classicCMS 0.1.2

data/vendor/bundle/gems/sass-3.1.15/test/sass/engine_test.rb

@@ -0,0 +1,2711 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/test_helper'
+require 'sass/engine'
+require 'stringio'
+require 'mock_importer'
+require 'pathname'
+
+module Sass::Script::Functions::UserFunctions
+  def option(name)
+    Sass::Script::String.new(@options[name.value.to_sym].to_s)
+  end
+end
+
+class SassEngineTest < Test::Unit::TestCase
+  FAKE_FILE_NAME = __FILE__.gsub(/rb$/,"sass")
+  # A map of erroneous Sass 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 = {
+    "$a: 1 + " => 'Invalid CSS after "1 +": expected expression (e.g. 1px, bold), was ""',
+    "$a: 1 + 2 +" => 'Invalid CSS after "1 + 2 +": expected expression (e.g. 1px, bold), was ""',
+    "$a: 1 + 2 + %" => 'Invalid CSS after "1 + 2 + ": expected expression (e.g. 1px, bold), was "%"',
+    "$a: foo(\"bar\"" => 'Invalid CSS after "foo("bar"": expected ")", was ""',
+    "$a: 1 }" => 'Invalid CSS after "1 ": expected expression (e.g. 1px, bold), was "}"',
+    "$a: 1 }foo\"" => 'Invalid CSS after "1 ": expected expression (e.g. 1px, bold), was "}foo""',
+    ":" => 'Invalid property: ":".',
+    ": a" => 'Invalid property: ": a".',
+    "a\n  :b" => <<MSG,
+Invalid property: ":b" (no value).
+If ":b" should be a selector, use "\\:b" instead.
+MSG
+    "a\n  b:" => 'Invalid property: "b:" (no value).',
+    "a\n  :b: c" => 'Invalid property: ":b: c".',
+    "a\n  :b:c d" => 'Invalid property: ":b:c d".',
+    "a\n  :b c;" => 'Invalid CSS after "c": expected expression (e.g. 1px, bold), was ";"',
+    "a\n  b: c;" => 'Invalid CSS after "c": expected expression (e.g. 1px, bold), was ";"',
+    ".foo ^bar\n  a: b" => ['Invalid CSS after ".foo ": expected selector, was "^bar"', 1],
+    "a\n  @extend .foo ^bar" => 'Invalid CSS after ".foo ": expected selector, was "^bar"',
+    "a: b" => 'Properties are only allowed within rules, directives, or other properties.',
+    ":a b" => 'Properties are only allowed within rules, directives, or other properties.',
+    "$" => 'Invalid variable: "$".',
+    "$a" => 'Invalid variable: "$a".',
+    "$ a" => 'Invalid variable: "$ a".',
+    "$a b" => 'Invalid variable: "$a b".',
+    "$a: 1b + 2c" => "Incompatible units: 'c' and 'b'.",
+    "$a: 1b < 2c" => "Incompatible units: 'c' and 'b'.",
+    "$a: 1b > 2c" => "Incompatible units: 'c' and 'b'.",
+    "$a: 1b <= 2c" => "Incompatible units: 'c' and 'b'.",
+    "$a: 1b >= 2c" => "Incompatible units: 'c' and 'b'.",
+    "a\n  b: 1b * 2c" => "2b*c isn't a valid CSS value.",
+    "a\n  b: 1b % 2c" => "Cannot modulo by a number with units: 2c.",
+    "$a: 2px + #ccc" => "Cannot add a number with units (2px) to a color (#cccccc).",
+    "$a: #ccc + 2px" => "Cannot add a number with units (2px) to a color (#cccccc).",
+    "& a\n  :b c" => ["Base-level rules cannot contain the parent-selector-referencing character '&'.", 1],
+    "a\n  :b\n    c" => "Illegal nesting: Only properties may be nested beneath properties.",
+    "$a: b\n  :c d\n" => "Illegal nesting: Nothing may be nested beneath variable declarations.",
+    "$a: b\n  :c d\n" => "Illegal nesting: Nothing may be nested beneath variable declarations.",
+    "@import templates/basic\n  foo" => "Illegal nesting: Nothing may be nested beneath import directives.",
+    "foo\n  @import foo.css" => "CSS import directives may only be used at the root of a document.",
+    "@if true\n  @import foo" => "Import directives may not be used within control directives or mixins.",
+    "@mixin foo\n  @import foo" => "Import directives may not be used within control directives or mixins.",
+    "@import foo;" => "Invalid @import: expected end of line, was \";\".",
+    '$foo: "bar" "baz" !' => %Q{Invalid CSS after ""bar" "baz" ": expected expression (e.g. 1px, bold), was "!"},
+    '$foo: "bar" "baz" $' => %Q{Invalid CSS after ""bar" "baz" ": expected expression (e.g. 1px, bold), was "$"},
+    "=foo\n  :color red\n.bar\n  +bang" => "Undefined mixin 'bang'.",
+    "=foo\n  :color red\n.bar\n  +bang_bop" => "Undefined mixin 'bang_bop'.",
+    "=foo\n  :color red\n.bar\n  +bang-bop" => "Undefined mixin 'bang-bop'.",
+    ".bar\n  =foo\n    :color red\n" => ["Mixins may only be defined at the root of a document.", 2],
+    "=foo\n  :color red\n.bar\n  +foo\n    :color red" => "Illegal nesting: Nothing may be nested beneath mixin directives.",
+    "    a\n  b: c" => ["Indenting at the beginning of the document is illegal.", 1],
+    " \n   \n\t\n  a\n  b: c" => ["Indenting at the beginning of the document is illegal.", 4],
+    "a\n  b: c\n b: c" => ["Inconsistent indentation: 1 space was used for indentation, but the rest of the document was indented using 2 spaces.", 3],
+    "a\n  b: c\na\n b: c" => ["Inconsistent indentation: 1 space was used for indentation, but the rest of the document was indented using 2 spaces.", 4],
+    "a\n\t\tb: c\n\tb: c" => ["Inconsistent indentation: 1 tab was used for indentation, but the rest of the document was indented using 2 tabs.", 3],
+    "a\n  b: c\n   b: c" => ["Inconsistent indentation: 3 spaces were used for indentation, but the rest of the document was indented using 2 spaces.", 3],
+    "a\n  b: c\n  a\n   d: e" => ["Inconsistent indentation: 3 spaces were used for indentation, but the rest of the document was indented using 2 spaces.", 4],
+    "a\n  b: c\na\n    d: e" => ["The line was indented 2 levels deeper than the previous line.", 4],
+    "a\n  b: c\n  a\n        d: e" => ["The line was indented 3 levels deeper than the previous line.", 4],
+    "a\n \tb: c" => ["Indentation can't use both tabs and spaces.", 2],
+    "=a(" => 'Invalid CSS after "(": expected variable (e.g. $foo), was ""',
+    "=a(b)" => 'Invalid CSS after "(": expected variable (e.g. $foo), was "b)"',
+    "=a(,)" => 'Invalid CSS after "(": expected variable (e.g. $foo), was ",)"',
+    "=a($)" => 'Invalid CSS after "(": expected variable (e.g. $foo), was "$)"',
+    "=a($foo bar)" => 'Invalid CSS after "($foo ": expected ")", was "bar)"',
+    "=foo\n  bar: baz\n+foo" => ["Properties are only allowed within rules, directives, or other properties.", 2],
+    "a-\#{$b\n  c: d" => ['Invalid CSS after "a-#{$b": expected "}", was ""', 1],
+    "=a($b: 1, $c)" => "Required argument $c must come before any optional arguments.",
+    "=a($b: 1)\n  a: $b\ndiv\n  +a(1,2)" => "Mixin a takes 1 argument but 2 were passed.",
+    "=a($b: 1)\n  a: $b\ndiv\n  +a(1,$c: 3)" => "Mixin a doesn't have an argument named $c",
+    "=a($b)\n  a: $b\ndiv\n  +a" => "Mixin a is missing parameter $b.",
+    "@function foo()\n  1 + 2" => "Functions can only contain variable declarations and control directives.",
+    "@function foo()\n  foo: bar" => "Functions can only contain variable declarations and control directives.",
+    "@function foo()\n  foo: bar\n  @return 3" => ["Functions can only contain variable declarations and control directives.", 2],
+    "@function foo\n  @return 1" => ['Invalid CSS after "": expected "(", was ""', 1],
+    "@function foo(\n  @return 1" => ['Invalid CSS after "(": expected variable (e.g. $foo), was ""', 1],
+    "@function foo(b)\n  @return 1" => ['Invalid CSS after "(": expected variable (e.g. $foo), was "b)"', 1],
+    "@function foo(,)\n  @return 1" => ['Invalid CSS after "(": expected variable (e.g. $foo), was ",)"', 1],
+    "@function foo($)\n  @return 1" => ['Invalid CSS after "(": expected variable (e.g. $foo), was "$)"', 1],
+    "@function foo()\n  @return" => 'Invalid @return: expected expression.',
+    "@function foo()\n  @return 1\n    $var: val" => 'Illegal nesting: Nothing may be nested beneath return directives.',
+    "foo\n  @function bar()\n    @return 1" => ['Functions may only be defined at the root of a document.', 2],
+    "@function foo($a)\n  @return 1\na\n  b: foo()" => 'Function foo is missing parameter $a.',
+    "@function foo()\n  @return 1\na\n  b: foo(2)" => 'Wrong number of arguments (1 for 0) for `foo\'',
+    "@return 1" => '@return may only be used within a function.',
+    "@if true\n  @return 1" => '@return may only be used within a function.',
+    "@mixin foo\n  @return 1\n@include foo" => ['@return may only be used within a function.', 2],
+    "@else\n  a\n    b: c" => ["@else must come after @if.", 1],
+    "@if false\n@else foo" => "Invalid else directive '@else foo': expected 'if <expr>'.",
+    "@if false\n@else if " => "Invalid else directive '@else if': expected 'if <expr>'.",
+    "a\n  $b: 12\nc\n  d: $b" => 'Undefined variable: "$b".',
+    "=foo\n  $b: 12\nc\n  +foo\n  d: $b" => 'Undefined variable: "$b".',
+    "c\n  d: $b-foo" => 'Undefined variable: "$b-foo".',
+    "c\n  d: $b_foo" => 'Undefined variable: "$b_foo".',
+    '@for $a from "foo" to 1' => '"foo" is not an integer.',
+    '@for $a from 1 to "2"' => '"2" is not an integer.',
+    '@for $a from 1 to "foo"' => '"foo" is not an integer.',
+    '@for $a from 1 to 1.232323' => '1.232 is not an integer.',
+    '@for $a from 1px to 3em' => "Incompatible units: 'em' and 'px'.",
+    '@if' => "Invalid if directive '@if': expected expression.",
+    '@while' => "Invalid while directive '@while': expected expression.",
+    '@debug' => "Invalid debug directive '@debug': expected expression.",
+    %Q{@debug "a message"\n  "nested message"} => "Illegal nesting: Nothing may be nested beneath debug directives.",
+    '@warn' => "Invalid warn directive '@warn': expected expression.",
+    %Q{@warn "a message"\n  "nested message"} => "Illegal nesting: Nothing may be nested beneath warn directives.",
+    "/* foo\n    bar\n  baz" => "Inconsistent indentation: previous line was indented by 4 spaces, but this line was indented by 2 spaces.",
+    '+foo(1 + 1: 2)' => 'Invalid CSS after "(1 + 1": expected comma, was ": 2)"',
+    '+foo($var: )' => 'Invalid CSS after "($var: ": expected mixin argument, was ")"',
+    '+foo($var: a, $var: b)' => 'Keyword argument "$var" passed more than once',
+    '+foo($var-var: a, $var_var: b)' => 'Keyword argument "$var-var" passed more than once',
+    '+foo($var_var: a, $var-var: b)' => 'Keyword argument "$var_var" passed more than once',
+    "a\n  b: foo(1 + 1: 2)" => 'Invalid CSS after "foo(1 + 1": expected comma, was ": 2)"',
+    "a\n  b: foo($var: )" => 'Invalid CSS after "foo($var: ": expected function argument, was ")"',
+    "a\n  b: foo($var: a, $var: b)" => 'Keyword argument "$var" passed more than once',
+    "a\n  b: foo($var-var: a, $var_var: b)" => 'Keyword argument "$var-var" passed more than once',
+    "a\n  b: foo($var_var: a, $var-var: b)" => 'Keyword argument "$var_var" passed more than once',
+    "@if foo\n  @extend .bar" => ["Extend directives may only be used within rules.", 2],
+    "$var: true\n@while $var\n  @extend .bar\n  $var: false" => ["Extend directives may only be used within rules.", 3],
+    "@for $i from 0 to 1\n  @extend .bar" => ["Extend directives may only be used within rules.", 2],
+    "@mixin foo\n  @extend .bar\n@include foo" => ["Extend directives may only be used within rules.", 2],
+
+    # Regression tests
+    "a\n  b:\n    c\n    d" => ["Illegal nesting: Only properties may be nested beneath properties.", 3],
+    "& foo\n  bar: baz\n  blat: bang" => ["Base-level rules cannot contain the parent-selector-referencing character '&'.", 1],
+    "a\n  b: c\n& foo\n  bar: baz\n  blat: bang" => ["Base-level rules cannot contain the parent-selector-referencing character '&'.", 3],
+  }
+
+  def teardown
+    clean_up_sassc
+  end
+
+  def test_basic_render
+    renders_correctly "basic", { :style => :compact }
+  end
+
+  def test_empty_render
+    assert_equal "", render("")
+  end
+
+  def test_multiple_calls_to_render
+    sass = Sass::Engine.new("a\n  b: c")
+    assert_equal sass.render, sass.render
+  end
+
+  def test_alternate_styles
+    renders_correctly "expanded", { :style => :expanded }
+    renders_correctly "compact", { :style => :compact }
+    renders_correctly "nested", { :style => :nested }
+    renders_correctly "compressed", { :style => :compressed }
+  end
+
+  def test_compile
+    assert_equal "div { hello: world; }\n", Sass.compile("$who: world\ndiv\n  hello: $who", :syntax => :sass, :style => :compact)
+    assert_equal "div { hello: world; }\n", Sass.compile("$who: world; div { hello: $who }", :style => :compact)
+  end
+
+  def test_compile_file
+    FileUtils.mkdir_p(absolutize("tmp"))
+    open(absolutize("tmp/test_compile_file.sass"), "w") {|f| f.write("$who: world\ndiv\n  hello: $who")}
+    open(absolutize("tmp/test_compile_file.scss"), "w") {|f| f.write("$who: world; div { hello: $who }")}
+    assert_equal "div { hello: world; }\n", Sass.compile_file(absolutize("tmp/test_compile_file.sass"), :style => :compact)
+    assert_equal "div { hello: world; }\n", Sass.compile_file(absolutize("tmp/test_compile_file.scss"), :style => :compact)
+  ensure
+    FileUtils.rm_rf(absolutize("tmp"))
+  end
+
+  def test_compile_file_to_css_file
+    FileUtils.mkdir_p(absolutize("tmp"))
+    open(absolutize("tmp/test_compile_file.sass"), "w") {|f| f.write("$who: world\ndiv\n  hello: $who")}
+    open(absolutize("tmp/test_compile_file.scss"), "w") {|f| f.write("$who: world; div { hello: $who }")}
+    Sass.compile_file(absolutize("tmp/test_compile_file.sass"), absolutize("tmp/test_compile_file_sass.css"), :style => :compact)
+    Sass.compile_file(absolutize("tmp/test_compile_file.scss"), absolutize("tmp/test_compile_file_scss.css"), :style => :compact)
+    assert_equal "div { hello: world; }\n", File.read(absolutize("tmp/test_compile_file_sass.css"))
+    assert_equal "div { hello: world; }\n", File.read(absolutize("tmp/test_compile_file_scss.css"))
+  ensure
+    FileUtils.rm_rf(absolutize("tmp"))
+  end
+  
+  def test_flexible_tabulation
+    assert_equal("p {\n  a: b; }\n  p q {\n    c: d; }\n",
+                 render("p\n a: b\n q\n  c: d\n"))
+    assert_equal("p {\n  a: b; }\n  p q {\n    c: d; }\n",
+                 render("p\n\ta: b\n\tq\n\t\tc: d\n"))
+  end
+  
+  EXCEPTION_MAP.each do |key, value|
+    define_method("test_exception (#{key.inspect})") do
+      line = 10
+      begin
+        silence_warnings {Sass::Engine.new(key, :filename => FAKE_FILE_NAME, :line => line).render}
+      rescue Sass::SyntaxError => err
+        value = [value] unless value.is_a?(Array)
+
+        assert_equal(value.first.rstrip, err.message, "Line: #{key}")
+        assert_equal(FAKE_FILE_NAME, err.sass_filename)
+        assert_equal((value[1] || key.split("\n").length) + line - 1, err.sass_line, "Line: #{key}")
+        assert_match(/#{Regexp.escape(FAKE_FILE_NAME)}:[0-9]+/, err.backtrace[0], "Line: #{key}")
+      else
+        assert(false, "Exception not raised for\n#{key}")
+      end
+    end
+  end
+
+  def test_exception_line
+    to_render = <<SASS
+rule
+  :prop val
+  // comment!
+
+  :broken
+SASS
+    begin
+      Sass::Engine.new(to_render).render
+    rescue Sass::SyntaxError => err
+      assert_equal(5, err.sass_line)
+    else
+      assert(false, "Exception not raised for '#{to_render}'!")
+    end
+  end
+
+  def test_exception_location
+    to_render = <<SASS
+rule
+  :prop val
+  // comment!
+
+  :broken
+SASS
+    begin
+      Sass::Engine.new(to_render, :filename => FAKE_FILE_NAME, :line => (__LINE__-7)).render
+    rescue Sass::SyntaxError => err
+      assert_equal(FAKE_FILE_NAME, err.sass_filename)
+      assert_equal((__LINE__-6), err.sass_line)
+    else
+      assert(false, "Exception not raised for '#{to_render}'!")
+    end
+  end
+
+  def test_imported_exception
+    [1, 2, 3, 4, 5].each do |i|
+      begin
+        Sass::Engine.new("@import bork#{i}", :load_paths => [File.dirname(__FILE__) + '/templates/']).render
+      rescue Sass::SyntaxError => err
+        assert_equal(2, err.sass_line)
+        assert_match(/(\/|^)bork#{i}\.sass$/, err.sass_filename)
+
+        assert_hash_has(err.sass_backtrace.first,
+          :filename => err.sass_filename, :line => err.sass_line)
+
+        assert_nil(err.sass_backtrace[1][:filename])
+        assert_equal(1, err.sass_backtrace[1][:line])
+
+        assert_match(/(\/|^)bork#{i}\.sass:2$/, err.backtrace.first)
+        assert_equal("(sass):1", err.backtrace[1])
+      else
+        assert(false, "Exception not raised for imported template: bork#{i}")
+      end
+    end
+  end
+
+  def test_double_imported_exception
+    [1, 2, 3, 4, 5].each do |i|
+      begin
+        Sass::Engine.new("@import nested_bork#{i}", :load_paths => [File.dirname(__FILE__) + '/templates/']).render
+      rescue Sass::SyntaxError => err
+        assert_equal(2, err.sass_line)
+        assert_match(/(\/|^)bork#{i}\.sass$/, err.sass_filename)
+
+        assert_hash_has(err.sass_backtrace.first,
+          :filename => err.sass_filename, :line => err.sass_line)
+
+        assert_match(/(\/|^)nested_bork#{i}\.sass$/, err.sass_backtrace[1][:filename])
+        assert_equal(2, err.sass_backtrace[1][:line])
+
+        assert_nil(err.sass_backtrace[2][:filename])
+        assert_equal(1, err.sass_backtrace[2][:line])
+
+        assert_match(/(\/|^)bork#{i}\.sass:2$/, err.backtrace.first)
+        assert_match(/(\/|^)nested_bork#{i}\.sass:2$/, err.backtrace[1])
+        assert_equal("(sass):1", err.backtrace[2])
+      else
+        assert(false, "Exception not raised for imported template: bork#{i}")
+      end
+    end
+  end
+
+  def test_selector_tracing
+    actual_css = render(<<-SCSS, :syntax => :scss, :trace_selectors => true)
+      @mixin mixed {
+        .mixed { color: red; }
+      }
+      .context {
+        @include mixed;
+      }
+    SCSS
+    assert_equal(<<CSS,actual_css)
+/* on line 2 of test_selector_tracing_inline.scss, in `mixed'
+   from line 5 of test_selector_tracing_inline.scss */
+.context .mixed {
+  color: red; }
+CSS
+  end
+
+  def test_mixin_exception
+    render(<<SASS)
+=error-mixin($a)
+  color: $a * 1em * 1px
+
+=outer-mixin($a)
+  +error-mixin($a)
+
+.error
+  +outer-mixin(12)
+SASS
+    assert(false, "Exception not raised")
+  rescue Sass::SyntaxError => err
+    assert_equal(2, err.sass_line)
+    assert_equal(filename_for_test, err.sass_filename)
+    assert_equal("error-mixin", err.sass_mixin)
+
+    assert_hash_has(err.sass_backtrace.first, :line => err.sass_line,
+      :filename => err.sass_filename, :mixin => err.sass_mixin)
+    assert_hash_has(err.sass_backtrace[1], :line => 5,
+      :filename => filename_for_test, :mixin => "outer-mixin")
+    assert_hash_has(err.sass_backtrace[2], :line => 8,
+      :filename => filename_for_test, :mixin => nil)
+
+    assert_equal("#{filename_for_test}:2:in `error-mixin'", err.backtrace.first)
+    assert_equal("#{filename_for_test}:5:in `outer-mixin'", err.backtrace[1])
+    assert_equal("#{filename_for_test}:8", err.backtrace[2])
+  end
+
+  def test_mixin_callsite_exception
+    render(<<SASS)
+=one-arg-mixin($a)
+  color: $a
+
+=outer-mixin($a)
+  +one-arg-mixin($a, 12)
+
+.error
+  +outer-mixin(12)
+SASS
+    assert(false, "Exception not raised")
+  rescue Sass::SyntaxError => err
+    assert_hash_has(err.sass_backtrace.first, :line => 5,
+      :filename => filename_for_test, :mixin => "one-arg-mixin")
+    assert_hash_has(err.sass_backtrace[1], :line => 5,
+      :filename => filename_for_test, :mixin => "outer-mixin")
+    assert_hash_has(err.sass_backtrace[2], :line => 8,
+      :filename => filename_for_test, :mixin => nil)
+  end
+
+  def test_mixin_exception_cssize
+    render(<<SASS)
+=parent-ref-mixin
+  & foo
+    a: b
+
+=outer-mixin
+  +parent-ref-mixin
+
++outer-mixin
+SASS
+    assert(false, "Exception not raised")
+  rescue Sass::SyntaxError => err
+    assert_hash_has(err.sass_backtrace.first, :line => 2,
+      :filename => filename_for_test, :mixin => "parent-ref-mixin")
+    assert_hash_has(err.sass_backtrace[1], :line => 6,
+      :filename => filename_for_test, :mixin => "outer-mixin")
+    assert_hash_has(err.sass_backtrace[2], :line => 8,
+      :filename => filename_for_test, :mixin => nil)
+  end
+
+  def test_mixin_and_import_exception
+    Sass::Engine.new("@import nested_mixin_bork", :load_paths => [File.dirname(__FILE__) + '/templates/']).render
+    assert(false, "Exception not raised")
+  rescue Sass::SyntaxError => err
+    assert_match(/(\/|^)nested_mixin_bork\.sass$/, err.sass_backtrace.first[:filename])
+    assert_hash_has(err.sass_backtrace.first, :mixin => "error-mixin", :line => 4)
+
+    assert_match(/(\/|^)mixin_bork\.sass$/, err.sass_backtrace[1][:filename])
+    assert_hash_has(err.sass_backtrace[1], :mixin => "outer-mixin", :line => 2)
+
+    assert_match(/(\/|^)mixin_bork\.sass$/, err.sass_backtrace[2][:filename])
+    assert_hash_has(err.sass_backtrace[2], :mixin => nil, :line => 5)
+
+    assert_match(/(\/|^)nested_mixin_bork\.sass$/, err.sass_backtrace[3][:filename])
+    assert_hash_has(err.sass_backtrace[3], :mixin => nil, :line => 6)
+
+    assert_hash_has(err.sass_backtrace[4], :filename => nil, :mixin => nil, :line => 1)
+  end
+
+  def test_basic_mixin_loop_exception
+    render <<SASS
+@mixin foo
+  @include foo
+@include foo
+SASS
+    assert(false, "Exception not raised")
+  rescue Sass::SyntaxError => err
+    assert_equal("An @include loop has been found: foo includes itself", err.message)
+    assert_hash_has(err.sass_backtrace[0], :mixin => "foo", :line => 2)
+  end
+
+  def test_double_mixin_loop_exception
+    render <<SASS
+@mixin foo
+  @include bar
+@mixin bar
+  @include foo
+@include foo
+SASS
+    assert(false, "Exception not raised")
+  rescue Sass::SyntaxError => err
+    assert_equal(<<MESSAGE.rstrip, err.message)
+An @include loop has been found:
+    foo includes bar
+    bar includes foo
+MESSAGE
+    assert_hash_has(err.sass_backtrace[0], :mixin => "bar", :line => 4)
+    assert_hash_has(err.sass_backtrace[1], :mixin => "foo", :line => 2)
+  end
+
+  def test_deep_mixin_loop_exception
+    render <<SASS
+@mixin foo
+  @include bar
+
+@mixin bar
+  @include baz
+
+@mixin baz
+  @include foo
+
+@include foo
+SASS
+    assert(false, "Exception not raised")
+  rescue Sass::SyntaxError => err
+    assert_equal(<<MESSAGE.rstrip, err.message)
+An @include loop has been found:
+    foo includes bar
+    bar includes baz
+    baz includes foo
+MESSAGE
+    assert_hash_has(err.sass_backtrace[0], :mixin => "baz", :line => 8)
+    assert_hash_has(err.sass_backtrace[1], :mixin => "bar", :line => 5)
+    assert_hash_has(err.sass_backtrace[2], :mixin => "foo", :line => 2)
+  end
+
+  def test_basic_import_loop_exception
+    import = filename_for_test
+    importer = MockImporter.new
+    importer.add_import(import, "@import '#{import}'")
+
+    engine = Sass::Engine.new("@import '#{import}'", :filename => import,
+      :load_paths => [importer])
+
+    assert_raise_message(Sass::SyntaxError, <<ERR.rstrip) {engine.render}
+An @import loop has been found: #{import} imports itself
+ERR
+  end
+
+  def test_double_import_loop_exception
+    importer = MockImporter.new
+    importer.add_import("foo", "@import 'bar'")
+    importer.add_import("bar", "@import 'foo'")
+
+    engine = Sass::Engine.new('@import "foo"', :filename => filename_for_test,
+      :load_paths => [importer])
+
+    assert_raise_message(Sass::SyntaxError, <<ERR.rstrip) {engine.render}
+An @import loop has been found:
+    #{filename_for_test} imports foo
+    foo imports bar
+    bar imports foo
+ERR
+  end
+
+  def test_deep_import_loop_exception
+    importer = MockImporter.new
+    importer.add_import("foo", "@import 'bar'")
+    importer.add_import("bar", "@import 'baz'")
+    importer.add_import("baz", "@import 'foo'")
+
+    engine = Sass::Engine.new('@import "foo"', :filename => filename_for_test,
+      :load_paths => [importer])
+
+    assert_raise_message(Sass::SyntaxError, <<ERR.rstrip) {engine.render}
+An @import loop has been found:
+    #{filename_for_test} imports foo
+    foo imports bar
+    bar imports baz
+    baz imports foo
+ERR
+  end
+
+  def test_exception_css_with_offset
+    opts = {:full_exception => true, :line => 362}
+    render(("a\n  b: c\n" * 10) + "d\n  e:\n" + ("f\n  g: h\n" * 10), opts)
+  rescue Sass::SyntaxError => e
+    assert_equal(<<CSS, Sass::SyntaxError.exception_to_css(e, opts).split("\n")[0..15].join("\n"))
+/*
+Syntax error: Invalid property: "e:" (no value).
+        on line 383 of test_exception_css_with_offset_inline.sass
+
+378: a
+379:   b: c
+380: a
+381:   b: c
+382: d
+383:   e:
+384: f
+385:   g: h
+386: f
+387:   g: h
+388: f
+CSS
+  else
+    assert(false, "Exception not raised for test_exception_css_with_offset")
+  end
+
+  def test_exception_css_with_mixins
+    opts = {:full_exception => true}
+    render(<<SASS, opts)
+=error-mixin($a)
+  color: $a * 1em * 1px
+
+=outer-mixin($a)
+  +error-mixin($a)
+
+.error
+  +outer-mixin(12)
+SASS
+  rescue Sass::SyntaxError => e
+    assert_equal(<<CSS, Sass::SyntaxError.exception_to_css(e, opts).split("\n")[0..13].join("\n"))
+/*
+Syntax error: 12em*px isn't a valid CSS value.
+        on line 2 of test_exception_css_with_mixins_inline.sass, in `error-mixin'
+        from line 5 of test_exception_css_with_mixins_inline.sass, in `outer-mixin'
+        from line 8 of test_exception_css_with_mixins_inline.sass
+
+1: =error-mixin($a)
+2:   color: $a * 1em * 1px
+3: 
+4: =outer-mixin($a)
+5:   +error-mixin($a)
+6: 
+7: .error
+CSS
+  else
+    assert(false, "Exception not raised")
+  end
+
+  def test_cssize_exception_css
+    opts = {:full_exception => true}
+    render(<<SASS, opts)
+.filler
+  stuff: "stuff!"
+
+a: b
+
+.more.filler
+  a: b
+SASS
+  rescue Sass::SyntaxError => e
+    assert_equal(<<CSS, Sass::SyntaxError.exception_to_css(e, opts).split("\n")[0..11].join("\n"))
+/*
+Syntax error: Properties are only allowed within rules, directives, or other properties.
+        on line 4 of test_cssize_exception_css_inline.sass
+
+1: .filler
+2:   stuff: "stuff!"
+3: 
+4: a: b
+5: 
+6: .more.filler
+7:   a: b
+CSS
+  else
+    assert(false, "Exception not raised")
+  end
+
+  def test_css_import
+    assert_equal("@import url(./fonts.css);\n", render("@import \"./fonts.css\""))
+  end
+
+  def test_http_import
+    assert_equal("@import \"http://fonts.googleapis.com/css?family=Droid+Sans\";\n",
+      render("@import \"http://fonts.googleapis.com/css?family=Droid+Sans\""))
+  end
+
+  def test_import_with_interpolation
+    assert_warning(<<WARNING) do
+DEPRECATION WARNING on line 2 of test_import_with_interpolation_inline.sass:
+@import directives using \#{} interpolation will need to use url() in Sass 3.2.
+For example:
+
+  @import url("http://\#{$url}/style.css");
+WARNING
+      assert_equal("@import \"http://fonts.googleapis.com/css?family=Droid+Sans\";\n",
+        render("$family: unquote(\"Droid+Sans\")\n@import \"http://fonts.googleapis.com/css?family=\#{$family}\"\n"))
+    end
+    assert_equal("@import url(\"http://fonts.googleapis.com/css?family=Droid+Sans\");\n",
+      render("$family: unquote(\"Droid+Sans\")\n@import url(\"http://fonts.googleapis.com/css?family=\#{$family}\")\n"))
+  end
+
+  def test_url_import
+    assert_equal("@import url(fonts.sass);\n", render("@import url(fonts.sass)"))
+  end
+
+  def test_sass_import
+    sassc_file = sassc_path("importee")
+    assert !File.exists?(sassc_file)
+    renders_correctly "import", { :style => :compact, :load_paths => [File.dirname(__FILE__) + "/templates"] }
+    assert File.exists?(sassc_file)
+  end
+
+  def test_sass_pathname_import
+    sassc_file = sassc_path("importee")
+    assert !File.exists?(sassc_file)
+    renders_correctly("import",
+      :style => :compact,
+      :load_paths => [Pathname.new(File.dirname(__FILE__) + "/templates")])
+    assert File.exists?(sassc_file)
+  end
+
+  def test_nonexistent_import
+    assert_raise_message(Sass::SyntaxError, <<ERR.rstrip) do
+File to import not found or unreadable: nonexistent.sass.
+Load path: #{Dir.pwd}
+ERR
+      render("@import nonexistent.sass")
+    end
+  end
+
+  def test_nonexistent_extensionless_import
+    assert_raise_message(Sass::SyntaxError, <<ERR.rstrip) do
+File to import not found or unreadable: nonexistent.
+Load path: #{Dir.pwd}
+ERR
+      render("@import nonexistent")
+    end
+  end
+
+  def test_no_cache
+    assert !File.exists?(sassc_path("importee"))
+    renders_correctly("import", {
+        :style => :compact, :cache => false,
+        :load_paths => [File.dirname(__FILE__) + "/templates"],
+      })
+    assert !File.exists?(sassc_path("importee"))
+  end
+
+  def test_import_in_rule
+    assert_equal(<<CSS, render(<<SASS, :load_paths => [File.dirname(__FILE__) + '/templates/']))
+.foo #foo {
+  background-color: #bbaaff; }
+
+.bar {
+  a: b; }
+  .bar #foo {
+    background-color: #bbaaff; }
+CSS
+.foo
+  @import partial
+
+.bar
+  a: b
+  @import partial
+SASS
+  end
+
+  def test_nested_import_with_toplevel_constructs
+    Sass::Engine.new(".foo\n  @import importee", :load_paths => [File.dirname(__FILE__) + '/templates/']).render
+  rescue Sass::SyntaxError => err
+    assert_equal(3, err.sass_line)
+    assert_match(/(\/|^)importee\.sass$/, err.sass_filename)
+
+    assert_hash_has(err.sass_backtrace.first,
+      :filename => err.sass_filename, :line => err.sass_line)
+
+    assert_nil(err.sass_backtrace[1][:filename])
+    assert_equal(2, err.sass_backtrace[1][:line])
+
+    assert_match(/(\/|^)importee\.sass:3$/, err.backtrace.first)
+    assert_equal("(sass):2", err.backtrace[1])
+  else
+    assert(false, "Exception not raised for importing mixins nested")
+  end
+
+  def test_units
+    renders_correctly "units"
+  end
+
+  def test_default_function
+    assert_equal(<<CSS, render(<<SASS))
+foo {
+  bar: url("foo.png"); }
+CSS
+foo
+  bar: url("foo.png")
+SASS
+    assert_equal("foo {\n  bar: url(); }\n", render("foo\n  bar: url()\n"));
+  end
+
+  def test_string_minus
+    assert_equal("foo {\n  bar: baz-boom-bat; }\n", render(%Q{foo\n  bar: baz-boom-bat}))
+    assert_equal("foo {\n  bar: -baz-boom; }\n", render(%Q{foo\n  bar: -baz-boom}))
+  end
+
+  def test_string_div
+    assert_equal("foo {\n  bar: baz/boom/bat; }\n", render(%Q{foo\n  bar: baz/boom/bat}))
+    assert_equal("foo {\n  bar: /baz/boom; }\n", render(%Q{foo\n  bar: /baz/boom}))
+  end
+
+  def test_basic_multiline_selector
+    assert_equal("#foo #bar,\n#baz #boom {\n  foo: bar; }\n",
+                 render("#foo #bar,\n#baz #boom\n  :foo bar"))
+    assert_equal("#foo #bar,\n#foo #baz {\n  foo: bar; }\n",
+                 render("#foo\n  #bar,\n  #baz\n    :foo bar"))
+    assert_equal("#foo,\n#bar {\n  foo: bar; }\n  #foo #baz,\n  #bar #baz {\n    foo: bar; }\n",
+                 render("#foo,\n#bar\n  :foo bar\n  #baz\n    :foo bar"))
+    assert_equal("#foo #bar, #baz #boom { foo: bar; }\n",
+                 render("#foo #bar,\n#baz #boom\n  :foo bar", :style => :compact))
+                 
+    assert_equal("#foo #bar,#baz #boom{foo:bar}\n",
+                 render("#foo #bar,\n#baz #boom\n  :foo bar", :style => :compressed))
+
+    assert_equal("#foo #bar,\n#baz #boom {\n  foo: bar; }\n",
+                 render("#foo #bar,,\n,#baz #boom,\n  :foo bar"))
+
+    assert_equal("#bip #bop {\n  foo: bar; }\n",
+                 render("#bip #bop,, ,\n  :foo bar"))
+  end
+
+  def test_complex_multiline_selector
+    renders_correctly "multiline"
+  end
+
+  def test_colon_only
+    begin
+      render("a\n  b: c", :property_syntax => :old)
+    rescue Sass::SyntaxError => e
+      assert_equal("Illegal property syntax: can't use new syntax when :property_syntax => :old is set.",
+                   e.message)
+      assert_equal(2, e.sass_line)
+    else
+      assert(false, "SyntaxError not raised for :property_syntax => :old")
+    end
+
+    begin
+      render("a\n  :b c", :property_syntax => :new)
+      assert_equal(2, e.sass_line)
+    rescue Sass::SyntaxError => e
+      assert_equal("Illegal property syntax: can't use old syntax when :property_syntax => :new is set.",
+                   e.message)
+    else
+      assert(false, "SyntaxError not raised for :property_syntax => :new")
+    end
+  end
+
+  def test_pseudo_elements
+    assert_equal(<<CSS, render(<<SASS))
+::first-line {
+  size: 10em; }
+CSS
+::first-line
+  size: 10em
+SASS
+  end
+
+  def test_directive
+    assert_equal("@a b;\n", render("@a b"))
+
+    assert_equal("@a {\n  b: c; }\n", render("@a\n  :b c"))
+    assert_equal("@a { b: c; }\n", render("@a\n  :b c", :style => :compact))
+    assert_equal("@a {\n  b: c;\n}\n", render("@a\n  :b c", :style => :expanded))
+    assert_equal("@a{b:c}\n", render("@a\n  :b c", :style => :compressed))
+
+    assert_equal("@a {\n  b: c;\n  d: e; }\n",
+                 render("@a\n  :b c\n  :d e"))
+    assert_equal("@a { b: c; d: e; }\n",
+                 render("@a\n  :b c\n  :d e", :style => :compact))
+    assert_equal("@a {\n  b: c;\n  d: e;\n}\n",
+                 render("@a\n  :b c\n  :d e", :style => :expanded))
+    assert_equal("@a{b:c;d:e}\n",
+                 render("@a\n  :b c\n  :d e", :style => :compressed))
+
+    assert_equal("@a {\n  #b {\n    c: d; } }\n",
+                 render("@a\n  #b\n    :c d"))
+    assert_equal("@a { #b { c: d; } }\n",
+                 render("@a\n  #b\n    :c d", :style => :compact))
+    assert_equal("@a {\n  #b {\n    c: d;\n  }\n}\n",
+                 render("@a\n  #b\n    :c d", :style => :expanded))
+    assert_equal("@a{#b{c:d}}\n",
+                 render("@a\n  #b\n    :c d", :style => :compressed))
+
+    assert_equal("@a {\n  #b {\n    a: b; }\n    #b #c {\n      d: e; } }\n",
+                 render("@a\n  #b\n    :a b\n    #c\n      :d e"))
+    assert_equal("@a { #b { a: b; }\n  #b #c { d: e; } }\n",
+                 render("@a\n  #b\n    :a b\n    #c\n      :d e", :style => :compact))
+    assert_equal("@a {\n  #b {\n    a: b;\n  }\n  #b #c {\n    d: e;\n  }\n}\n",
+                 render("@a\n  #b\n    :a b\n    #c\n      :d e", :style => :expanded))
+    assert_equal("@a{#b{a:b}#b #c{d:e}}\n",
+                 render("@a\n  #b\n    :a b\n    #c\n      :d e", :style => :compressed))
+                 
+    assert_equal("@a {\n  #foo,\n  #bar {\n    b: c; } }\n",
+                 render("@a\n  #foo, \n  #bar\n    :b c"))
+    assert_equal("@a { #foo, #bar { b: c; } }\n",
+                 render("@a\n  #foo, \n  #bar\n    :b c", :style => :compact))
+    assert_equal("@a {\n  #foo,\n  #bar {\n    b: c;\n  }\n}\n",
+                 render("@a\n  #foo, \n  #bar\n    :b c", :style => :expanded))
+    assert_equal("@a{#foo,#bar{b:c}}\n",
+                 render("@a\n  #foo, \n  #bar\n    :b c", :style => :compressed))
+
+    to_render = <<END
+@a
+  :b c
+  #d
+    :e f
+  :g h
+END
+    rendered = <<END
+@a { b: c;
+  #d { e: f; }
+  g: h; }
+END
+    assert_equal(rendered, render(to_render, :style => :compact))
+    
+    assert_equal("@a{b:c;#d{e:f}g:h}\n", render(to_render, :style => :compressed))
+  end
+
+  def test_property_hacks
+    assert_equal(<<CSS, render(<<SASS))
+foo {
+  _name: val;
+  *name: val;
+  #name: val;
+  .name: val;
+  name/**/: val;
+  name/*\\**/: val;
+  name: val; }
+CSS
+foo
+  _name: val
+  *name: val
+  #name: val
+  .name: val
+  name/**/: val
+  name/*\\**/: val
+  name: val
+SASS
+  end
+
+  def test_properties_with_space_after_colon
+    assert_equal <<CSS, render(<<SASS)
+foo {
+  bar: baz;
+  bizz: bap; }
+CSS
+foo
+  bar : baz
+  bizz	: bap
+SASS
+  end
+
+  def test_line_annotations
+    assert_equal(<<CSS, render(<<SASS, :line_comments => true, :style => :compact))
+/* line 2, test_line_annotations_inline.sass */
+foo bar { foo: bar; }
+/* line 5, test_line_annotations_inline.sass */
+foo baz { blip: blop; }
+
+/* line 9, test_line_annotations_inline.sass */
+floodle { flop: blop; }
+
+/* line 18, test_line_annotations_inline.sass */
+bup { mix: on; }
+/* line 15, test_line_annotations_inline.sass */
+bup mixin { moop: mup; }
+
+/* line 22, test_line_annotations_inline.sass */
+bip hop, skip hop { a: b; }
+CSS
+foo
+  bar
+    foo: bar
+
+  baz
+    blip: blop
+
+
+floodle
+
+  flop: blop
+
+=mxn
+  mix: on
+  mixin
+    moop: mup
+
+bup
+  +mxn
+
+bip, skip
+  hop
+    a: b
+SASS
+  end
+
+  def test_line_annotations_with_filename
+    renders_correctly "line_numbers", :line_comments => true, :load_paths => [File.dirname(__FILE__) + "/templates"]
+  end
+
+  def test_debug_info
+    esc_file_name = Sass::SCSS::RX.escape_ident(Sass::Util.scope("test_debug_info_inline.sass"))
+
+    assert_equal(<<CSS, render(<<SASS, :debug_info => true, :style => :compact))
+@media -sass-debug-info{filename{font-family:file\\:\\/\\/#{esc_file_name}}line{font-family:\\000032}}
+foo bar { foo: bar; }
+@media -sass-debug-info{filename{font-family:file\\:\\/\\/#{esc_file_name}}line{font-family:\\000035}}
+foo baz { blip: blop; }
+
+@media -sass-debug-info{filename{font-family:file\\:\\/\\/#{esc_file_name}}line{font-family:\\000039}}
+floodle { flop: blop; }
+
+@media -sass-debug-info{filename{font-family:file\\:\\/\\/#{esc_file_name}}line{font-family:\\0000318}}
+bup { mix: on; }
+@media -sass-debug-info{filename{font-family:file\\:\\/\\/#{esc_file_name}}line{font-family:\\0000315}}
+bup mixin { moop: mup; }
+
+@media -sass-debug-info{filename{font-family:file\\:\\/\\/#{esc_file_name}}line{font-family:\\0000322}}
+bip hop, skip hop { a: b; }
+CSS
+foo
+  bar
+    foo: bar
+
+  baz
+    blip: blop
+
+
+floodle
+
+  flop: blop
+
+=mxn
+  mix: on
+  mixin
+    moop: mup
+
+bup
+  +mxn
+
+bip, skip
+  hop
+    a: b
+SASS
+  end
+
+  def test_debug_info_without_filename
+    assert_equal(<<CSS, Sass::Engine.new(<<SASS, :debug_info => true).render)
+@media -sass-debug-info{filename{font-family:}line{font-family:\\000031}}
+foo {
+  a: b; }
+CSS
+foo
+  a: b
+SASS
+  end
+
+  def test_debug_info_with_compressed
+    assert_equal(<<CSS, render(<<SASS, :debug_info => true, :style => :compressed))
+foo{a:b}
+CSS
+foo
+  a: b
+SASS
+  end
+
+  def test_debug_info_with_line_annotations
+    esc_file_name = Sass::SCSS::RX.escape_ident(Sass::Util.scope("test_debug_info_with_line_annotations_inline.sass"))
+
+    assert_equal(<<CSS, render(<<SASS, :debug_info => true, :line_comments => true))
+@media -sass-debug-info{filename{font-family:file\\:\\/\\/#{esc_file_name}}line{font-family:\\000031}}
+foo {
+  a: b; }
+CSS
+foo
+  a: b
+SASS
+  end
+
+  def test_debug_info_in_keyframes
+    assert_equal(<<CSS, render(<<SASS, :debug_info => true))
+@-webkit-keyframes warm {
+  from {
+    color: black; }
+
+  to {
+    color: red; } }
+CSS
+@-webkit-keyframes warm
+  from
+    color: black
+  to
+    color: red
+SASS
+  end
+
+  def test_empty_first_line
+    assert_equal("#a {\n  b: c; }\n", render("#a\n\n  b: c"))
+  end
+
+  def test_escaped_rule
+    assert_equal(":focus {\n  a: b; }\n", render("\\:focus\n  a: b"))
+    assert_equal("a {\n  b: c; }\n  a :focus {\n    d: e; }\n", render("\\a\n  b: c\n  \\:focus\n    d: e"))
+  end
+
+  def test_cr_newline
+    assert_equal("foo {\n  a: b;\n  c: d;\n  e: f; }\n", render("foo\r  a: b\r\n  c: d\n\r  e: f"))
+  end
+
+  def test_property_with_content_and_nested_props
+    assert_equal(<<CSS, render(<<SASS))
+foo {
+  a: b;
+    a-c: d;
+      a-c-e: f; }
+CSS
+foo
+  a: b
+    c: d
+      e: f
+SASS
+
+    assert_equal(<<CSS, render(<<SASS))
+foo {
+  a: b;
+    a-c-e: f; }
+CSS
+foo
+  a: b
+    c:
+      e: f
+SASS
+  end
+
+  def test_guarded_assign
+    assert_equal("foo {\n  a: b; }\n", render(%Q{$foo: b\n$foo: c !default\nfoo\n  a: $foo}))
+    assert_equal("foo {\n  a: b; }\n", render(%Q{$foo: b !default\nfoo\n  a: $foo}))
+  end
+  
+  def test_mixins
+    renders_correctly "mixins", { :style => :expanded }
+  end
+
+  def test_directive_style_mixins
+    assert_equal <<CSS, render(<<SASS)
+bar {
+  prop: baz; }
+CSS
+@mixin foo($arg)
+  prop: $arg
+
+bar
+  @include foo(baz)
+SASS
+  end
+
+  def test_mixins_dont_interfere_with_sibling_combinator
+    assert_equal("foo + bar {\n  a: b; }\nfoo + baz {\n  c: d; }\n",
+                 render("foo\n  +\n    bar\n      a: b\n    baz\n      c: d"))
+  end
+
+  def test_mixin_args
+    assert_equal("blat {\n  baz: hi; }\n", render(<<SASS))
+=foo($bar)
+  baz: $bar
+blat
+  +foo(hi)
+SASS
+    assert_equal("blat {\n  baz: 3; }\n", render(<<SASS))
+=foo($a, $b)
+  baz: $a + $b
+blat
+  +foo(1, 2)
+SASS
+    assert_equal("blat {\n  baz: 4;\n  baz: 3;\n  baz: 5;\n  bang: 3; }\n", render(<<SASS))
+=foo($c: (6 + 4) / 2)
+  baz: $c
+$c: 3
+blat
+  +foo($c + 1)
+  +foo(($c + 3)/2)
+  +foo
+  bang: $c
+SASS
+  end
+
+  def test_default_values_for_mixin_arguments
+    assert_equal("white {\n  color: white; }\n\nblack {\n  color: black; }\n", render(<<SASS))
+=foo($a: #FFF)
+  :color $a
+white
+  +foo
+black
+  +foo(#000)
+SASS
+    assert_equal(<<CSS, render(<<SASS))
+one {
+  color: white;
+  padding: 1px;
+  margin: 4px; }
+
+two {
+  color: white;
+  padding: 2px;
+  margin: 5px; }
+
+three {
+  color: white;
+  padding: 2px;
+  margin: 3px; }
+CSS
+$a: 5px
+=foo($a, $b: 1px, $c: 3px + $b)
+  :color $a
+  :padding $b
+  :margin $c
+one
+  +foo(#fff)
+two
+  +foo(#fff, 2px)
+three
+  +foo(#fff, 2px, 3px)
+SASS
+  end
+
+  def test_hyphen_underscore_insensitive_mixins
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  b: 12;
+  c: foo; }
+CSS
+=mixin-hyphen
+  b: 12
+
+=mixin_under
+  c: foo
+
+a
+  +mixin_hyphen
+  +mixin-under
+SASS
+  end
+
+  def test_css_identifier_mixin
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  foo: 12; }
+CSS
+=\\{foo\\(12\\)($a)
+  foo: $a
+
+a
+  +\\{foo\\(12\\)(12)
+SASS
+  end
+
+  def test_basic_function
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: 3; }
+CSS
+@function foo()
+  @return 1 + 2
+
+bar
+  a: foo()
+SASS
+  end
+
+  def test_function_args
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: 3; }
+CSS
+@function plus($var1, $var2)
+  @return $var1 + $var2
+
+bar
+  a: plus(1, 2)
+SASS
+  end
+
+  def test_function_arg_default
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: 3; }
+CSS
+@function plus($var1, $var2: 2)
+  @return $var1 + $var2
+
+bar
+  a: plus(1)
+SASS
+  end
+
+  def test_function_arg_keyword
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: 1bar; }
+CSS
+@function plus($var1: 1, $var2: 2)
+  @return $var1 + $var2
+
+bar
+  a: plus($var2: bar)
+SASS
+  end
+
+  def test_function_with_if
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: foo;
+  b: bar; }
+CSS
+@function my-if($cond, $val1, $val2)
+  @if $cond
+    @return $val1
+  @else
+    @return $val2
+
+bar
+  a: my-if(true, foo, bar)
+  b: my-if(false, foo, bar)
+SASS
+  end
+
+  def test_function_with_var
+    assert_equal(<<CSS, render(<<SASS))
+bar {
+  a: 1; }
+CSS
+@function foo($val1, $val2)
+  $intermediate: $val1 + $val2
+  @return $intermediate/3
+
+bar
+  a: foo(1, 2)
+SASS
+  end
+
+  def test_control_directive_in_nested_property
+    assert_equal(<<CSS, render(<<SASS))
+foo {
+  a-b: c; }
+CSS
+foo
+  a:
+    @if true
+      b: c
+SASS
+  end
+
+  def test_interpolation
+    assert_equal("a-1 {\n  b-2-3: c-3; }\n", render(<<SASS))
+$a: 1
+$b: 2
+$c: 3
+a-\#{$a}
+  b-\#{$b}-\#{$c}: c-\#{$a + $b}
+SASS
+  end
+
+  def test_complex_property_interpolation
+    assert_equal(<<CSS, render(<<SASS))
+a-1 {
+  b-2 3-fizzap18: c-3; }
+CSS
+$a: 1
+$b: 2
+$c: 3
+a-\#{$a}
+  b-\#{$b $c}-\#{fizzap + ($c + 15)}: c-\#{$a + $b}
+SASS
+  end
+
+  def test_if_directive
+    assert_equal("a {\n  b: 1; }\n", render(<<SASS))
+$var: true
+a
+  @if $var
+    b: 1
+  @if not $var
+    b: 2
+SASS
+  end
+
+  def test_for
+    assert_equal(<<CSS, render(<<SASS))
+a-0 {
+  two-i: 0; }
+
+a-1 {
+  two-i: 2; }
+
+a-2 {
+  two-i: 4; }
+
+a-3 {
+  two-i: 6; }
+
+b-1 {
+  j-1: 0; }
+
+b-2 {
+  j-1: 1; }
+
+b-3 {
+  j-1: 2; }
+
+b-4 {
+  j-1: 3; }
+CSS
+$a: 3
+@for $i from 0 to $a + 1
+  a-\#{$i}
+    two-i: 2 * $i
+
+@for $j from 1 through 4
+  b-\#{$j}
+    j-1: $j - 1
+SASS
+  end
+
+  def test_while
+    assert_equal(<<CSS, render(<<SASS))
+a-5 {
+  blooble: gloop; }
+
+a-4 {
+  blooble: gloop; }
+
+a-3 {
+  blooble: gloop; }
+
+a-2 {
+  blooble: gloop; }
+
+a-1 {
+  blooble: gloop; }
+CSS
+$a: 5
+@while $a != 0
+  a-\#{$a}
+    blooble: gloop
+  $a: $a - 1
+SASS
+  end
+
+  def test_else
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  t1: t;
+  t2: t;
+  t3: t;
+  t4: t; }
+CSS
+a
+  @if true
+    t1: t
+  @else
+    f1: f
+
+  @if false
+    f2: f
+  @else
+    t2: t
+
+  @if false
+    f3: f1
+  @else if 1 + 1 == 3
+    f3: f2
+  @else
+    t3: t
+
+  @if false
+    f4: f1
+  @else if 1 + 1 == 2
+    t4: t
+  @else
+    f4: f2
+
+  @if false
+    f5: f1
+  @else if false
+    f5: f2
+SASS
+  end
+
+  def test_each
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  b: 1px;
+  b: 2px;
+  b: 3px;
+  b: 4px;
+  c: foo;
+  c: bar;
+  c: baz;
+  c: bang;
+  d: blue; }
+CSS
+a
+  @each $number in 1px 2px 3px 4px
+    b: $number
+  @each $str in foo, bar, baz, bang
+    c: $str
+  @each $single in blue
+    d: $single
+SASS
+  end
+
+  def test_variable_reassignment
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  b: 1;
+  c: 2; }
+CSS
+$a: 1
+a
+  b: $a
+  $a: 2
+  c: $a
+SASS
+  end
+
+  def test_variable_scope
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  b-1: c;
+  b-2: c;
+  d: 12; }
+
+b {
+  d: 17; }
+CSS
+$i: 12
+a
+  @for $i from 1 through 2
+    b-\#{$i}: c
+  d: $i
+
+=foo
+  $i: 17
+
+b
+  +foo
+  d: $i
+SASS
+  end
+
+  def test_hyphen_underscore_insensitive_variables
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  b: c; }
+
+d {
+  e: 13;
+  f: foobar; }
+CSS
+$var-hyphen: 12
+$var_under: foo
+
+a
+  $var_hyphen: 1 + $var_hyphen
+  $var-under: $var-under + bar
+  b: c
+
+d
+  e: $var-hyphen
+  f: $var_under
+SASS
+  end
+
+  def test_css_identifier_variable
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  b: 12; }
+CSS
+$\\{foo\\(12\\): 12
+
+a
+  b: $\\{foo\\(12\\)
+SASS
+  end
+
+  def test_important
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  b: 12px !important; }
+CSS
+$foo: 12px
+a
+  b: $foo !important
+SASS
+  end
+
+  def test_argument_error
+    assert_raise(Sass::SyntaxError) { render("a\n  b: hsl(1)") }
+  end
+
+  def test_comments_at_the_top_of_a_document
+    render(<<SASS)
+//
+  This is a comment that
+  continues to the second line.
+foo
+  bar: baz
+SASS
+  end
+
+  def test_loud_comments_containing_a_comment_close
+    actual_css = render(<<SASS)
+/*
+  This is a comment that
+  continues to the second line. */
+foo
+  bar: baz
+SASS
+assert_equal(<<CSS, actual_css)
+/* This is a comment that
+ * continues to the second line. */
+foo {
+  bar: baz; }
+CSS
+  end
+
+  def test_loud_comments_with_starred_lines
+    assert_equal(<<CSS, render(<<SASS))
+/* This is a comment that
+ * continues to the second line.
+ * And even to the third! */
+CSS
+/* This is a comment that
+ * continues to the second line.
+ * And even to the third!
+SASS
+  end
+
+  def test_loud_comments_with_no_space_after_starred_lines
+    assert_equal(<<CSS, render(<<SASS))
+/*bip bop
+ *beep boop
+ *bap blimp */
+CSS
+/*bip bop
+ *beep boop
+ *bap blimp
+SASS
+  end
+
+  def test_comment_indentation_at_beginning_of_doc
+    assert_equal <<CSS, render(<<SASS)
+/* foo
+ * bar
+ *   baz */
+foo {
+  a: b; }
+CSS
+/* foo
+   bar
+     baz
+foo
+  a: b
+SASS
+  end
+
+  def test_unusual_comment_indentation
+    assert_equal <<CSS, render(<<SASS)
+foo {
+  /* foo
+   * bar
+   *   baz */ }
+CSS
+foo
+  /* foo
+     bar
+       baz
+SASS
+  end
+
+  def test_loud_comment_with_close
+    assert_equal <<CSS, render(<<SASS)
+foo {
+  /* foo
+   * bar */ }
+CSS
+foo
+  /* foo
+     bar */
+SASS
+  end
+
+  def test_loud_comment_with_separate_line_close
+    assert_equal <<CSS, render(<<SASS)
+foo {
+  /* foo
+   * bar
+   */ }
+CSS
+foo
+  /* foo
+   * bar
+   */
+SASS
+  end
+
+  def test_loud_comment_in_compressed_mode
+    assert_equal <<CSS, render(<<SASS, :style => :compressed)
+foo{color:blue;/* foo
+ * bar
+ */}
+CSS
+foo
+  color: blue
+  /*! foo
+   * bar
+   */
+SASS
+  end
+
+  def test_loud_comment_in_silent_comment
+    silence_warnings {assert_equal <<CSS, render(<<SASS, :style => :compressed)}
+foo{color:blue;/* foo */
+/* bar */
+/* bip */
+/* baz */}
+CSS
+foo
+  color: blue
+  //! foo
+  //! bar
+  //!
+    bip
+    baz
+SASS
+  end
+
+  def test_loud_comment_is_evaluated
+    assert_equal <<CSS, render(<<SASS)
+/* Hue: 327.216deg */
+CSS
+/*!
+  Hue: \#{hue(#f836a0)}
+SASS
+  end
+
+  def test_attribute_selector_with_spaces
+    assert_equal(<<CSS, render(<<SASS))
+a b[foo=bar] {
+  c: d; }
+CSS
+a
+  b[foo = bar]
+    c: d
+SASS
+  end
+
+  def test_quoted_colon
+    assert_equal(<<CSS, render(<<SASS))
+a b[foo="bar: baz"] {
+  c: d; }
+CSS
+a
+  b[foo="bar: baz"]
+    c: d
+SASS
+  end
+
+  def test_quoted_comma
+    assert_equal(<<CSS, render(<<SASS))
+a b[foo="bar, baz"] {
+  c: d; }
+CSS
+a
+  b[foo="bar, baz"]
+    c: d
+SASS
+  end
+
+  def test_quoted_ampersand
+    assert_equal(<<CSS, render(<<SASS))
+a b[foo="bar & baz"] {
+  c: d; }
+CSS
+a
+  b[foo="bar & baz"]
+    c: d
+SASS
+  end
+
+  def test_empty_selector_warning
+    assert_warning(<<END) {render("foo bar")}
+WARNING on line 1 of test_empty_selector_warning_inline.sass:
+This selector doesn't have any properties and will not be rendered.
+END
+  end
+
+  def test_root_level_pseudo_class_with_new_properties
+    assert_equal(<<CSS, render(<<SASS, :property_syntax => :new))
+:focus {
+  outline: 0; }
+CSS
+:focus
+  outline: 0
+SASS
+  end
+
+  def test_pseudo_class_with_new_properties
+    assert_equal(<<CSS, render(<<SASS, :property_syntax => :new))
+p :focus {
+  outline: 0; }
+CSS
+p
+  :focus
+    outline: 0
+SASS
+  end
+
+  def test_nil_option
+    assert_equal(<<CSS, render(<<SASS, :format => nil))
+foo {
+  a: b; }
+CSS
+foo
+  a: b
+SASS
+  end
+
+  def test_interpolation_in_raw_functions
+    assert_equal(<<CSS, render(<<SASS))
+foo {
+  filter: progid:Microsoft.foo.bar.Baz(flip=foobar, bang=#00ff00cc); }
+CSS
+foo
+  filter: progid:Microsoft.foo.bar.Baz(flip=\#{foo + bar}, bang=#00ff00cc)
+SASS
+  end
+
+  # SassScript string behavior
+
+  def test_plus_preserves_quotedness
+    assert_equal(<<CSS, render(<<SASS))
+foo {
+  a: "foo1";
+  b: "1foo";
+  c: foo1;
+  d: 1foo;
+  e: "foobar";
+  f: foobar; }
+CSS
+foo
+  a: "foo" + 1
+  b: 1 + "foo"
+  c: foo + 1
+  d: 1 + foo
+  e: "foo" + bar
+  f: foo + "bar"
+SASS
+  end
+
+  def test_colon_properties_preserve_quotedness
+    assert_equal(<<CSS, render(<<SASS))
+foo {
+  a: "foo";
+  b: bar;
+  c: "foo" bar;
+  d: foo, "bar"; }
+CSS
+foo
+  a: "foo"
+  b: bar
+  c: "foo" bar
+  d: foo, "bar"
+SASS
+  end
+
+  def test_colon_variables_preserve_quotedness
+    assert_equal(<<CSS, render(<<SASS))
+foo {
+  a: "foo";
+  b: bar; }
+CSS
+$a: "foo"
+$b: bar
+
+foo
+  a: $a
+  b: $b
+SASS
+  end
+
+  def test_colon_args_preserve_quotedness
+    assert_equal(<<CSS, render(<<SASS))
+foo {
+  a: "foo";
+  b: bar;
+  c: "foo" bar;
+  d: foo, "bar"; }
+CSS
+=foo($a: "foo", $b: bar, $c: "foo" bar, $d: (foo, "bar"))
+  foo
+    a: $a
+    b: $b
+    c: $c
+    d: $d
+
++foo
+SASS
+  end
+
+  def test_interpolation_unquotes_strings
+    assert_equal(<<CSS, render(<<SASS))
+.foo-bar {
+  a: b; }
+CSS
+.foo-\#{"bar"}
+  a: b
+SASS
+
+    assert_equal(<<CSS, render(<<SASS))
+.foo {
+  a: b c; }
+CSS
+.foo
+  a: b \#{"c"}
+SASS
+  end
+
+  def test_interpolation_unquotes_strings_in_vars
+    assert_equal(<<CSS, render(<<SASS))
+.foo-bar {
+  a: b; }
+CSS
+$var: "bar"
+
+.foo-\#{$var}
+  a: b
+SASS
+  end
+
+  def test_interpolation_doesnt_deep_unquote_strings
+    assert_equal(<<CSS, render(<<SASS))
+.foo {
+  a: "bar" "baz"; }
+CSS
+.foo
+  a: \#{"bar" "baz"}
+SASS
+  end
+
+  def test_warn_directive
+  expected_warning = <<EXPECTATION
+WARNING: this is a warning
+         on line 4 of test_warn_directive_inline.sass
+
+WARNING: this is a mixin warning
+         on line 2 of test_warn_directive_inline.sass, in `foo'
+         from line 7 of test_warn_directive_inline.sass
+EXPECTATION
+    assert_warning expected_warning do
+      assert_equal <<CSS, render(<<SASS)
+bar {
+  c: d; }
+CSS
+=foo
+  @warn "this is a mixin warning"
+
+@warn "this is a warning"
+bar
+  c: d
+  +foo
+SASS
+    end
+  end
+
+  def test_warn_directive_when_quiet
+    assert_warning "" do
+      assert_equal <<CSS, render(<<SASS, :quiet => true)
+CSS
+@warn "this is a warning"
+SASS
+    end
+  end
+
+  def test_warn_with_imports
+    expected_warning = <<WARN
+WARNING: In the main file
+         on line 1 of #{File.dirname(__FILE__)}/templates/warn.sass
+
+WARNING: Imported
+         on line 1 of #{File.dirname(__FILE__)}/templates/warn_imported.sass
+         from line 2 of #{File.dirname(__FILE__)}/templates/warn.sass
+
+WARNING: In an imported mixin
+         on line 4 of #{File.dirname(__FILE__)}/templates/warn_imported.sass, in `emits-a-warning'
+         from line 3 of #{File.dirname(__FILE__)}/templates/warn.sass
+WARN
+    assert_warning expected_warning do
+      renders_correctly "warn", :style => :compact, :load_paths => [File.dirname(__FILE__) + "/templates"]
+    end
+  end
+
+  def test_media_bubbling
+    assert_equal <<CSS, render(<<SASS)
+.foo {
+  a: b; }
+  @media bar {
+    .foo {
+      c: d; } }
+  .foo .baz {
+    e: f; }
+    @media bip {
+      .foo .baz {
+        g: h; } }
+
+.other {
+  i: j; }
+CSS
+.foo
+  a: b
+  @media bar
+    c: d
+  .baz
+    e: f
+    @media bip
+      g: h
+
+.other
+  i: j
+SASS
+
+    assert_equal <<CSS, render(<<SASS, :style => :compact)
+.foo { a: b; }
+@media bar { .foo { c: d; } }
+.foo .baz { e: f; }
+@media bip { .foo .baz { g: h; } }
+
+.other { i: j; }
+CSS
+.foo
+  a: b
+  @media bar
+    c: d
+  .baz
+    e: f
+    @media bip
+      g: h
+
+.other
+  i: j
+SASS
+
+    assert_equal <<CSS, render(<<SASS, :style => :expanded)
+.foo {
+  a: b;
+}
+@media bar {
+  .foo {
+    c: d;
+  }
+}
+.foo .baz {
+  e: f;
+}
+@media bip {
+  .foo .baz {
+    g: h;
+  }
+}
+
+.other {
+  i: j;
+}
+CSS
+.foo
+  a: b
+  @media bar
+    c: d
+  .baz
+    e: f
+    @media bip
+      g: h
+
+.other
+  i: j
+SASS
+  end
+
+  def test_double_media_bubbling
+    assert_equal <<CSS, render(<<SASS)
+@media bar and baz {
+  .foo {
+    c: d; } }
+CSS
+@media bar
+  @media baz
+    .foo
+      c: d
+SASS
+
+    assert_equal <<CSS, render(<<SASS)
+@media bar {
+  .foo {
+    a: b; } }
+  @media bar and baz {
+    .foo {
+      c: d; } }
+CSS
+.foo
+  @media bar
+    a: b
+    @media baz
+      c: d
+SASS
+  end
+
+  def test_double_media_bubbling_with_commas
+    assert_equal <<CSS, render(<<SASS)
+@media foo and baz, foo and bang, bar and baz, bar and bang {
+  .foo {
+    c: d; } }
+CSS
+@media foo, bar
+  @media baz, bang
+    .foo
+      c: d
+SASS
+  end
+
+  def test_rule_media_rule_bubbling
+    assert_equal <<CSS, render(<<SASS)
+@media bar {
+  .foo {
+    a: b;
+    e: f; }
+    .foo .baz {
+      c: d; } }
+CSS
+.foo
+  @media bar
+    a: b
+    .baz
+      c: d
+    e: f
+SASS
+  end
+
+  def test_nested_media_around_properties
+    assert_equal <<CSS, render(<<SASS)
+.outside {
+  color: red;
+  background: blue; }
+  @media print {
+    .outside {
+      color: black; } }
+    @media print and nested {
+      .outside .inside {
+        border: 1px solid black; } }
+  .outside .middle {
+    display: block; }
+CSS
+.outside
+  color: red
+  @media print
+    color: black
+    .inside
+      @media nested
+        border: 1px solid black
+  background: blue
+  .middle
+    display: block
+SASS
+  end
+
+  def test_media_with_parent_references
+    sass_str = <<SASS
+.outside
+  @media print
+    &.inside
+      border: 1px solid black
+SASS
+    css_str = <<CSS
+@media print {
+  .outside.inside {
+    border: 1px solid black; } }
+CSS
+    assert_equal css_str, render(sass_str)
+  end
+
+  # Regression tests
+
+  def test_tricky_mixin_loop_exception
+    render <<SASS
+@mixin foo($a)
+  @if $a
+    @include foo(false)
+    @include foo(true)
+  @else
+    a: b
+
+a
+  @include foo(true)
+SASS
+    assert(false, "Exception not raised")
+  rescue Sass::SyntaxError => err
+    assert_equal("An @include loop has been found: foo includes itself", err.message)
+    assert_hash_has(err.sass_backtrace[0], :mixin => "foo", :line => 3)
+  end
+
+  def test_interpolated_comment_in_mixin
+    assert_equal <<CSS, render(<<SASS)
+/* color: red */
+.foo {
+  color: red; }
+
+/* color: blue */
+.foo {
+  color: blue; }
+
+/* color: green */
+.foo {
+  color: green; }
+CSS
+=foo($var)
+  /*! color: \#{$var}
+  .foo
+    color: $var
+
++foo(red)
++foo(blue)
++foo(green)
+SASS
+  end
+
+  def test_parens_in_mixins
+    assert_equal(<<CSS, render(<<SASS))
+.foo {
+  color: #01ff7f;
+  background-color: #000102; }
+CSS
+=foo($c1, $c2: rgb(0, 1, 2))
+  color: $c1
+  background-color: $c2
+
+.foo
+  +foo(rgb(1,255,127))
+SASS
+  end
+
+  def test_comment_beneath_prop
+    assert_equal(<<RESULT, render(<<SOURCE))
+.box {
+  border-style: solid; }
+RESULT
+.box
+  :border
+    //:color black
+    :style solid
+SOURCE
+
+    assert_equal(<<RESULT, render(<<SOURCE))
+.box {
+  /* :color black */
+  border-style: solid; }
+RESULT
+.box
+  :border
+    /* :color black
+    :style solid
+SOURCE
+
+    assert_equal(<<RESULT, render(<<SOURCE, :style => :compressed))
+.box{border-style:solid}
+RESULT
+.box
+  :border
+    /*:color black
+    :style solid
+SOURCE
+  end
+
+  def test_compressed_comment_beneath_directive
+    assert_equal(<<RESULT, render(<<SOURCE, :style => :compressed))
+@foo{a:b}
+RESULT
+@foo
+  a: b
+  /*b: c
+SOURCE
+  end
+
+  def test_comment_with_crazy_indentation
+    assert_equal(<<CSS, render(<<SASS))
+/* This is a loud comment:
+ *          Where the indentation is wonky. */
+.comment {
+  width: 1px; }
+CSS
+/*
+  This is a loud comment:
+           Where the indentation is wonky.
+//
+  This is a silent comment:
+           Where the indentation is wonky.
+.comment
+  width: 1px
+SASS
+  end
+
+  def test_plus_with_space
+    assert_equal(<<CSS, render(<<SASS))
+a + b {
+  color: green; }
+CSS
+a
+  + b
+    color: green
+SASS
+  end
+
+  def test_empty_line_comment
+    assert_equal(<<CSS, render(<<SASS))
+/* Foo
+ *
+ * Bar */
+CSS
+/*
+  Foo
+
+  Bar
+SASS
+  end
+
+  def test_empty_comment
+    assert_equal(<<CSS, render(<<SASS))
+/* */
+a {
+  /* */
+  b: c; }
+CSS
+/*
+a
+  /*
+  b: c
+SASS
+  end
+
+  def test_options_available_in_environment
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  b: nested; }
+CSS
+a
+  b: option("style")
+SASS
+  end
+
+  def test_mixin_no_arg_error
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "($bar,": expected variable (e.g. $foo), was ")"') do
+      render(<<SASS)
+=foo($bar,)
+  bip: bap
+SASS
+    end
+  end
+
+  def test_import_with_commas_in_url
+    assert_equal <<CSS, render(<<SASS)
+@import url(foo.css?bar,baz);
+CSS
+@import url(foo.css?bar,baz)
+SASS
+  end
+
+  def test_silent_comment_in_prop_val_after_important
+    assert_equal(<<CSS, render(<<SASS))
+.advanced {
+  display: none !important; }
+CSS
+.advanced
+  display: none !important // yeah, yeah. it's not really a style anyway.
+SASS
+  end
+
+  def test_mixin_with_keyword_args
+    assert_equal <<CSS, render(<<SASS)
+.mixed {
+  required: foo;
+  arg1: default-val1;
+  arg2: non-default-val2; }
+CSS
+=a-mixin($required, $arg1: default-val1, $arg2: default-val2)
+  required: $required
+  arg1: $arg1
+  arg2: $arg2
+.mixed
+  +a-mixin(foo, $arg2: non-default-val2)
+SASS
+  end
+
+  def test_mixin_with_keyword_arg_variable_value
+    assert_equal <<CSS, render(<<SASS)
+.mixed {
+  required: foo;
+  arg1: default-val1;
+  arg2: a-value; }
+CSS
+=a-mixin($required, $arg1: default-val1, $arg2: default-val2)
+  required: $required
+  arg1: $arg1
+  arg2: $arg2
+.mixed
+  $a-value: a-value
+  +a-mixin(foo, $arg2: $a-value)
+SASS
+  end
+
+  def test_mixin_keyword_args_handle_variable_underscore_dash_equivalence
+    assert_equal <<CSS, render(<<SASS)
+.mixed {
+  required: foo;
+  arg1: non-default-val1;
+  arg2: non-default-val2; }
+CSS
+=a-mixin($required, $arg-1: default-val1, $arg_2: default-val2)
+  required: $required
+  arg1: $arg_1
+  arg2: $arg-2
+.mixed
+  +a-mixin(foo, $arg-2: non-default-val2, $arg_1: non-default-val1)
+SASS
+  end
+
+  def test_passing_required_args_as_a_keyword_arg
+    assert_equal <<CSS, render(<<SASS)
+.mixed {
+  required: foo;
+  arg1: default-val1;
+  arg2: default-val2; }
+CSS
+=a-mixin($required, $arg1: default-val1, $arg2: default-val2)
+  required: $required
+  arg1: $arg1
+  arg2: $arg2
+.mixed
+  +a-mixin($required: foo)
+SASS
+  end
+
+  def test_passing_all_as_keyword_args_in_opposite_order
+    assert_equal <<CSS, render(<<SASS)
+.mixed {
+  required: foo;
+  arg1: non-default-val1;
+  arg2: non-default-val2; }
+CSS
+=a-mixin($required, $arg1: default-val1, $arg2: default-val2)
+  required: $required
+  arg1: $arg1
+  arg2: $arg2
+.mixed
+  +a-mixin($arg2: non-default-val2, $arg1: non-default-val1, $required: foo)
+SASS
+  end
+
+  def test_function_output_with_comma
+    assert_equal <<CSS, render(<<SASS)
+foo {
+  a: b(c), d(e); }
+CSS
+foo
+  a: b(c), d(e)
+SASS
+  end
+
+  def test_interpolation_with_comma
+    assert_equal <<CSS, render(<<SASS)
+foo {
+  a: foo, bar; }
+CSS
+$foo: foo
+foo
+  a: \#{$foo}, bar
+SASS
+  end
+
+  def test_string_interpolation_with_comma
+    assert_equal <<CSS, render(<<SASS)
+foo {
+  a: "bip foo bap", bar; }
+CSS
+$foo: foo
+foo
+  a: "bip \#{$foo} bap", bar
+SASS
+  end
+
+  def test_unknown_directive
+    assert_equal <<CSS, render(<<SASS)
+@baz {
+  c: d; }
+CSS
+@baz
+  c: d
+SASS
+  end
+
+  def test_comment_interpolation_warning
+    assert_warning(<<END) {render("/* \#{foo}")}
+WARNING:
+On line 1 of 'test_comment_interpolation_warning_inline.sass'
+Comments will evaluate the contents of interpolations (\#{ ... }) in Sass 3.2.
+Please escape the interpolation by adding a backslash before the `#`.
+END
+  end
+
+  def test_loud_silent_comment_warning
+    assert_warning(<<END) {render("//! \#{foo}")}
+WARNING:
+On line 1 of 'test_loud_silent_comment_warning_inline.sass'
+`//` comments will no longer be allowed to use the `!` flag in Sass 3.2.
+Please change to `/*` comments.
+END
+  end
+
+  def test_loud_comment_interpolations_can_be_escaped
+    assert_equal <<CSS, render(<<SASS)
+/* \#{foo} */
+CSS
+/* \\\#{foo}
+SASS
+    assert_equal <<CSS, render(<<SASS)
+/* \#{foo} */
+CSS
+/*! \\\#{foo}
+SASS
+  end
+
+  def test_selector_compression
+    assert_equal <<CSS, render(<<SASS, :style => :compressed)
+a>b,c+d,:-moz-any(e,f,g){h:i}
+CSS
+a > b, c + d, :-moz-any(e, f, g)
+  h: i
+SASS
+  end
+
+  def test_comment_like_selector
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "": expected selector, was "/ foo"') {render(<<SASS)}
+/ foo
+  a: b
+SASS
+  end
+
+  # Encodings
+
+  unless Sass::Util.ruby1_8?
+    def test_encoding_error
+      render("foo\nbar\nb\xFEaz".force_encoding("utf-8"))
+      assert(false, "Expected exception")
+    rescue Sass::SyntaxError => e
+      assert_equal(3, e.sass_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 Sass::SyntaxError => e
+      assert_equal(3, e.sass_line)
+      assert_equal('Invalid UTF-16LE character "\xFE"', e.message)
+    end
+
+    def test_same_charset_as_encoding
+      assert_renders_encoded(<<CSS, <<SASS)
+@charset "UTF-8";
+fóó {
+  a: b; }
+CSS
+@charset "utf-8"
+fóó
+  a: b
+SASS
+    end
+
+    def test_different_charset_than_encoding
+      assert_renders_encoded(<<CSS.force_encoding("IBM866"), <<SASS)
+@charset "IBM866";
+fóó {
+  a: b; }
+CSS
+@charset "ibm866"
+fóó
+  a: b
+SASS
+    end
+
+    def test_different_encoding_than_system
+      assert_renders_encoded(<<CSS.encode("IBM866"), <<SASS.encode("IBM866"))
+@charset "IBM866";
+тАЬ {
+  a: b; }
+CSS
+тАЬ
+  a: b
+SASS
+    end
+
+    def test_multibyte_charset
+      assert_renders_encoded(<<CSS.encode("UTF-16LE"), <<SASS.encode("UTF-16LE").force_encoding("UTF-8"))
+@charset "UTF-16LE";
+fóó {
+  a: b; }
+CSS
+@charset "utf-16le"
+fóó
+  a: b
+SASS
+    end
+
+    def test_multibyte_charset_without_endian_specifier
+      assert_renders_encoded(<<CSS.encode("UTF-32BE"), <<SASS.encode("UTF-32BE").force_encoding("UTF-8"))
+@charset "UTF-32BE";
+fóó {
+  a: b; }
+CSS
+@charset "utf-32"
+fóó
+  a: b
+SASS
+    end
+
+    def test_utf8_bom
+      assert_renders_encoded(<<CSS, <<SASS.force_encoding("BINARY"))
+@charset "UTF-8";
+fóó {
+  a: b; }
+CSS
+\uFEFFfóó
+  a: b
+SASS
+    end
+
+    def test_utf16le_bom
+      assert_renders_encoded(<<CSS.encode("UTF-16LE"), <<SASS.encode("UTF-16LE").force_encoding("BINARY"))
+@charset "UTF-16LE";
+fóó {
+  a: b; }
+CSS
+\uFEFFfóó
+  a: b
+SASS
+    end
+
+    def test_utf32be_bom
+      assert_renders_encoded(<<CSS.encode("UTF-32BE"), <<SASS.encode("UTF-32BE").force_encoding("BINARY"))
+@charset "UTF-32BE";
+fóó {
+  a: b; }
+CSS
+\uFEFFfóó
+  a: b
+SASS
+    end
+
+    # Encoding Regression Test
+
+    def test_multibyte_prop_name
+      assert_equal(<<CSS, render(<<SASS))
+@charset "UTF-8";
+#bar {
+  cölor: blue; }
+CSS
+#bar
+  cölor: blue
+SASS
+    end
+
+    def test_multibyte_and_interpolation
+      assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))
+#bar {
+  background: a 0%; }
+CSS
+#bar {
+  // 
+  background: \#{a} 0%;
+}
+SCSS
+    end
+  end
+
+  def test_original_filename_set
+    importer = MockImporter.new
+    importer.add_import("imported", "div{color:red}")
+
+    original_filename = filename_for_test
+    engine = Sass::Engine.new('@import "imported"; div{color:blue}',
+      :filename => original_filename, :load_paths => [importer], :syntax => :scss)
+    engine.render
+
+    assert_equal original_filename, engine.options[:original_filename]
+    assert_equal original_filename, importer.engine("imported").options[:original_filename]
+  end
+
+  def test_deprecated_PRECISION
+    assert_warning(<<END) {assert_equal 1000.0, Sass::Script::Number::PRECISION}
+Sass::Script::Number::PRECISION is deprecated and will be removed in a future release. Use Sass::Script::Number.precision_factor instead.
+END
+  end
+  def test_changing_precision
+    begin
+      Sass::Script::Number.precision = 8
+      assert_equal <<CSS, render(<<SASS)
+div {
+  maximum: 1.00000001;
+  too-much: 1.0; }
+CSS
+div
+  maximum : 1.00000001
+  too-much: 1.000000001
+SASS
+    ensure
+      Sass::Script::Number.precision = 3
+    end
+  end
+
+  private
+
+  def assert_hash_has(hash, expected)
+    expected.each {|k, v| assert_equal(v, hash[k])}
+  end
+
+  def assert_renders_encoded(css, sass)
+    result = render(sass)
+    assert_equal css.encoding, result.encoding
+    assert_equal css, result
+  end
+
+  def render(sass, options = {})
+    munge_filename options
+    Sass::Engine.new(sass, options).render
+  end
+
+  def renders_correctly(name, options={})
+    sass_file  = load_file(name, "sass")
+    css_file   = load_file(name, "css")
+    options[:filename] ||= filename(name, "sass")
+    options[:syntax] ||= :sass
+    options[:css_filename] ||= filename(name, "css")
+    css_result = Sass::Engine.new(sass_file, options).render
+    assert_equal css_file, css_result
+  end
+
+  def load_file(name, type = "sass")
+    @result = ''
+    File.new(filename(name, type)).each_line { |l| @result += l }
+    @result
+  end
+
+  def filename(name, type)
+    File.dirname(__FILE__) + "/#{type == 'sass' ? 'templates' : 'results'}/#{name}.#{type}"
+  end
+
+  def sassc_path(template)
+    sassc_path = File.join(File.dirname(__FILE__) + "/templates/#{template}.sass")
+    engine = Sass::Engine.new("", :filename => sassc_path,
+      :importer => Sass::Importers::Filesystem.new("."))
+    key = engine.send(:sassc_key)
+    File.join(engine.options[:cache_location], key)
+  end
+end
+