gem.gems.haml-3.1.1.test.haml.engine_test.rb Maven / Gradle / Ivy

Go to download

#!/usr/bin/env ruby
# -*- coding: utf-8 -*-
require File.dirname(__FILE__) + '/../test_helper'

class EngineTest < Test::Unit::TestCase
  # A map of erroneous Haml documents to the error messages they should produce.
  # The error messages may be arrays;
  # if so, the second element should be the line number that should be reported for the error.
  # If this isn't provided, the tests will assume the line number should be the last line of the document.
  EXCEPTION_MAP = {
    "!!!\n  a" => "Illegal nesting: nesting within a header command is illegal.",
    "a\n  b" => "Illegal nesting: nesting within plain text is illegal.",
    "/ a\n  b" => "Illegal nesting: nesting within a tag that already has content is illegal.",
    "% a" => 'Invalid tag: "% a".',
    "%p a\n  b" => "Illegal nesting: content can't be both given on the same line as %p and nested within it.",
    "%p=" => "There's no Ruby code for = to evaluate.",
    "%p~" => "There's no Ruby code for ~ to evaluate.",
    "~" => "There's no Ruby code for ~ to evaluate.",
    "=" => "There's no Ruby code for = to evaluate.",
    "%p/\n  a" => "Illegal nesting: nesting within a self-closing tag is illegal.",
    ":a\n  b" => ['Filter "a" is not defined.', 1],
    ":a= b" => 'Invalid filter name ":a= b".',
    "." => "Illegal element: classes and ids must have values.",
    ".#" => "Illegal element: classes and ids must have values.",
    ".{} a" => "Illegal element: classes and ids must have values.",
    ".() a" => "Illegal element: classes and ids must have values.",
    ".= a" => "Illegal element: classes and ids must have values.",
    "%p..a" => "Illegal element: classes and ids must have values.",
    "%a/ b" => "Self-closing tags can't have content.",
    "%p{:a => 'b',\n:c => 'd'}/ e" => ["Self-closing tags can't have content.", 2],
    "%p{:a => 'b',\n:c => 'd'}=" => ["There's no Ruby code for = to evaluate.", 2],
    "%p.{:a => 'b',\n:c => 'd'} e" => ["Illegal element: classes and ids must have values.", 1],
    "%p{:a => 'b',\n:c => 'd',\n:e => 'f'}\n%p/ a" => ["Self-closing tags can't have content.", 4],
    "%p{:a => 'b',\n:c => 'd',\n:e => 'f'}\n- raise 'foo'" => ["foo", 4],
    "%p{:a => 'b',\n:c => raise('foo'),\n:e => 'f'}" => ["foo", 2],
    "%p{:a => 'b',\n:c => 'd',\n:e => raise('foo')}" => ["foo", 3],
    " %p foo" => "Indenting at the beginning of the document is illegal.",
    "  %p foo" => "Indenting at the beginning of the document is illegal.",
    "- end" => < ["Indenting at the beginning of the document is illegal.", 3],
    "\n\n %p foo" => ["Indenting at the beginning of the document is illegal.", 3],
    "%p\n  foo\n foo" => ["Inconsistent indentation: 1 space was used for indentation, but the rest of the document was indented using 2 spaces.", 3],
    "%p\n  foo\n%p\n foo" => ["Inconsistent indentation: 1 space was used for indentation, but the rest of the document was indented using 2 spaces.", 4],
    "%p\n\t\tfoo\n\tfoo" => ["Inconsistent indentation: 1 tab was used for indentation, but the rest of the document was indented using 2 tabs.", 3],
    "%p\n  foo\n   foo" => ["Inconsistent indentation: 3 spaces were used for indentation, but the rest of the document was indented using 2 spaces.", 3],
    "%p\n  foo\n  %p\n   bar" => ["Inconsistent indentation: 3 spaces were used for indentation, but the rest of the document was indented using 2 spaces.", 4],
    "%p\n  :plain\n     bar\n   \t  baz" => ['Inconsistent indentation: "   \t  " was used for indentation, but the rest of the document was indented using 2 spaces.', 4],
    "%p\n  foo\n%p\n    bar" => ["The line was indented 2 levels deeper than the previous line.", 4],
    "%p\n  foo\n  %p\n        bar" => ["The line was indented 3 levels deeper than the previous line.", 4],
    "%p\n \tfoo" => ["Indentation can't use both tabs and spaces.", 2],
    "%p(" => "Invalid attribute list: \"(\".",
    "%p(foo=\nbar)" => ["Invalid attribute list: \"(foo=\".", 1],
    "%p(foo=)" => "Invalid attribute list: \"(foo=)\".",
    "%p(foo 'bar')" => "Invalid attribute list: \"(foo 'bar')\".",
    "%p(foo 'bar'\nbaz='bang')" => ["Invalid attribute list: \"(foo 'bar'\".", 1],
    "%p(foo='bar'\nbaz 'bang'\nbip='bop')" => ["Invalid attribute list: \"(foo='bar' baz 'bang'\".", 2],
    "%p{:foo => 'bar' :bar => 'baz'}" => :compile,
    "%p{:foo => }" => :compile,
    "%p{=> 'bar'}" => :compile,
    "%p{:foo => 'bar}" => :compile,
    "%p{'foo => 'bar'}" => :compile,
    "%p{:foo => 'bar\"}" => :compile,

    # Regression tests
    "- raise 'foo'\n\n\n\nbar" => ["foo", 1],
    "= 'foo'\n-raise 'foo'" => ["foo", 2],
    "\n\n\n- raise 'foo'" => ["foo", 4],
    "%p foo |\n   bar |\n   baz |\nbop\n- raise 'foo'" => ["foo", 5],
    "foo\n\n\n  bar" => ["Illegal nesting: nesting within plain text is illegal.", 4],
    "%p/\n\n  bar" => ["Illegal nesting: nesting within a self-closing tag is illegal.", 3],
    "%p foo\n\n  bar" => ["Illegal nesting: content can't be both given on the same line as %p and nested within it.", 3],
    "/ foo\n\n  bar" => ["Illegal nesting: nesting within a tag that already has content is illegal.", 3],
    "!!!\n\n  bar" => ["Illegal nesting: nesting within a header command is illegal.", 3],
    "foo\n:ruby\n  1\n  2\n  3\n- raise 'foo'" => ["foo", 6],
    "foo\n:erb\n  1\n  2\n  3\n- raise 'foo'" => ["foo", 6],
    "foo\n:plain\n  1\n  2\n  3\n- raise 'foo'" => ["foo", 6],
    "foo\n:plain\n  1\n  2\n  3\n4\n- raise 'foo'" => ["foo", 7],
    "foo\n:plain\n  1\n  2\n  3\#{''}\n- raise 'foo'" => ["foo", 6],
    "foo\n:plain\n  1\n  2\n  3\#{''}\n4\n- raise 'foo'" => ["foo", 7],
    "foo\n:plain\n  1\n  2\n  \#{raise 'foo'}" => ["foo", 5],
    "= raise 'foo'\nfoo\nbar\nbaz\nbang" => ["foo", 1],
    "- case 1\n\n- when 1\n  - raise 'foo'" => ["foo", 4],
  }

  User = Struct.new('User', :id)
  class CustomHamlClass < Struct.new(:id)
    def haml_object_ref
      "my_thing"
    end
  end

  def render(text, options = {}, &block)
    scope  = options.delete(:scope)  || Object.new
    locals = options.delete(:locals) || {}
    engine(text, options).to_html(scope, locals, &block)
  end
  
  def engine(text, options = {})
    unless options[:filename]
      # use caller method name as fake filename. useful for debugging
      i = -1
      caller[i+=1] =~ /`(.+?)'/ until $1 and $1.index('test_') == 0
      options[:filename] = "(#{$1})"
    end
    Haml::Engine.new(text, options)
  end

  def setup
    return if Haml::Util.ruby1_8?
    @old_default_internal = Encoding.default_internal
    Encoding.default_internal = nil
  end

  def teardown
    return if Haml::Util.ruby1_8?
    Encoding.default_internal = @old_default_internal
  end

  def test_empty_render
    assert_equal "", render("")
  end

  def test_flexible_tabulation
    assert_equal("\n  foo\n
\n\n  bar\n  \n    baz\n  \n\n",
                 render("%p\n foo\n%q\n bar\n %a\n  baz"))
    assert_equal("\n  foo\n
\n\n  bar\n  \n    baz\n  \n\n",
                 render("%p\n\tfoo\n%q\n\tbar\n\t%a\n\t\tbaz"))
    assert_equal("\n      \t \t bar\n   baz\n\n",
                 render("%p\n  :plain\n        \t \t bar\n     baz"))
  end

  def test_empty_render_should_remain_empty
    assert_equal('', render(''))
  end

  def test_attributes_should_render_correctly
    assert_equal("", render(".atlantis{:style => 'ugly'}").chomp)
  end

  def test_css_id_as_attribute_should_be_appended_with_underscore
    assert_equal("", render("#my_id{:id => '1'}").chomp)
    assert_equal("", render("#my_id{:id => 1}").chomp)
  end

  def test_ruby_code_should_work_inside_attributes
    author = 'hcatlin'
    assert_equal("foo", render("%p{:class => 1+2} foo").chomp)
  end

  def test_class_attr_with_array
    assert_equal("foo\n", render("%p{:class => %w[a b]} foo")) # basic
    assert_equal("foo\n", render("%p.css{:class => %w[a b]} foo")) # merge with css
    assert_equal("foo\n", render("%p.css{:class => %w[css b]} foo")) # merge uniquely
    assert_equal("foo\n", render("%p{:class => [%w[a b], %w[c d]]} foo")) # flatten
    assert_equal("foo\n", render("%p{:class => [:a, :b] } foo")) # stringify
    assert_equal("foo\n", render("%p{:class => [nil, false] } foo")) # strip falsey
    assert_equal("foo\n", render("%p{:class => :a} foo")) # single stringify
    assert_equal("foo\n", render("%p{:class => false} foo")) # single falsey
    assert_equal("foo\n", render("%p(class='html'){:class => %w[a b]} foo")) # html attrs
  end

  def test_id_attr_with_array
    assert_equal("foo\n", render("%p{:id => %w[a b]} foo")) # basic
    assert_equal("foo\n", render("%p#css{:id => %w[a b]} foo")) # merge with css
    assert_equal("foo\n", render("%p{:id => [%w[a b], %w[c d]]} foo")) # flatten
    assert_equal("foo\n", render("%p{:id => [:a, :b] } foo")) # stringify
    assert_equal("foo\n", render("%p{:id => [nil, false] } foo")) # strip falsey
    assert_equal("foo\n", render("%p{:id => :a} foo")) # single stringify
    assert_equal("foo\n", render("%p{:id => false} foo")) # single falsey
    assert_equal("foo\n", render("%p(id='html'){:id => %w[a b]} foo")) # html attrs
  end

  def test_colon_in_class_attr
    assert_equal("\n", render("%p.foo:bar/"))
  end

  def test_colon_in_id_attr
    assert_equal("
\n", render("%p#foo:bar/"))
  end

  def test_dynamic_attributes_with_no_content
    assert_equal(<
  

HTML
%p
  %a{:href => "http://" + "haml-lang.com"}
HAML
  end

  def test_attributes_with_to_s
    assert_equal(<



HTML
%p#foo{:id => 1+1}
%p.foo{:class => 1+1}
%p{:blaz => 1+1}
%p{(1+1) => 1+1}
HAML
  end

  def test_nil_should_render_empty_tag
    assert_equal("",
                 render(".no_attributes{:nil => nil}").chomp)
  end

  def test_strings_should_get_stripped_inside_tags
    assert_equal("This should have no spaces in front of it",
                 render(".stripped    This should have no spaces in front of it").chomp)
  end

  def test_one_liner_should_be_one_line
    assert_equal("Hello", render('%p Hello').chomp)
  end

  def test_one_liner_with_newline_shouldnt_be_one_line
    assert_equal("\n  foo\n  bar\n", render('%p= "foo\nbar"').chomp)
  end

  def test_multi_render
    engine = engine("%strong Hi there!")
    assert_equal("Hi there!\n", engine.to_html)
    assert_equal("Hi there!\n", engine.to_html)
    assert_equal("Hi there!\n", engine.to_html)
  end

  def test_interpolation
    assert_equal("Hello World\n", render('%p Hello #{who}', :locals => {:who => 'World'}))
    assert_equal("\n  Hello World\n\n", render("%p\n  Hello \#{who}", :locals => {:who => 'World'}))
  end

  def test_interpolation_in_the_middle_of_a_string
    assert_equal("\"title 'Title'. \"\n",
                 render("\"title '\#{\"Title\"}'. \""))
  end

  def test_interpolation_at_the_beginning_of_a_line
    assert_equal("2\n", render('%p #{1 + 1}'))
    assert_equal("\n  2\n\n", render("%p\n  \#{1 + 1}"))
  end

  def test_escaped_interpolation
    assert_equal("Foo & Bar & Baz\n", render('%p& Foo #{"&"} Bar & Baz'))
  end

  def test_nil_tag_value_should_render_as_empty
    assert_equal("\n", render("%p= nil"))
  end

  def test_tag_with_failed_if_should_render_as_empty
    assert_equal("\n", render("%p= 'Hello' if false"))
  end

  def test_static_attributes_with_empty_attr
    assert_equal("\n", render("%img{:src => '/foo.png', :alt => ''}"))
  end

  def test_dynamic_attributes_with_empty_attr
    assert_equal("\n", render("%img{:width => nil, :src => '/foo.png', :alt => String.new}"))
  end

  def test_attribute_hash_with_newlines
    assert_equal("foop\n", render("%p{:a => 'b',\n   :c => 'd'} foop"))
    assert_equal("\n  foop\n\n", render("%p{:a => 'b',\n   :c => 'd'}\n  foop"))
    assert_equal("\n", render("%p{:a => 'b',\n   :c => 'd'}/"))
    assert_equal("
\n", render("%p{:a => 'b',\n   :c => 'd',\n   :e => 'f'}"))
  end

  def test_attr_hashes_not_modified
    hash = {:color => 'red'}
    assert_equal(< {:hash => hash}))



HTML
%div{hash}
.special{hash}
%div{hash}
HAML
    assert_equal(hash, {:color => 'red'})
  end

  def test_ugly_semi_prerendered_tags
    assert_equal(< true))

foo

foo
foo
bar
foo
bar

foo

HTML
%p{:a => 1 + 1}
%p{:a => 1 + 1} foo
%p{:a => 1 + 1}/
%p{:a => 1 + 1}= "foo"
%p{:a => 1 + 1}= "foo\\nbar"
%p{:a => 1 + 1}~ "foo\\nbar"
%p{:a => 1 + 1}
  foo
HAML
  end

  def test_end_of_file_multiline
    assert_equal("0
\n1
\n2\n", render("- for i in (0...3)\n  %p= |\n   i |"))
  end

  def test_cr_newline
    assert_equal("foo
\nbar
\nbaz
\nboom\n", render("%p foo\r%p bar\r\n%p baz\n\r%p boom"))
  end

  def test_textareas
    assert_equal("Foo
  bar
   baz\n",
                 render('%textarea= "Foo\n  bar\n   baz"'))

    assert_equal("Foo
  bar
   baz\n",
                 render('%pre= "Foo\n  bar\n   baz"'))

    assert_equal("#{'a' * 100}\n",
                 render("%textarea #{'a' * 100}"))

    assert_equal("\n  Foo\n  Bar\n  Baz\n
\n", render(<Foo
  bar
    baz


HTML
%pre
  %code
    :preserve
      Foo
        bar
          baz
HAML
  end

  def test_boolean_attributes
    assert_equal("\n",
                 render("%p{:foo => 'bar', :bar => true, :baz => 'true'}", :format => :html4))
    assert_equal("\n",
                 render("%p{:foo => 'bar', :bar => true, :baz => 'true'}", :format => :xhtml))

    assert_equal("\n",
                 render("%p{:foo => 'bar', :bar => false, :baz => 'false'}", :format => :html4))
    assert_equal("\n",
                 render("%p{:foo => 'bar', :bar => false, :baz => 'false'}", :format => :xhtml))
  end

  def test_both_whitespace_nukes_work_together
    assert_equal(<Foo
  Bar
RESULT
%p
  %q><= "Foo\\nBar"
SOURCE
  end

  def test_nil_option
    assert_equal("\n", render('%p{:foo => "bar"}', :attr_wrapper => nil))
  end

  # Regression tests

  def test_whitespace_nuke_with_both_newlines
    assert_equal("foo\n", render('%p<= "\nfoo\n"'))
    assert_equal(<
  foo

HTML
%p
  %p<= "\\nfoo\\n"
HAML
  end

  def test_whitespace_nuke_with_tags_and_else
    assert_equal(<
  foo

HTML
%a
  %b<
    - if false
      = "foo"
    - else
      foo
HAML

    assert_equal(<
  
    foo
  

HTML
%a
  %b
    - if false
      = "foo"
    - else
      foo
HAML
  end

  def test_outer_whitespace_nuke_with_empty_script
    assert_equal(<
  foo
HTML
%p
  foo
  = "  "
  %a>
HAML
  end

  def test_both_case_indentation_work_with_deeply_nested_code
    result = <
  other

RESULT
    assert_equal(result, render(< true))
= capture_haml do
  foo
HAML
  end

  def test_plain_equals_with_ugly
    assert_equal("foo\nbar\n", render(< true))
= "foo"
bar
HAML
  end

  def test_inline_if
    assert_equal(<One

Three
HTML
- for name in ["One", "Two", "Three"]
  %p= name unless name == "Two"
HAML
  end

  def test_end_with_method_call
    assert_equal(<
  2|3|4
  b-a-r

HTML
%p
  = [1, 2, 3].map do |i|
    - i + 1
  - end.join("|")
  = "bar".gsub(/./) do |s|
    - s + "-"
  - end.gsub(/-$/) do |s|
    - ''
HAML
  end

  def test_silent_end_with_stuff
    assert_equal(<hi!
HTML
- if true
  %p hi!
- end if "foo".gsub(/f/) do
  - "z"
- end + "bar"
HAML
  end

  def test_multiline_with_colon_after_filter
    assert_equal(< "Bar",      |
    :b => "Baz" }[:a] |
HAML
    assert_equal(< "Bar",      |
    :b => "Baz" }[:a] |
HAML
  end

  def test_multiline_in_filter
    assert_equal(< false))

  bar

HTML
#foo{:class => ''}
  bar
HAML
  end

  def test_escape_attrs_always
    assert_equal(< :always))

  bar

HTML
#foo{:class => '"<>&"'}
  bar
HAML
  end

  def test_escape_html
    html = < true))
&= "&"
!= "&"
= "&"
HAML

    assert_equal(html, render(< true))
&~ "&"
!~ "&"
~ "&"
HAML

    assert_equal(html, render(< true))
& \#{"&"}
! \#{"&"}
\#{"&"}
HAML

    assert_equal(html, render(< true))
&== \#{"&"}
!== \#{"&"}
== \#{"&"}
HAML

    tag_html = <&
&
&
HTML

    assert_equal(tag_html, render(< true))
%p&= "&"
%p!= "&"
%p= "&"
HAML

    assert_equal(tag_html, render(< true))
%p&~ "&"
%p!~ "&"
%p~ "&"
HAML

    assert_equal(tag_html, render(< true))
%p& \#{"&"}
%p! \#{"&"}
%p \#{"&"}
HAML

    assert_equal(tag_html, render(< true))
%p&== \#{"&"}
%p!== \#{"&"}
%p== \#{"&"}
HAML
  end

  def test_new_attrs_with_hash
    assert_equal("\n", render('%a(href="#")'))
  end

  def test_javascript_filter_with_dynamic_interp_and_escape_html
    assert_equal(< true))

HTML
:javascript
 & < > \#{"&"}
HAML
  end

  def test_html5_javascript_filter
    assert_equal(< :html5))

HTML
:javascript
  foo bar
HAML
  end

  def test_html5_css_filter
    assert_equal(< :html5))

HTML
:css
  foo bar
HAML
  end

  def test_erb_filter_with_multiline_expr
    assert_equal(<
HAML
  end

  def test_silent_script_with_hyphen_case
    assert_equal("", render("- 'foo-case-bar-case'"))
  end

  def test_silent_script_with_hyphen_end
    assert_equal("", render("- 'foo-end-bar-end'"))
  end

  def test_silent_script_with_hyphen_end_and_block
    assert_equal(<foo-end
bar-end
HTML
- ("foo-end-bar-end".gsub(/\\w+-end/) do |s|
  %p= s
- end; nil)
HAML
  end

  def test_if_without_content_and_else
    assert_equal(<Foo\n",
      render('%a(href="#" rel="top") Foo'))
    assert_equal("Foo\n",
      render('%a(href="#") #{"Foo"}'))

    assert_equal("\n", render('%a(href="#\\"")'))
  end

  def test_filter_with_newline_and_interp
    assert_equal(< true))
foo,
HTML
foo\#{"," if true}
HAML
  end

  # HTML escaping tests

  def test_ampersand_equals_should_escape
    assert_equal("\n  foo & bar\n\n", render("%p\n  &= 'foo & bar'", :escape_html => false))
  end

  def test_ampersand_equals_inline_should_escape
    assert_equal("foo & bar\n", render("%p&= 'foo & bar'", :escape_html => false))
  end

  def test_ampersand_equals_should_escape_before_preserve
    assert_equal("foo
bar\n", render('%textarea&= "foo\nbar"', :escape_html => false))
  end

  def test_bang_equals_should_not_escape
    assert_equal("\n  foo & bar\n\n", render("%p\n  != 'foo & bar'", :escape_html => true))
  end

  def test_bang_equals_inline_should_not_escape
    assert_equal("foo & bar\n", render("%p!= 'foo & bar'", :escape_html => true))
  end
  
  def test_static_attributes_should_be_escaped
    assert_equal("\n",
                 render("%img.atlantis{:style => 'ugly&stupid'}"))
    assert_equal("foo\n",
                 render(".atlantis{:style => 'ugly&stupid'} foo"))
    assert_equal("foo\n",
                render("%p.atlantis{:style => 'ugly&stupid'}= 'foo'"))
    assert_equal("\n",
                render("%p.atlantis{:style => \"ugly\\nstupid\"}"))
  end

  def test_dynamic_attributes_should_be_escaped
    assert_equal("\n",
                 render("%img{:width => nil, :src => '&foo.png', :alt => String.new}"))
    assert_equal("foo\n",
                 render("%p{:width => nil, :src => '&foo.png', :alt => String.new} foo"))
    assert_equal("foo\n",
                 render("%div{:width => nil, :src => '&foo.png', :alt => String.new}= 'foo'"))
    assert_equal("\n",
                 render("%img{:width => nil, :src => \"foo\\n.png\", :alt => String.new}"))
  end

  def test_string_double_equals_should_be_esaped
    assert_equal("4&<\n", render("%p== \#{2+2}&\#{'<'}", :escape_html => true))
    assert_equal("4&<\n", render("%p== \#{2+2}&\#{'<'}", :escape_html => false))
  end

  def test_escaped_inline_string_double_equals
    assert_equal("4&<\n", render("%p&== \#{2+2}&\#{'<'}", :escape_html => true))
    assert_equal("4&<\n", render("%p&== \#{2+2}&\#{'<'}", :escape_html => false))
  end

  def test_unescaped_inline_string_double_equals
    assert_equal("4&<\n", render("%p!== \#{2+2}&\#{'<'}", :escape_html => true))
    assert_equal("4&<\n", render("%p!== \#{2+2}&\#{'<'}", :escape_html => false))
  end

  def test_escaped_string_double_equals
    assert_equal("\n  4&<\n\n", render("%p\n  &== \#{2+2}&\#{'<'}", :escape_html => true))
    assert_equal("\n  4&<\n\n", render("%p\n  &== \#{2+2}&\#{'<'}", :escape_html => false))
  end

  def test_unescaped_string_double_equals
    assert_equal("\n  4&<\n\n", render("%p\n  !== \#{2+2}&\#{'<'}", :escape_html => true))
    assert_equal("\n  4&<\n\n", render("%p\n  !== \#{2+2}&\#{'<'}", :escape_html => false))
  end

  def test_string_interpolation_should_be_esaped
    assert_equal("4&<\n", render("%p \#{2+2}&\#{'<'}", :escape_html => true))
    assert_equal("4&<\n", render("%p \#{2+2}&\#{'<'}", :escape_html => false))
  end

  def test_escaped_inline_string_interpolation
    assert_equal("4&<\n", render("%p& \#{2+2}&\#{'<'}", :escape_html => true))
    assert_equal("4&<\n", render("%p& \#{2+2}&\#{'<'}", :escape_html => false))
  end

  def test_unescaped_inline_string_interpolation
    assert_equal("4&<\n", render("%p! \#{2+2}&\#{'<'}", :escape_html => true))
    assert_equal("4&<\n", render("%p! \#{2+2}&\#{'<'}", :escape_html => false))
  end

  def test_escaped_string_interpolation
    assert_equal("\n  4&<\n\n", render("%p\n  & \#{2+2}&\#{'<'}", :escape_html => true))
    assert_equal("\n  4&<\n\n", render("%p\n  & \#{2+2}&\#{'<'}", :escape_html => false))
  end

  def test_unescaped_string_interpolation
    assert_equal("\n  4&<\n\n", render("%p\n  ! \#{2+2}&\#{'<'}", :escape_html => true))
    assert_equal("\n  4&<\n\n", render("%p\n  ! \#{2+2}&\#{'<'}", :escape_html => false))
  end

  def test_scripts_should_respect_escape_html_option
    assert_equal("\n  foo & bar\n\n", render("%p\n  = 'foo & bar'", :escape_html => true))
    assert_equal("\n  foo & bar\n\n", render("%p\n  = 'foo & bar'", :escape_html => false))
  end

  def test_inline_scripts_should_respect_escape_html_option
    assert_equal("foo & bar\n", render("%p= 'foo & bar'", :escape_html => true))
    assert_equal("foo & bar\n", render("%p= 'foo & bar'", :escape_html => false))
  end

  def test_script_ending_in_comment_should_render_when_html_is_escaped
    assert_equal("foo&bar\n", render("= 'foo&bar' #comment", :escape_html => true))
  end

  def test_script_with_if_shouldnt_output
    assert_equal(<foo

HTML
%p= "foo"
%p= "bar" if false
HAML
  end

  # Options tests

  def test_filename_and_line
    begin
      render("\n\n = abc", :filename => 'test', :line => 2)
    rescue Exception => e
      assert_kind_of Haml::SyntaxError, e
      assert_match(/test:4/, e.backtrace.first)
    end

    begin
      render("\n\n= 123\n\n= nil[]", :filename => 'test', :line => 2)
    rescue Exception => e
      assert_kind_of NoMethodError, e
      assert_match(/test:6/, e.backtrace.first)
    end
  end

  def test_stop_eval
    assert_equal("", render("= 'Hello'", :suppress_eval => true))
    assert_equal("", render("- haml_concat 'foo'", :suppress_eval => true))
    assert_equal("

\n", render("#foo{:yes => 'no'}/", :suppress_eval => true))
    assert_equal("

\n", render("#foo{:yes => 'no', :call => a_function() }/", :suppress_eval => true))
    assert_equal("\n", render("%div[1]/", :suppress_eval => true))
    assert_equal("", render(":ruby\n  Kernel.puts 'hello'", :suppress_eval => true))
  end

  def test_doctypes
    assert_equal('',
      render('!!!', :format => :html5).strip)
    assert_equal('', render('!!! 5').strip)
    assert_equal('',
      render('!!! strict').strip)
    assert_equal('',
      render('!!! frameset').strip)
    assert_equal('',
      render('!!! mobile').strip)
    assert_equal('',
      render('!!! basic').strip)
    assert_equal('',
      render('!!! transitional').strip)
    assert_equal('',
      render('!!!').strip)
    assert_equal('',
      render('!!! strict', :format => :html4).strip)
    assert_equal('',
      render('!!! frameset', :format => :html4).strip)
    assert_equal('',
      render('!!! transitional', :format => :html4).strip)
    assert_equal('',
      render('!!!', :format => :html4).strip)
  end

  def test_attr_wrapper
    assert_equal("\n", render("%p{ :strange => 'attrs'}", :attr_wrapper => '*'))
    assert_equal("\n", render("%p{ :escaped => 'quo\"te'}", :attr_wrapper => '"'))
    assert_equal("\n", render("%p{ :escaped => 'quo\\'te'}", :attr_wrapper => '"'))
    assert_equal("\n", render("%p{ :escaped => 'q\\'uo\"te'}", :attr_wrapper => '"'))
    assert_equal("\n", render("!!! XML", :attr_wrapper => '"'))
  end

  def test_autoclose_option
    assert_equal("\n", render("%flaz{:foo => 'bar'}", :autoclose => ["flaz"]))
    assert_equal(< [/^flaz/]))



HTML
%flaz
%flaznicate
%flan
HAML
  end

  def test_attrs_parsed_correctly
    assert_equal("biddly='bar => baz'>\n", render("%p{'boom=>biddly' => 'bar => baz'}"))
    assert_equal("\n", render("%p{'foo,bar' => 'baz, qux'}"))
    assert_equal("\n", render("%p{ :escaped => \"quo\\nte\"}"))
    assert_equal("\n", render("%p{ :escaped => \"quo\#{2 + 2}te\"}"))
  end

  def test_correct_parsing_with_brackets
    assert_equal("{tada} foo\n", render("%p{:class => 'foo'} {tada} foo"))
    assert_equal("deep {nested { things }}\n", render("%p{:class => 'foo'} deep {nested { things }}"))
    assert_equal("{a { d\n", render("%p{{:class => 'foo'}, :class => 'bar'} {a { d"))
    assert_equal("a}\n", render("%p{:foo => 'bar'} a}"))
    
    foo = []
    foo[0] = Struct.new('Foo', :id).new
    assert_equal("New User]\n",
                 render("%p[foo[0]] New User]", :locals => {:foo => foo}))
    assert_equal("New User]\n",
                 render("%p[foo[0], :prefix] New User]", :locals => {:foo => foo}))

    foo[0].id = 1
    assert_equal("New User]\n",
                 render("%p[foo[0]] New User]", :locals => {:foo => foo}))
    assert_equal("New User]\n",
                 render("%p[foo[0], :prefix] New User]", :locals => {:foo => foo}))
  end
  
  def test_empty_attrs
    assert_equal("empty\n", render("%p{ :attr => '' } empty"))
    assert_equal("empty\n", render("%p{ :attr => x } empty", :locals => {:x => ''}))
  end
  
  def test_nil_attrs
    assert_equal("nil\n", render("%p{ :attr => nil } nil"))
    assert_equal("nil\n", render("%p{ :attr => x } nil", :locals => {:x => nil}))
  end

  def test_nil_id_with_syntactic_id
    assert_equal("nil\n", render("%p#foo{:id => nil} nil"))
    assert_equal("nil\n", render("%p#foo{{:id => 'bar'}, :id => nil} nil"))
    assert_equal("nil\n", render("%p#foo{{:id => nil}, :id => 'bar'} nil"))
  end

  def test_nil_class_with_syntactic_class
    assert_equal("nil\n", render("%p.foo{:class => nil} nil"))
    assert_equal("nil\n", render("%p.bar.foo{:class => nil} nil"))
    assert_equal("nil\n", render("%p.foo{{:class => 'bar'}, :class => nil} nil"))
    assert_equal("nil\n", render("%p.foo{{:class => nil}, :class => 'bar'} nil"))
  end

  def test_locals
    assert_equal("Paragraph!\n", render("%p= text", :locals => { :text => "Paragraph!" }))
  end

  def test_dynamic_attrs_shouldnt_register_as_literal_values
    assert_equal("\n", render('%p{:a => "b#{1 + 1}c"}'))
    assert_equal("\n", render("%p{:a => 'b' + (1 + 1).to_s + 'c'}"))
  end

  def test_dynamic_attrs_with_self_closed_tag
    assert_equal("\nc\n", render("%a{'b' => 1 + 1}/\n= 'c'\n"))
  end

  EXCEPTION_MAP.each do |key, value|
    define_method("test_exception (#{key.inspect})") do
      begin
        render(key, :filename => __FILE__)
      rescue Exception => err
        value = [value] unless value.is_a?(Array)
        expected_message, line_no = value
        line_no ||= key.split("\n").length

        if expected_message == :compile
          if Haml::Util.ruby1_8?
            assert_match(/^compile error\n/, err.message, "Line: #{key}")
          else
            assert_match(/^#{Regexp.quote __FILE__}:#{line_no}: syntax error,/, err.message, "Line: #{key}")
          end
        else
          assert_equal(expected_message, err.message, "Line: #{key}")
        end

        if Haml::Util.ruby1_8?
          # Sometimes, the first backtrace entry is *only* in the message.
          # No idea why.
          bt =
            if expected_message == :compile && err.message.include?("\n")
              err.message.split("\n", 2)[1]
            else
              err.backtrace[0]
            end
          assert_match(/^#{Regexp.escape(__FILE__)}:#{line_no}/, bt, "Line: #{key}")
        end
      else
        assert(false, "Exception not raised for\n#{key}")
      end
    end
  end

  def test_exception_line
    render("a\nb\n!!!\n  c\nd")
  rescue Haml::SyntaxError => e
    assert_equal("(test_exception_line):4", e.backtrace[0])
  else
    assert(false, '"a\nb\n!!!\n  c\nd" doesn\'t produce an exception')
  end

  def test_exception
    render("%p\n  hi\n  %a= undefined\n= 12")
  rescue Exception => e
    assert_match("(test_exception):3", e.backtrace[0])
  else
    # Test failed... should have raised an exception
    assert(false)
  end

  def test_compile_error
    render("a\nb\n- fee)\nc")
  rescue Exception => e
    assert_match(/\(test_compile_error\):3: syntax error/i, e.message)
  else
    assert(false,
           '"a\nb\n- fee)\nc" doesn\'t produce an exception!')
  end

  def test_unbalanced_brackets
    render('foo #{1 + 5} foo #{6 + 7 bar #{8 + 9}')
  rescue Haml::SyntaxError => e
    assert_equal("Unbalanced brackets.", e.message)
  end

  def test_balanced_conditional_comments
    assert_equal("\n",
                 render("/[if !(IE 6)|(IE 7)] Bracket: ]"))
  end

  def test_empty_filter
    assert_equal(<
  //

END
  end

  def test_ugly_filter
    assert_equal(< true))
#foo {
  bar: baz; }
END
  end

  def test_css_filter
    assert_equal(<
  /**/

HTML
:css
  #foo {
    bar: baz; }
HAML
  end

  def test_local_assigns_dont_modify_class
    assert_equal("bar\n", render("= foo", :locals => {:foo => 'bar'}))
    assert_equal(nil, defined?(foo))
  end

  def test_object_ref_with_nil_id
    user = User.new
    assert_equal("New User\n",
                 render("%p[user] New User", :locals => {:user => user}))
  end

  def test_object_ref_before_attrs
    user = User.new 42
    assert_equal("New User\n",
                 render("%p[user]{:style => 'width: 100px;'} New User", :locals => {:user => user}))
  end

  def test_object_ref_with_custom_haml_class
    custom = CustomHamlClass.new 42
    assert_equal("My Thing\n",
                 render("%p[custom]{:style => 'width: 100px;'} My Thing", :locals => {:custom => custom}))
  end

  def test_non_literal_attributes
    assert_equal("\n",
                 render("%p{a2, a1, :a3 => 'baz'}/",
                        :locals => {:a1 => {:a1 => 'foo'}, :a2 => {:a2 => 'bar'}}))
  end

  def test_render_should_accept_a_binding_as_scope
    string = "This is a string!"
    string.instance_variable_set("@var", "Instance variable")
    b = string.instance_eval do
      var = "Local variable"
      binding
    end

    assert_equal("
THIS IS A STRING!
\nInstance variable
\nLocal variable\n",
                 render("%p= upcase\n%p= @var\n%p= var", :scope => b))
  end

  def test_yield_should_work_with_binding
    assert_equal("12\nFOO\n", render("= yield\n= upcase", :scope => "foo".instance_eval{binding}) { 12 })
  end

  def test_yield_should_work_with_def_method
    s = "foo"
    engine("= yield\n= upcase").def_method(s, :render)
    assert_equal("12\nFOO\n", s.render { 12 })
  end

  def test_def_method_with_module
    engine("= yield\n= upcase").def_method(String, :render_haml)
    assert_equal("12\nFOO\n", "foo".render_haml { 12 })
  end

  def test_def_method_locals
    obj = Object.new
    engine("%p= foo\n.bar{:baz => baz}= boom").def_method(obj, :render, :foo, :baz, :boom)
    assert_equal("1
\n3\n", obj.render(:foo => 1, :baz => 2, :boom => 3))
  end

  def test_render_proc_locals
    proc = engine("%p= foo\n.bar{:baz => baz}= boom").render_proc(Object.new, :foo, :baz, :boom)
    assert_equal("1
\n3\n", proc[:foo => 1, :baz => 2, :boom => 3])
  end

  def test_render_proc_with_binding
    assert_equal("FOO\n", engine("= upcase").render_proc("foo".instance_eval{binding}).call)
  end

  def test_haml_buffer_gets_reset_even_with_exception
    scope = Object.new
    render("- raise Haml::Error", :scope => scope)
    assert(false, "Expected exception")
  rescue Exception
    assert_nil(scope.send(:haml_buffer))
  end

  def test_def_method_haml_buffer_gets_reset_even_with_exception
    scope = Object.new
    engine("- raise Haml::Error").def_method(scope, :render)
    scope.render
    assert(false, "Expected exception")
  rescue Exception
    assert_nil(scope.send(:haml_buffer))
  end

  def test_render_proc_haml_buffer_gets_reset_even_with_exception
    scope = Object.new
    proc = engine("- raise Haml::Error").render_proc(scope)
    proc.call
    assert(false, "Expected exception")
  rescue Exception
    assert_nil(scope.send(:haml_buffer))
  end

  def test_ugly_true
    assert_equal("\n\nhello world
\n
\n\n",
                 render("#outer\n  #inner\n    %p hello world", :ugly => true))

    assert_equal("#{'s' * 75}\n",
                 render("%p #{'s' * 75}", :ugly => true))

    assert_equal("#{'s' * 75}\n",
                 render("%p= 's' * 75", :ugly => true))
  end

  def test_auto_preserve_unless_ugly
    assert_equal("foo
bar\n", render('%pre="foo\nbar"'))
    assert_equal("foo\nbar\n", render("%pre\n  foo\n  bar"))
    assert_equal("foo\nbar\n", render('%pre="foo\nbar"', :ugly => true))
    assert_equal("foo\nbar\n", render("%pre\n  foo\n  bar", :ugly => true))
  end

  def test_xhtml_output_option
    assert_equal "\n  
\n\n", render("%p\n  %br", :format => :xhtml)
    assert_equal "\n", render("%a/", :format => :xhtml)
  end

  def test_arbitrary_output_option
    assert_raise_message(Haml::Error, "Invalid output format :html1") do
      engine("%br", :format => :html1)
    end
  end

  def test_static_hashes
    assert_equal("\n", render("%a{:b => 'a => b'}", :suppress_eval => true))
    assert_equal("\n", render("%a{:b => 'a, b'}", :suppress_eval => true))
    assert_equal("\n", render('%a{:b => "a\tb"}', :suppress_eval => true))
    assert_equal("\n", render('%a{:b => "a\\#{foo}b"}', :suppress_eval => true))
  end

  def test_dynamic_hashes_with_suppress_eval
    assert_equal("\n", render('%a{:b => "a #{1 + 1} b", :c => "d"}', :suppress_eval => true))
  end

  def test_utf8_attrs
    assert_equal("\n", render("%a{:href => 'héllo'}"))
    assert_equal("\n", render("%a(href='héllo')"))
  end

  # HTML 4.0

  def test_html_has_no_self_closing_tags
    assert_equal "\n  
\n\n", render("%p\n  %br", :format => :html4)
    assert_equal "
\n", render("%br/", :format => :html4)
  end

  def test_html_renders_empty_node_with_closing_tag
    assert_equal "\n", render(".foo", :format => :html4)
  end

  def test_html_doesnt_add_slash_to_self_closing_tags
    assert_equal "\n", render("%a/", :format => :html4)
    assert_equal "\n", render("%a{:foo => 1 + 1}/", :format => :html4)
    assert_equal "\n", render("%meta", :format => :html4)
    assert_equal "\n", render("%meta{:foo => 1 + 1}", :format => :html4)
  end

  def test_html_ignores_xml_prolog_declaration
    assert_equal "", render('!!! XML', :format => :html4)
  end

  def test_html_has_different_doctype
    assert_equal %{\n},
    render('!!!', :format => :html4)
  end

  # because anything before the doctype triggers quirks mode in IE
  def test_xml_prolog_and_doctype_dont_result_in_a_leading_whitespace_in_html
    assert_no_match(/^\s+/, render("!!! xml\n!!!", :format => :html4))
  end

  # HTML5
  def test_html5_doctype
    assert_equal %{\n}, render('!!!', :format => :html5)
  end

  # HTML5 custom data attributes
  def test_html5_data_attributes
    assert_equal("\n",
      render("%div{:data => {:author_id => 123, :foo => 'bar', :biz => 'baz'}}"))

    assert_equal("\n",
      render("%div{:data => {:one_plus_one => 1+1}}"))

    assert_equal("\n",
      render(%{%div{:data => {:foo => %{Here's a "quoteful" string.}}}})) #'
  end

  def test_html5_data_attributes_with_multiple_defs
    # Should always use the more-explicit attribute
    assert_equal("\n",
      render("%div{:data => {:foo => 'first'}, 'data-foo' => 'second'}"))
    assert_equal("\n",
      render("%div{'data-foo' => 'first', :data => {:foo => 'second'}}"))
  end

  def test_html5_data_attributes_with_attr_method
    Haml::Helpers.module_eval do
      def data_hash
        {:data => {:foo => "bar", :baz => "bang"}}
      end

      def data_val
        {:data => "dat"}
      end
    end

    assert_equal("\n",
      render("%div{data_hash, :data => {:foo => 'blip', :brat => 'wurst'}}"))
    assert_equal("\n",
      render("%div{data_hash, 'data-foo' => 'blip'}"))
    assert_equal("\n",
      render("%div{data_hash, :data => 'dat'}"))
    assert_equal("\n",
      render("%div{data_val, :data => {:foo => 'blip', :brat => 'wurst'}}"))
  end

  # New attributes

  def test_basic_new_attributes
    assert_equal("bar\n", render("%a() bar"))
    assert_equal("bar\n", render("%a(href='foo') bar"))
    assert_equal("baz\n", render(%q{%a(b="c" c='d' d="e") baz}))
  end

  def test_new_attribute_ids
    assert_equal("\n", render("#foo(id='bar')"))
    assert_equal("\n", render("#foo{:id => 'bar'}(id='baz')"))
    assert_equal("\n", render("#foo(id='baz'){:id => 'bar'}"))
    foo = User.new(42)
    assert_equal("\n",
      render("#foo(id='baz'){:id => 'bar'}[foo]", :locals => {:foo => foo}))
    assert_equal("\n",
      render("#foo(id='baz')[foo]{:id => 'bar'}", :locals => {:foo => foo}))
    assert_equal("\n",
      render("#foo[foo](id='baz'){:id => 'bar'}", :locals => {:foo => foo}))
    assert_equal("\n",
      render("#foo[foo]{:id => 'bar'}(id='baz')", :locals => {:foo => foo}))
  end

  def test_new_attribute_classes
    assert_equal("\n", render(".foo(class='bar')"))
    assert_equal("\n", render(".foo{:class => 'bar'}(class='baz')"))
    assert_equal("\n", render(".foo(class='baz'){:class => 'bar'}"))
    foo = User.new(42)
    assert_equal("\n",
      render(".foo(class='baz'){:class => 'bar'}[foo]", :locals => {:foo => foo}))
    assert_equal("\n",
      render(".foo[foo](class='baz'){:class => 'bar'}", :locals => {:foo => foo}))
    assert_equal("\n",
      render(".foo[foo]{:class => 'bar'}(class='baz')", :locals => {:foo => foo}))
  end

  def test_dynamic_new_attributes
    assert_equal("bar\n", render("%a(href=foo) bar", :locals => {:foo => 12}))
    assert_equal("bar\n", render("%a(b=b c='13' d=d) bar", :locals => {:b => 12, :d => 14}))
  end

  def test_new_attribute_interpolation
    assert_equal("bar\n", render('%a(href="1#{1 + 1}") bar'))
    assert_equal("bar\n", render(%q{%a(href='2: #{1 + 1}, 3: #{foo}') bar}, :locals => {:foo => 3}))
    assert_equal(%Q{bar\n}, render('%a(href="1\#{1 + 1}") bar'))
  end

  def test_truthy_new_attributes
    assert_equal("bar\n", render("%a(href) bar"))
    assert_equal("bar\n", render("%a(href bar='baz') bar", :format => :html5))
    assert_equal("bar\n", render("%a(href=true) bar"))
    assert_equal("bar\n", render("%a(href=false) bar"))
  end

  def test_new_attribute_parsing
    assert_equal("bar\n", render("%a(a2=b2) bar", :locals => {:b2 => 'b2'}))
    assert_equal(%Q{bar\n}, render(%q{%a(a="#{'foo"bar'}") bar})) #'
    assert_equal(%Q{bar\n}, render(%q{%a(a="#{"foo'bar"}") bar})) #'
    assert_equal(%Q{bar\n}, render(%q{%a(a='foo"bar') bar}))
    assert_equal(%Q{bar\n}, render(%q{%a(a="foo'bar") bar}))
    assert_equal("bar\n", render("%a(a:b='foo') bar"))
    assert_equal("bar\n", render("%a(a = 'foo' b = 'bar') bar"))
    assert_equal("bar\n", render("%a(a = foo b = bar) bar", :locals => {:foo => 'foo', :bar => 'bar'}))
    assert_equal("(b='bar')\n", render("%a(a='foo')(b='bar')"))
    assert_equal("baz\n", render("%a(a='foo)bar') baz"))
    assert_equal("baz\n", render("%a( a = 'foo' ) baz"))
  end

  def test_new_attribute_escaping
    assert_equal(%Q{bar\n}, render(%q{%a(a="foo \" bar") bar}))
    assert_equal(%Q{bar\n}, render(%q{%a(a="foo \\\\\" bar") bar}))

    assert_equal(%Q{bar\n}, render(%q{%a(a='foo \' bar') bar}))
    assert_equal(%Q{bar\n}, render(%q{%a(a='foo \\\\\' bar') bar}))

    assert_equal(%Q{bar\n}, render(%q{%a(a="foo \\\\ bar") bar}))
    assert_equal(%Q{bar\n}, render(%q{%a(a="foo \#{1 + 1} bar") bar}))
  end

  def test_multiline_new_attribute
    assert_equal("bar\n", render("%a(a='b'\n  c='d') bar"))
    assert_equal("bar\n",
      render("%a(a='b' b='c'\n  c='d' d=e\n  e='f' f='j') bar", :locals => {:e => 'e'}))
  end

  def test_new_and_old_attributes
    assert_equal("bar\n", render("%a(a='b'){:c => 'd'} bar"))
    assert_equal("bar\n", render("%a{:c => 'd'}(a='b') bar"))
    assert_equal("bar\n", render("%a(c='d'){:a => 'b'} bar"))
    assert_equal("bar\n", render("%a{:a => 'b'}(c='d') bar"))

    # Old-style always takes precedence over new-style,
    # because theoretically old-style could have arbitrary end-of-method-call syntax.
    assert_equal("bar\n", render("%a{:a => 'b'}(a='d') bar"))
    assert_equal("bar\n", render("%a(a='d'){:a => 'b'} bar"))

    assert_equal("bar\n",
      render("%a{:a => 'b',\n:b => 'c'}(c='d'\nd='e') bar"))

    locals = {:b => 'b', :d => 'd'}
    assert_equal("\n", render("%p{:a => b}(c=d)", :locals => locals))
    assert_equal("\n", render("%p(a=b){:c => d}", :locals => locals))
  end

  # Ruby Multiline

  def test_silent_ruby_multiline
    assert_equal(<foo
HTML
- foo = ["bar",
         "baz",
         "bang"]
= foo.join(", ")
%p foo
HAML
  end

  def test_loud_ruby_multiline
    assert_equal(<foo
bar
HTML
= ["bar",
   "baz",
   "bang"].join(", ")
%p foo
%p bar
HAML
  end

  def test_escaped_loud_ruby_multiline
    assert_equal(<foo
bar
HTML
&= ["bar<",
    "baz",
    "bang"].join(", ")
%p foo
%p bar
HAML
  end

  def test_unescaped_loud_ruby_multiline
    assert_equal(< true))
bar<, baz, bang
foo
bar
HTML
!= ["bar<",
    "baz",
    "bang"].join(", ")
%p foo
%p bar
HAML
  end

  def test_flattened_loud_ruby_multiline
    assert_equal(<bar
baz
bang
foo
bar
HTML
~ "" + ["bar",
             "baz",
             "bang"].join("\\n") + ""
%p foo
%p bar
HAML
  end

  def test_loud_ruby_multiline_with_block
    assert_equal(<foo
bar
HTML
= ["bar",
   "baz",
   "bang"].map do |str|
  - str.gsub("ba",
             "fa")
%p foo
%p bar
HAML
  end

  def test_silent_ruby_multiline_with_block
    assert_equal(<foo
bar
HTML
- ["bar",
   "baz",
   "bang"].map do |str|
  = str.gsub("ba",
             "fa")
%p foo
%p bar
HAML
  end

  def test_ruby_multiline_in_tag
    assert_equal(<foo, bar, baz
foo
bar
HTML
%p= ["foo",
     "bar",
     "baz"].join(", ")
%p foo
%p bar
HAML
  end

  def test_escaped_ruby_multiline_in_tag
    assert_equal(<foo<, bar, baz
foo
bar
HTML
%p&= ["foo<",
      "bar",
      "baz"].join(", ")
%p foo
%p bar
HAML
  end

  def test_unescaped_ruby_multiline_in_tag
    assert_equal(< true))
foo<, bar, baz
foo
bar
HTML
%p!= ["foo<",
      "bar",
      "baz"].join(", ")
%p foo
%p bar
HAML
  end

  def test_ruby_multiline_with_normal_multiline
    assert_equal(<foo
bar
HTML
= "foo" + |
  "bar" + |
  ["bar", |
   "baz",
   "bang"].join(", ")
%p foo
%p bar
HAML
  end

  def test_ruby_multiline_after_filter
    assert_equal(<foo
bar
HTML
:plain
  foo
  bar
= ["bar",
   "baz",
   "bang"].join(", ")
%p foo
%p bar
HAML
  end

  # Encodings

  def test_utf_8_bom
    assert_equal <
  baz

HTML
\xEF\xBB\xBF.foo
  %p baz
HAML
  end

  unless Haml::Util.ruby1_8?
    def test_default_encoding
      assert_equal(Encoding.find("utf-8"), render(< "ascii-8bit"))
bâr
föö
HTML
%p bâr
%p föö
HAML
    end

    def test_convert_template_render_proc
      assert_converts_template_properly {|e| e.render_proc.call}
    end

    def test_convert_template_render
      assert_converts_template_properly {|e| e.render}
    end

    def test_convert_template_def_method
      assert_converts_template_properly do |e|
        o = Object.new
        e.def_method(o, :render)
        o.render
      end
    end

    def test_encoding_error
      render("foo\nbar\nb\xFEaz".force_encoding("utf-8"))
      assert(false, "Expected exception")
    rescue Haml::Error => e
      assert_equal(3, e.line)
      assert_equal('Invalid UTF-8 character "\xFE"', e.message)
    end

    def test_ascii_incompatible_encoding_error
      template = "foo\nbar\nb_z".encode("utf-16le")
      template[9] = "\xFE".force_encoding("utf-16le")
      render(template)
      assert(false, "Expected exception")
    rescue Haml::Error => e
      assert_equal(3, e.line)
      assert_equal('Invalid UTF-16LE character "\xFE"', e.message)
    end

    def test_same_coding_comment_as_encoding
      assert_renders_encoded(<bâr
föö
HTML
-# coding: utf-8
%p bâr
%p föö
HAML
    end

    def test_coding_comments
      assert_valid_encoding_comment("-# coding: ibm866")
      assert_valid_encoding_comment("-# CodINg: IbM866")
      assert_valid_encoding_comment("-#coding:ibm866")
      assert_valid_encoding_comment("-# CodINg= ibm866")
      assert_valid_encoding_comment("-# foo BAR FAOJcoding: ibm866")
      assert_valid_encoding_comment("-# coding: ibm866 ASFJ (&(&#!$")
      assert_valid_encoding_comment("-# -*- coding: ibm866")
      assert_valid_encoding_comment("-# coding: ibm866 -*- coding: blah")
      assert_valid_encoding_comment("-# -*- coding: ibm866 -*-")
      assert_valid_encoding_comment("-# -*- encoding: ibm866 -*-")
      assert_valid_encoding_comment('-# -*- coding: "ibm866" -*-')
      assert_valid_encoding_comment("-#-*-coding:ibm866-*-")
      assert_valid_encoding_comment("-#-*-coding:ibm866-*-")
      assert_valid_encoding_comment("-# -*- foo: bar; coding: ibm866; baz: bang -*-")
      assert_valid_encoding_comment("-# foo bar coding: baz -*- coding: ibm866 -*-")
      assert_valid_encoding_comment("-# -*- coding: ibm866 -*- foo bar coding: baz")
    end

    def test_different_coding_than_system
      assert_renders_encoded(<тАЬ
HTML
%p тАЬ
HAML
    end
  end

  private

  def assert_valid_encoding_comment(comment)
    assert_renders_encoded(<ЖЛЫ
тАЬ
HTML
#{comment}
%p ЖЛЫ
%p тАЬ
HAML
  end

  def assert_converts_template_properly
    engine = Haml::Engine.new(< "macRoman")
%p bâr
%p föö
HAML
    assert_encoded_equal(<bâr
föö
HTML
  end

  def assert_renders_encoded(html, haml)
    result = render(haml)
    assert_encoded_equal html, result
  end

  def assert_encoded_equal(expected, actual)
    assert_equal expected.encoding, actual.encoding
    assert_equal expected, actual
  end
end