radiant 0.9.1 → 1.0.0.rc1

data/vendor/plugins/haml/test/sass/script_test.rb

@@ -2,18 +2,42 @@
 require File.dirname(__FILE__) + '/../test_helper'
 require 'sass/engine'
 
+module Sass::Script::Functions::UserFunctions
+  def assert_options(val)
+    val.options[:foo]
+    Sass::Script::String.new("Options defined!")
+  end
+end
+
 class SassScriptTest < Test::Unit::TestCase
   include Sass::Script
 
   def test_color_checks_input
-    assert_raise(Sass::SyntaxError, "Color values must be between 0 and 255") {Color.new([1, 2, -1])}
-    assert_raise(Sass::SyntaxError, "Color values must be between 0 and 255") {Color.new([256, 2, 3])}
+    assert_raise_message(Sass::SyntaxError, "Blue value must be between 0 and 255") {Color.new([1, 2, -1])}
+    assert_raise_message(Sass::SyntaxError, "Red value must be between 0 and 255") {Color.new([256, 2, 3])}
+  end
+
+  def test_color_checks_rgba_input
+    assert_raise_message(Sass::SyntaxError, "Alpha channel must be between 0 and 1") {Color.new([1, 2, 3, 1.1])}
+    assert_raise_message(Sass::SyntaxError, "Alpha channel must be between 0 and 1") {Color.new([1, 2, 3, -0.1])}
   end
 
   def test_string_escapes
+    assert_equal "'", resolve("\"'\"")
     assert_equal '"', resolve("\"\\\"\"")
-    assert_equal "\\", resolve("\"\\\\\"")
+    assert_equal "\\\\", resolve("\"\\\\\"")
     assert_equal "\\02fa", resolve("\"\\02fa\"")
+
+    assert_equal "'", resolve("'\\''")
+    assert_equal '"', resolve("'\"'")
+    assert_equal "\\\\", resolve("'\\\\'")
+    assert_equal "\\02fa", resolve("'\\02fa'")
+  end
+
+  def test_string_interpolation
+    assert_equal "foo2bar", resolve('\'foo#{1 + 1}bar\'')
+    assert_equal "foo2bar", resolve('"foo#{1 + 1}bar"')
+    assert_equal "foo1bar5baz4bang", resolve('\'foo#{1 + "bar#{2 + 3}baz" + 4}bang\'')
   end
 
   def test_color_names
@@ -22,15 +46,124 @@ class SassScriptTest < Test::Unit::TestCase
     assert_equal "#fffffe", resolve("white - #000001")
   end
 
-  def test_implicit_strings
-    silence_warnings do
-      assert_equal Sass::Script::String.new("foo"), eval("foo")
-      assert_equal Sass::Script::String.new("foo bar"), eval("foo bar")
-      assert_equal Sass::Script::String.new("foo/bar"), eval("foo/bar")
+  def test_rgba_color_literals
+    assert_equal Sass::Script::Color.new([1, 2, 3, 0.75]), eval("rgba(1, 2, 3, 0.75)")
+    assert_equal "rgba(1, 2, 3, 0.75)", resolve("rgba(1, 2, 3, 0.75)")
+
+    assert_equal Sass::Script::Color.new([1, 2, 3, 0]), eval("rgba(1, 2, 3, 0)")
+    assert_equal "rgba(1, 2, 3, 0)", resolve("rgba(1, 2, 3, 0)")
+
+    assert_equal Sass::Script::Color.new([1, 2, 3]), eval("rgba(1, 2, 3, 1)")
+    assert_equal Sass::Script::Color.new([1, 2, 3, 1]), eval("rgba(1, 2, 3, 1)")
+    assert_equal "#010203", resolve("rgba(1, 2, 3, 1)")
+    assert_equal "white", resolve("rgba(255, 255, 255, 1)")
+  end
+
+  def test_rgba_color_math
+    assert_equal "rgba(50, 50, 100, 0.35)", resolve("rgba(1, 1, 2, 0.35) * rgba(50, 50, 50, 0.35)")
+    assert_equal "rgba(52, 52, 52, 0.25)", resolve("rgba(2, 2, 2, 0.25) + rgba(50, 50, 50, 0.25)")
+
+    assert_raise_message(Sass::SyntaxError, "Alpha channels must be equal: rgba(1, 2, 3, 0.15) + rgba(50, 50, 50, 0.75)") do
+      resolve("rgba(1, 2, 3, 0.15) + rgba(50, 50, 50, 0.75)")
+    end
+    assert_raise_message(Sass::SyntaxError, "Alpha channels must be equal: #123456 * rgba(50, 50, 50, 0.75)") do
+      resolve("#123456 * rgba(50, 50, 50, 0.75)")
     end
+    assert_raise_message(Sass::SyntaxError, "Alpha channels must be equal: rgba(50, 50, 50, 0.75) / #123456") do
+      resolve("rgba(50, 50, 50, 0.75) / #123456")
+    end
+  end
+
+  def test_rgba_number_math
+    assert_equal "rgba(49, 49, 49, 0.75)", resolve("rgba(50, 50, 50, 0.75) - 1")
+    assert_equal "rgba(100, 100, 100, 0.75)", resolve("rgba(50, 50, 50, 0.75) * 2")
   end
 
-  def test_interpolation
+  def test_rgba_rounding
+    assert_equal "rgba(10, 1, 0, 0.123)", resolve("rgba(10.0, 1.23456789, 0.0, 0.1234567)")
+  end
+
+  def test_compressed_colors
+    assert_equal "#123456", resolve("#123456", :style => :compressed)
+    assert_equal "rgba(1,2,3,0.5)", resolve("rgba(1, 2, 3, 0.5)", :style => :compressed)
+    assert_equal "#123", resolve("#112233", :style => :compressed)
+    assert_equal "#000", resolve("black", :style => :compressed)
+    assert_equal "red", resolve("#f00", :style => :compressed)
+    assert_equal "blue", resolve("#00f", :style => :compressed)
+    assert_equal "navy", resolve("#000080", :style => :compressed)
+    assert_equal "navy #fff", resolve("#000080 white", :style => :compressed)
+    assert_equal "This color is #fff", resolve('"This color is #{ white }"', :style => :compressed)
+  end
+
+  def test_compressed_comma
+    # assert_equal "foo,bar,baz", resolve("foo, bar, baz", :style => :compressed)
+    # assert_equal "foo,#baf,baz", resolve("foo, #baf, baz", :style => :compressed)
+    assert_equal "foo,#baf,red", resolve("foo, #baf, #f00", :style => :compressed)
+  end
+
+  def test_implicit_strings
+    assert_equal Sass::Script::String.new("foo"), eval("foo")
+    assert_equal Sass::Script::String.new("foo bar"), eval("foo bar")
+    assert_equal Sass::Script::String.new("foo/bar"), eval("foo/bar")
+  end
+
+  def test_basic_interpolation
+    assert_equal "foo3bar", resolve("foo\#{1 + 2}bar")
+    assert_equal "foo3 bar", resolve("foo\#{1 + 2} bar")
+    assert_equal "foo 3bar", resolve("foo \#{1 + 2}bar")
+    assert_equal "foo 3 bar", resolve("foo \#{1 + 2} bar")
+    assert_equal "foo 35 bar", resolve("foo \#{1 + 2}\#{2 + 3} bar")
+    assert_equal "foo 3 5 bar", resolve("foo \#{1 + 2} \#{2 + 3} bar")
+    assert_equal "3bar", resolve("\#{1 + 2}bar")
+    assert_equal "foo3", resolve("foo\#{1 + 2}")
+    assert_equal "3", resolve("\#{1 + 2}")
+  end
+
+  def test_interpolation_in_function
+    assert_equal 'flabnabbit(1foo)', resolve('flabnabbit(#{1 + "foo"})')
+    assert_equal 'flabnabbit(foo 1foobaz)', resolve('flabnabbit(foo #{1 + "foo"}baz)')
+    assert_equal('flabnabbit(foo 1foo2bar baz)',
+      resolve('flabnabbit(foo #{1 + "foo"}#{2 + "bar"} baz)'))
+  end
+
+  def test_interpolation_near_operators
+    assert_equal '3 , 7', resolve('#{1 + 2} , #{3 + 4}')
+    assert_equal '3, 7', resolve('#{1 + 2}, #{3 + 4}')
+    assert_equal '3 ,7', resolve('#{1 + 2} ,#{3 + 4}')
+    assert_equal '3,7', resolve('#{1 + 2},#{3 + 4}')
+
+    assert_equal '3 / 7', resolve('3 / #{3 + 4}')
+    assert_equal '3 /7', resolve('3 /#{3 + 4}')
+    assert_equal '3/ 7', resolve('3/ #{3 + 4}')
+    assert_equal '3/7', resolve('3/#{3 + 4}')
+
+    assert_equal '3 * 7', resolve('#{1 + 2} * 7')
+    assert_equal '3* 7', resolve('#{1 + 2}* 7')
+    assert_equal '3 *7', resolve('#{1 + 2} *7')
+    assert_equal '3*7', resolve('#{1 + 2}*7')
+
+    assert_equal '-3', resolve('-#{1 + 2}')
+    assert_equal '- 3', resolve('- #{1 + 2}')
+
+    assert_equal '5 + 3 * 7', resolve('5 + #{1 + 2} * #{3 + 4}')
+    assert_equal '5 +3 * 7', resolve('5 +#{1 + 2} * #{3 + 4}')
+    assert_equal '5+3 * 7', resolve('5+#{1 + 2} * #{3 + 4}')
+    assert_equal '3 * 7 + 5', resolve('#{1 + 2} * #{3 + 4} + 5')
+    assert_equal '3 * 7+ 5', resolve('#{1 + 2} * #{3 + 4}+ 5')
+    assert_equal '3 * 7+5', resolve('#{1 + 2} * #{3 + 4}+5')
+
+    assert_equal '5/3 + 7', resolve('5 / (#{1 + 2} + #{3 + 4})')
+    assert_equal '5/3 + 7', resolve('5 /(#{1 + 2} + #{3 + 4})')
+    assert_equal '5/3 + 7', resolve('5 /( #{1 + 2} + #{3 + 4} )')
+    assert_equal '3 + 7/5', resolve('(#{1 + 2} + #{3 + 4}) / 5')
+    assert_equal '3 + 7/5', resolve('(#{1 + 2} + #{3 + 4})/ 5')
+    assert_equal '3 + 7/5', resolve('( #{1 + 2} + #{3 + 4} )/ 5')
+
+    assert_equal '3 + 5', resolve('#{1 + 2} + 2 + 3')
+    assert_equal '3 +5', resolve('#{1 + 2} +2 + 3')
+  end
+
+  def test_string_interpolation
     assert_equal "foo bar, baz bang", resolve('"foo #{"bar"}, #{"baz"} bang"')
     assert_equal "foo bar baz bang", resolve('"foo #{"#{"ba" + "r"} baz"} bang"')
     assert_equal 'foo #{bar baz} bang', resolve('"foo \#{#{"ba" + "r"} baz} bang"')
@@ -46,78 +179,57 @@ foo \#{"\#{"ba" + "r"} baz"} bang
   a: b
 SASS
     assert_equal(<<CSS, render(<<SASS))
-foo \#{bar baz} bang {
+foo [bar="\#{bar baz}"] bang {
   a: b; }
 CSS
-foo \\\#{\#{"ba" + "r"} baz} bang
+foo [bar="\\\#{\#{"ba" + "r"} baz}"] bang
   a: b
 SASS
     assert_equal(<<CSS, render(<<SASS))
-foo \#{baz bang {
+foo [bar="\#{baz"] bang {
   a: b; }
 CSS
-foo \#{"\\\#{" + "baz"} bang
+foo [bar="\#{"\\\#{" + "baz"}"] bang
   a: b
 SASS
   end
 
-  def test_implicit_string_warning
-    assert_warning(<<WARN) {eval("foo")}
-DEPRECATION WARNING:
-On line 1, character 1 of 'test_implicit_string_warning_inline.sass'
-Implicit strings have been deprecated and will be removed in version 3.0.
-'foo' was not quoted. Please add double quotes (e.g. "foo").
-WARN
-    assert_warning(<<WARN) {eval("1 + foo")}
-DEPRECATION WARNING:
-On line 1, character 5 of 'test_implicit_string_warning_inline.sass'
-Implicit strings have been deprecated and will be removed in version 3.0.
-'foo' was not quoted. Please add double quotes (e.g. "foo").
-WARN
-    assert_warning(<<WARN) {render("@if 1 + foo")}
-DEPRECATION WARNING:
-On line 1, character 9 of 'test_implicit_string_warning_inline.sass'
-Implicit strings have been deprecated and will be removed in version 3.0.
-'foo' was not quoted. Please add double quotes (e.g. "foo").
-WARN
-
-    # Regression
-    assert_warning(<<WARN) {render("@if if")}
-DEPRECATION WARNING:
-On line 1, character 5 of 'test_implicit_string_warning_inline.sass'
-Implicit strings have been deprecated and will be removed in version 3.0.
-'if' was not quoted. Please add double quotes (e.g. "if").
-WARN
-  end
-
   def test_inaccessible_functions
-    assert_warning <<WARN do
-DEPRECATION WARNING:
-On line 2, character 6 of 'test_inaccessible_functions_inline.sass'
-Implicit strings have been deprecated and will be removed in version 3.0.
-'to_s' was not quoted. Please add double quotes (e.g. "to_s").
-WARN
-      assert_equal "send(to_s)", resolve("send(to_s)", :line => 2)
-    end
+    assert_equal "send(to_s)", resolve("send(to_s)", :line => 2)
     assert_equal "public_instance_methods()", resolve("public_instance_methods()")
   end
 
-  def test_hyphen_warning
-    a = Sass::Script::String.new("a")
-    b = Sass::Script::String.new("b")
-    assert_warning(<<WARN) {eval("!a-!b", {}, env("a" => a, "b" => b))}
-DEPRECATION WARNING:
-On line 1, character 3 of 'test_hyphen_warning_inline.sass'
-- will be allowed as part of variable names in version 3.0.
-Please add whitespace to separate it from the previous token.
-WARN
+  def test_default_functions
+    assert_equal "url(12)", resolve("url(12)")
+    assert_equal 'blam("foo")', resolve('blam("foo")')
+  end
+
+  def test_function_results_have_options
+    assert_equal "Options defined!", resolve("assert_options(abs(1))")
+    assert_equal "Options defined!", resolve("assert_options(round(1.2))")
+  end
+
+  def test_funcall_requires_no_whitespace_before_lparen
+    assert_equal "no-repeat 15px", resolve("no-repeat (7px + 8px)")
+    assert_equal "no-repeat(15px)", resolve("no-repeat(7px + 8px)")
+  end
+
+  def test_dynamic_url
+    assert_equal "url(foo-bar)", resolve("url($foo)", {}, env('foo' => Sass::Script::String.new("foo-bar")))
+    assert_equal "url(foo-bar baz)", resolve("url($foo $bar)", {}, env('foo' => Sass::Script::String.new("foo-bar"), 'bar' => Sass::Script::String.new("baz")))
+    assert_equal "url(foo baz)", resolve("url(foo $bar)", {}, env('bar' => Sass::Script::String.new("baz")))
+    assert_equal "url(foo bar)", resolve("url(foo    bar)")
+  end
+
+  def test_url_with_interpolation
+    assert_equal "url(http://sass-lang.com/images/foo-bar)", resolve("url(http://sass-lang.com/images/\#{foo-bar})")
+    assert_equal 'url("http://sass-lang.com/images/foo-bar")', resolve("url('http://sass-lang.com/images/\#{foo-bar}')")
+    assert_equal 'url("http://sass-lang.com/images/foo-bar")', resolve('url("http://sass-lang.com/images/#{foo-bar}")')
+    assert_unquoted "url(http://sass-lang.com/images/\#{foo-bar})"
+  end
 
-    assert_warning(<<WARN) {eval("true-false")}
-DEPRECATION WARNING:
-On line 1, character 5 of 'test_hyphen_warning_inline.sass'
-- will be allowed as part of variable names in version 3.0.
-Please add whitespace to separate it from the previous token.
-WARN
+  def test_hyphenated_variables
+    assert_equal("a-b", resolve("$a-b", {}, env("a-b" => Sass::Script::String.new("a-b"))))
   end
 
   def test_ruby_equality
@@ -155,27 +267,27 @@ WARN
     assert_equal "2", resolve("1 + 1")
     assert_equal "0", resolve("1 - 1")
     assert_equal "8", resolve("2 * 4")
-    assert_equal "0.5", resolve("2 / 4")
-    assert_equal "2", resolve("4 / 2")
+    assert_equal "0.5", resolve("(2 / 4)")
+    assert_equal "2", resolve("(4 / 2)")
 
     assert_equal "-1", resolve("-1")
   end
 
   def test_string_ops
-    assert_equal "foo bar", resolve('"foo" "bar"')
+    assert_equal '"foo" "bar"', resolve('"foo" "bar"')
     assert_equal "true 1", resolve('true 1')
-    assert_equal "foo, bar", resolve('"foo" , "bar"')
+    assert_equal '"foo", "bar"', resolve("'foo' , 'bar'")
     assert_equal "true, 1", resolve('true , 1')
     assert_equal "foobar", resolve('"foo" + "bar"')
     assert_equal "true1", resolve('true + 1')
-    assert_equal "foo-bar", resolve('"foo" - "bar"')
+    assert_equal '"foo"-"bar"', resolve("'foo' - 'bar'")
     assert_equal "true-1", resolve('true - 1')
-    assert_equal "foo/bar", resolve('"foo" / "bar"')
+    assert_equal '"foo"/"bar"', resolve('"foo" / "bar"')
     assert_equal "true/1", resolve('true / 1')
 
-    assert_equal "-bar", resolve('- "bar"')
+    assert_equal '-"bar"', resolve("- 'bar'")
     assert_equal "-true", resolve('- true')
-    assert_equal "/bar", resolve('/ "bar"')
+    assert_equal '/"bar"', resolve('/ "bar"')
     assert_equal "/true", resolve('/ true')
   end
 
@@ -195,7 +307,7 @@ WARN
   end
 
   def test_equals
-    assert_equal("true", resolve('"foo" == !foo', {},
+    assert_equal("true", resolve('"foo" == $foo', {},
         env("foo" => Sass::Script::String.new("foo"))))
     assert_equal "true", resolve("1 == 1.0")
     assert_equal "true", resolve("false != true")
@@ -225,23 +337,114 @@ WARN
     assert_equal "true", resolve("1.1cm == 11mm")
   end
 
-  # Regression tests
+  def test_operations_have_options
+    assert_equal "Options defined!", resolve("assert_options(1 + 1)")
+    assert_equal "Options defined!", resolve("assert_options('bar' + 'baz')")
+  end
+
+  def test_slash_compiles_literally_when_left_alone
+    assert_equal "1px/2px", resolve("1px/2px")
+    assert_equal "1px/2px/3px/4px", resolve("1px/2px/3px/4px")
+
+    assert_equal "1px/2px redpx bluepx", resolve("1px/2px redpx bluepx")
+    assert_equal "foo 1px/2px/3px bar", resolve("foo 1px/2px/3px bar")
+  end
+
+  def test_slash_divides_with_parens
+    assert_equal "0.5", resolve("(1px/2px)")
+    assert_equal "0.5", resolve("(1px)/2px")
+    assert_equal "0.5", resolve("1px/(2px)")
+  end
+
+  def test_slash_divides_with_other_arithmetic
+    assert_equal "0.5px", resolve("1px*1px/2px")
+    assert_equal "0.5px", resolve("1px/2px*1px")
+    assert_equal "0.5", resolve("0+1px/2px")
+    assert_equal "0.5", resolve("1px/2px+0")
+  end
+
+  def test_slash_divides_with_variable
+    assert_equal "0.5", resolve("$var/2px", {}, env("var" => eval("1px")))
+    assert_equal "0.5", resolve("1px/$var", {}, env("var" => eval("2px")))
+    assert_equal "0.5", resolve("$var", {}, env("var" => eval("1px/2px")))
+  end
+
+  def test_colors_with_wrong_number_of_digits
+    assert_raise_message(Sass::SyntaxError,
+      "Colors must have either three or six digits: '#0'") {eval("#0")}
+    assert_raise_message(Sass::SyntaxError,
+      "Colors must have either three or six digits: '#12'") {eval("#12")}
+    assert_raise_message(Sass::SyntaxError,
+      "Colors must have either three or six digits: '#abcd'") {eval("#abcd")}
+    assert_raise_message(Sass::SyntaxError,
+      "Colors must have either three or six digits: '#abcdE'") {eval("#abcdE")}
+    assert_raise_message(Sass::SyntaxError,
+      "Colors must have either three or six digits: '#abcdEFA'") {eval("#abcdEFA")}
+  end
+
+  def test_case_insensitive_color_names
+    assert_equal "blue", resolve("BLUE")
+    assert_equal "red", resolve("rEd")
+    assert_equal "#7f4000", resolve("mix(GrEeN, ReD)")
+  end
+
+  # Regression Tests
+
+  def test_funcall_has_higher_precedence_than_color_name
+    assert_equal "teal(12)", resolve("teal(12)")
+    assert_equal "tealbang(12)", resolve("tealbang(12)")
+    assert_equal "teal-bang(12)", resolve("teal-bang(12)")
+    assert_equal "teal\\+bang(12)", resolve("teal\\+bang(12)")
+  end
 
   def test_interpolation_after_hash
     assert_equal "#2", resolve('"##{1 + 1}"')
   end
 
+  def test_misplaced_comma_in_funcall
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid CSS after "foo(bar, ": expected function argument, was ")"') {eval('foo(bar, )')}
+  end
+
+  def test_color_prefixed_identifier
+    assert_equal "tealbang", resolve("tealbang")
+    assert_equal "teal-bang", resolve("teal-bang")
+  end
+
+  def test_op_prefixed_identifier
+    assert_equal "notbang", resolve("notbang")
+    assert_equal "not-bang", resolve("not-bang")
+    assert_equal "or-bang", resolve("or-bang")
+    assert_equal "and-bang", resolve("and-bang")
+  end
+
   private
 
   def resolve(str, opts = {}, environment = env)
     munge_filename opts
-    eval(str, opts, environment).to_s
+    val = eval(str, opts, environment)
+    val.is_a?(Sass::Script::String) ? val.value : val.to_s
+  end
+
+  def assert_unquoted(str, opts = {}, environment = env)
+    munge_filename opts
+    val = eval(str, opts, environment)
+    assert_kind_of Sass::Script::String, val
+    assert_equal :identifier, val.type
+  end
+
+  def assert_quoted(str, opts = {}, environment = env)
+    munge_filename opts
+    val = eval(str, opts, environment)
+    assert_kind_of Sass::Script::String, val
+    assert_equal :string, val.type
   end
 
   def eval(str, opts = {}, environment = env)
     munge_filename opts
-    Sass::Script.parse(str, opts[:line] || 1,
-      opts[:offset] || 0, opts[:filename]).perform(environment)
+    environment.options = opts
+    Sass::Script.parse(str, opts.delete(:line) || 1,
+      opts.delete(:offset) || 0, opts).perform(environment)
   end
 
   def render(sass, options = {})

data/vendor/plugins/haml/test/sass/scss/css_test.rb

@@ -0,0 +1,916 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+require File.dirname(__FILE__) + '/test_helper'
+require 'sass/scss/css_parser'
+
+# These tests just test the parsing of CSS
+# (both standard and any hacks we intend to support).
+# Tests of SCSS-specific behavior go in scss_test.rb.
+class ScssCssTest < Test::Unit::TestCase
+  include ScssTestHelper
+
+  def test_basic_scss
+    assert_parses <<SCSS
+selector {
+  property: value;
+  property2: value; }
+SCSS
+
+    assert_equal <<CSS, render('sel{p:v}')
+sel {
+  p: v; }
+CSS
+  end
+
+  def test_empty_rule
+    assert_equal "", render("#foo .bar {}")
+    assert_equal "", render(<<SCSS)
+#foo .bar {
+}
+SCSS
+  end
+
+  def test_cdo_and_cdc_ignored_at_toplevel
+    assert_equal <<CSS, render(<<SCSS)
+foo {
+  bar: baz; }
+
+bar {
+  bar: baz; }
+
+baz {
+  bar: baz; }
+CSS
+foo {bar: baz}
+<!--
+bar {bar: baz}
+-->
+baz {bar: baz}
+SCSS
+  end
+
+  if Haml::Util.ruby1_8?
+    def test_unicode
+      assert_parses <<SCSS
+@charset "UTF-8";
+foo {
+  bar: föö bâr; }
+SCSS
+      assert_parses <<SCSS
+foo {
+  bar: föö bâr; }
+SCSS
+    end
+  else
+    def test_unicode
+      assert_parses <<SCSS
+@charset "UTF-8";
+foo {
+  bar: föö bâr; }
+SCSS
+      assert_equal <<CSS, render(<<SCSS)
+@charset "UTF-8";
+foo {
+  bar: föö bâr; }
+CSS
+foo {
+  bar: föö bâr; }
+SCSS
+    end
+  end
+
+  def test_invisible_comments
+    assert_equal <<CSS, render(<<SCSS)
+foo {
+  a: d; }
+CSS
+foo {a: /* b; c: */ d}
+SCSS
+    assert_equal <<CSS, render(<<SCSS)
+foo {
+  a: d; }
+CSS
+foo {a /*: b; c */: d}
+SCSS
+  end
+
+  def test_crazy_comments 
+    # http://www.w3.org/Style/CSS/Test/CSS2.1/current/xhtml1/t040109-c17-comments-00-b.xht
+    assert_equal <<CSS, render(<<SCSS)
+/* This is a CSS comment. */
+.one {
+  color: green; }
+
+/* Another comment */
+/* The following should not be used:
+.two {color: red;} */
+.three {
+  color: green;
+  /* color: red; */ }
+
+/**
+.four {color: red;} */
+.five {
+  color: green; }
+
+/**/
+.six {
+  color: green; }
+
+/*********/
+.seven {
+  color: green; }
+
+/* a comment **/
+.eight {
+  color: green; }
+CSS
+/* This is a CSS comment. */
+.one {color: green;} /* Another comment */
+/* The following should not be used:
+.two {color: red;} */
+.three {color: green; /* color: red; */}
+/**
+.four {color: red;} */
+.five {color: green;}
+/**/
+.six {color: green;}
+/*********/
+.seven {color: green;}
+/* a comment **/
+.eight {color: green;}
+SCSS
+  end
+
+  def test_rule_comments
+    assert_parses <<SCSS
+/* Foo */
+.foo {
+  a: b; }
+SCSS
+    assert_equal <<CSS, render(<<SCSS)
+/* Foo
+ * Bar */
+.foo {
+  a: b; }
+CSS
+/* Foo
+ * Bar */.foo {
+  a: b; }
+SCSS
+  end
+
+  def test_property_comments
+    assert_parses <<SCSS
+.foo {
+  /* Foo */
+  a: b; }
+SCSS
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  /* Foo
+   * Bar */
+  a: b; }
+CSS
+.foo {
+  /* Foo
+   * Bar */a: b; }
+SCSS
+  end
+
+  def test_selector_comments
+    assert_equal <<CSS, render(<<SCSS)
+.foo #bar:baz(bip) {
+  a: b; }
+CSS
+.foo /* .a #foo */ #bar:baz(/* bang )*/ bip) {
+  a: b; }
+SCSS
+  end
+
+  def test_lonely_comments
+    assert_parses <<SCSS
+/* Foo
+ * Bar */
+SCSS
+    assert_parses <<SCSS
+.foo {
+  /* Foo
+   * Bar */ }
+SCSS
+  end
+
+  def test_multiple_comments
+    assert_parses <<SCSS
+/* Foo
+ * Bar */
+/* Baz
+ * Bang */
+SCSS
+    assert_parses <<SCSS
+.foo {
+  /* Foo
+   * Bar */
+  /* Baz
+   * Bang */ }
+SCSS
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  /* Foo Bar */
+  /* Baz Bang */ }
+CSS
+.foo {
+  /* Foo Bar *//* Baz Bang */ }
+SCSS
+  end
+
+  def test_bizarrely_formatted_comments
+    assert_parses <<SCSS
+.foo {
+  /* Foo
+Bar
+  Baz */
+  a: b; }
+SCSS
+    assert_parses <<SCSS
+.foo {
+    /* Foo
+Bar
+  Baz */
+  a: b; }
+SCSS
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+   /* Foo
+Bar */
+  a: b; }
+CSS
+.foo {/* Foo
+   Bar */
+  a: b; }
+SCSS
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+    /* Foo
+ Bar
+Baz */
+  a: b; }
+CSS
+.foo {/* Foo
+   Bar
+  Baz */
+  a: b; }
+SCSS
+  end
+
+  ## Declarations
+
+  def test_vendor_properties
+    assert_parses <<SCSS
+foo {
+  -moz-foo-bar: blat;
+  -o-flat-blang: wibble; }
+SCSS
+  end
+
+  def test_empty_declarations
+    assert_equal <<CSS, render(<<SCSS)
+foo {
+  bar: baz; }
+CSS
+foo {;;;;
+  bar: baz;;;;
+  ;;}
+SCSS
+  end
+
+  def test_basic_property_types
+    assert_parses <<SCSS
+foo {
+  a: 2;
+  b: 2.3em;
+  c: 50%;
+  d: "fraz bran";
+  e: flanny-blanny-blan;
+  f: url(http://sass-lang.com);
+  g: U+ffa?;
+  h: #aabbcc; }
+SCSS
+  end
+
+  def test_functions
+    assert_parses <<SCSS
+foo {
+  a: foo-bar(12);
+  b: -foo-bar-baz(13, 14 15); }
+SCSS
+  end
+
+  def test_unary_minus
+    assert_parses <<SCSS
+foo {
+  a: -2;
+  b: -2.3em;
+  c: -50%;
+  d: -foo(bar baz); }
+SCSS
+  end
+
+  def test_operators
+    assert_parses <<SCSS
+foo {
+  a: foo bar baz;
+  b: foo, #aabbcc, -12;
+  c: 1px/2px/-3px;
+  d: foo bar, baz/bang; }
+SCSS
+  end
+
+  def test_important
+    assert_parses <<SCSS
+foo {
+  a: foo !important;
+  b: foo bar !important;
+  b: foo, bar !important; }
+SCSS
+  end
+
+  def test_initial_hyphen
+    assert_parses <<SCSS
+foo {
+  a: -moz-bar-baz;
+  b: foo -o-bar-baz; }
+SCSS
+  end
+
+  def test_ms_long_filter_syntax
+    assert_equal <<CSS, render(<<SCSS)
+foo {
+  filter: progid:DXImageTransform.Microsoft.gradient(GradientType=1, startColorstr=#c0ff3300, endColorstr=#ff000000);
+  filter: progid:DXImageTransform.Microsoft.gradient(GradientType=1, startColorstr=#c0ff3300, endColorstr=#ff000000); }
+CSS
+foo {
+  filter: progid:DXImageTransform.Microsoft.gradient(GradientType=1, startColorstr=#c0ff3300, endColorstr=#ff000000);
+  filter:progid:DXImageTransform.Microsoft.gradient(GradientType=1, startColorstr=#c0ff3300, endColorstr=#ff000000); }
+SCSS
+  end
+
+  def test_ms_short_filter_syntax
+    assert_parses <<SCSS
+foo {
+  filter: alpha(opacity=20);
+  filter: alpha(opacity=20, enabled=true);
+  filter: blaznicate(foo=bar, baz=bang bip, bart=#fa4600); }
+SCSS
+  end
+
+  def test_declaration_hacks
+    assert_parses <<SCSS
+foo {
+  _name: val;
+  *name: val;
+  :name: val;
+  .name: val;
+  #name: val;
+  name/**/: val;
+  name/*\\**/: val;
+  name: val; }
+SCSS
+  end
+
+  def test_trailing_hash_hack
+    assert_parses <<SCSS
+foo {
+  foo: bar;
+  #baz: bang;
+  #bip: bop; }
+SCSS
+  end
+
+  def test_zero_arg_functions
+    assert_parses <<SCSS
+foo {
+  a: foo();
+  b: bar baz-bang() bip; }
+SCSS
+  end
+
+  def test_expression_function
+    assert_parses <<SCSS
+foo {
+  a: 12px expression(1 + (3 / Foo.bar("baz" + "bang") + function() {return 12;}) % 12); }
+SCSS
+  end
+
+  def test_calc_function
+    assert_parses <<SCSS
+foo {
+  a: 12px calc(100%/3 - 2*1em - 2*1px);
+  b: 12px -moz-calc(100%/3 - 2*1em - 2*1px);
+  b: 12px -webkit-calc(100%/3 - 2*1em - 2*1px);
+  b: 12px -foobar-calc(100%/3 - 2*1em - 2*1px); }
+SCSS
+  end
+
+  def test_unary_ops
+    assert_equal <<CSS, render(<<SCSS)
+foo {
+  a: -0.5em;
+  b: 0.5em;
+  c: -foo(12px);
+  d: +foo(12px); }
+CSS
+foo {
+  a: -0.5em;
+  b: +0.5em;
+  c: -foo(12px);
+  d: +foo(12px); }
+SCSS
+  end
+
+  def test_css_string_escapes
+    assert_parses <<SCSS
+foo {
+  a: "\\foo bar";
+  b: "foo\\ bar";
+  c: "\\2022 \\0020";
+  d: "foo\\\\bar";
+  e: "foo\\"'bar"; }
+SCSS
+  end
+
+  def test_css_ident_escapes
+    assert_parses <<SCSS
+foo {
+  a: \\foo bar;
+  b: foo\\ bar;
+  c: \\2022 \\0020;
+  d: foo\\\\bar;
+  e: foo\\"\\'bar; }
+SCSS
+  end
+
+  ## Directives
+
+  def test_namespace_directive
+    assert_parses '@namespace "http://www.w3.org/Profiles/xhtml1-strict";'
+    assert_parses '@namespace url(http://www.w3.org/Profiles/xhtml1-strict);'
+    assert_parses '@namespace html url("http://www.w3.org/Profiles/xhtml1-strict");'
+  end
+
+  def test_media_directive
+    assert_parses <<SCSS
+@media all {
+  rule1 {
+    prop: val; }
+
+  rule2 {
+    prop: val; } }
+SCSS
+    assert_parses <<SCSS
+@media screen, print {
+  rule1 {
+    prop: val; }
+
+  rule2 {
+    prop: val; } }
+SCSS
+  end
+
+  def test_media_directive_with_keywords
+    assert_parses <<SCSS
+@media screen and (-webkit-min-device-pixel-ratio:0) {
+  a: b; }
+SCSS
+    assert_parses <<SCSS
+@media only screen, print and (foo: 0px) and (bar: flam(12px solid)) {
+  a: b; }
+SCSS
+  end
+
+  def test_import_directive
+    assert_parses '@import "foo.css";'
+    assert_parses "@import 'foo.css';"
+    assert_parses '@import url("foo.css");'
+    assert_parses "@import url('foo.css');"
+    assert_parses '@import url(foo.css);'
+  end
+
+  def test_import_directive_with_media
+    assert_parses '@import "foo.css" screen;'
+    assert_parses '@import "foo.css" screen, print;'
+    assert_parses '@import "foo.css" screen, print and (foo: 0);'
+    assert_parses '@import "foo.css" screen, only print, screen and (foo: 0);'
+  end
+
+  def test_page_directive
+    assert_parses <<SCSS
+@page {
+  prop1: val;
+  prop2: val; }
+SCSS
+    assert_parses <<SCSS
+@page flap {
+  prop1: val;
+  prop2: val; }
+SCSS
+    assert_parses <<SCSS
+@page :first {
+  prop1: val;
+  prop2: val; }
+SCSS
+    assert_parses <<SCSS
+@page flap:first {
+  prop1: val;
+  prop2: val; }
+SCSS
+  end
+
+  def test_blockless_directive_without_semicolon
+    assert_equal "@foo \"bar\";\n", render('@foo "bar"')
+  end
+
+  def test_directive_with_lots_of_whitespace
+    assert_equal "@foo \"bar\";\n", render('@foo    "bar"  ;')
+  end
+
+  def test_empty_blockless_directive
+    assert_parses "@foo;"
+  end
+
+  def test_multiple_blockless_directives
+    assert_parses <<SCSS
+@foo bar;
+@bar baz;
+SCSS
+  end
+
+  def test_empty_block_directive
+    assert_parses "@foo {}"
+    assert_equal "@foo {}\n", render(<<SCSS)
+@foo {
+}
+SCSS
+  end
+
+  def test_multiple_block_directives
+    assert_parses <<SCSS
+@foo bar {
+  a: b; }
+
+@bar baz {
+  c: d; }
+SCSS
+  end
+
+  def test_block_directive_with_rule_and_property
+    assert_parses <<SCSS
+@foo {
+  rule {
+    a: b; }
+
+  a: b; }
+SCSS
+  end
+
+  def test_block_directive_with_semicolon
+    assert_equal <<CSS, render(<<SCSS)
+@foo {
+  a: b; }
+
+@bar {
+  a: b; }
+CSS
+@foo {a:b};
+@bar {a:b};
+SCSS
+  end
+
+  ## Selectors
+
+  # Taken from http://www.w3.org/TR/css3-selectors/#selectors
+  def test_summarized_selectors
+    assert_selector_parses('*')
+    assert_selector_parses('E')
+    assert_selector_parses('E[foo]')
+    assert_selector_parses('E[foo="bar"]')
+    assert_selector_parses('E[foo~="bar"]')
+    assert_selector_parses('E[foo^="bar"]')
+    assert_selector_parses('E[foo$="bar"]')
+    assert_selector_parses('E[foo*="bar"]')
+    assert_selector_parses('E[foo|="en"]')
+    assert_selector_parses('E:root')
+    assert_selector_parses('E:nth-child(n)')
+    assert_selector_parses('E:nth-last-child(n)')
+    assert_selector_parses('E:nth-of-type(n)')
+    assert_selector_parses('E:nth-last-of-type(n)')
+    assert_selector_parses('E:first-child')
+    assert_selector_parses('E:last-child')
+    assert_selector_parses('E:first-of-type')
+    assert_selector_parses('E:last-of-type')
+    assert_selector_parses('E:only-child')
+    assert_selector_parses('E:only-of-type')
+    assert_selector_parses('E:empty')
+    assert_selector_parses('E:link')
+    assert_selector_parses('E:visited')
+    assert_selector_parses('E:active')
+    assert_selector_parses('E:hover')
+    assert_selector_parses('E:focus')
+    assert_selector_parses('E:target')
+    assert_selector_parses('E:lang(fr)')
+    assert_selector_parses('E:enabled')
+    assert_selector_parses('E:disabled')
+    assert_selector_parses('E:checked')
+    assert_selector_parses('E::first-line')
+    assert_selector_parses('E::first-letter')
+    assert_selector_parses('E::before')
+    assert_selector_parses('E::after')
+    assert_selector_parses('E.warning')
+    assert_selector_parses('E#myid')
+    assert_selector_parses('E:not(s)')
+    assert_selector_parses('E F')
+    assert_selector_parses('E > F')
+    assert_selector_parses('E + F')
+    assert_selector_parses('E ~ F')
+  end
+
+  # Taken from http://www.w3.org/TR/css3-selectors/#selectors,
+  # but without the element names
+  def test_lonely_selectors
+    assert_selector_parses('[foo]')
+    assert_selector_parses('[foo="bar"]')
+    assert_selector_parses('[foo~="bar"]')
+    assert_selector_parses('[foo^="bar"]')
+    assert_selector_parses('[foo$="bar"]')
+    assert_selector_parses('[foo*="bar"]')
+    assert_selector_parses('[foo|="en"]')
+    assert_selector_parses(':root')
+    assert_selector_parses(':nth-child(n)')
+    assert_selector_parses(':nth-last-child(n)')
+    assert_selector_parses(':nth-of-type(n)')
+    assert_selector_parses(':nth-last-of-type(n)')
+    assert_selector_parses(':first-child')
+    assert_selector_parses(':last-child')
+    assert_selector_parses(':first-of-type')
+    assert_selector_parses(':last-of-type')
+    assert_selector_parses(':only-child')
+    assert_selector_parses(':only-of-type')
+    assert_selector_parses(':empty')
+    assert_selector_parses(':link')
+    assert_selector_parses(':visited')
+    assert_selector_parses(':active')
+    assert_selector_parses(':hover')
+    assert_selector_parses(':focus')
+    assert_selector_parses(':target')
+    assert_selector_parses(':lang(fr)')
+    assert_selector_parses(':enabled')
+    assert_selector_parses(':disabled')
+    assert_selector_parses(':checked')
+    assert_selector_parses('::first-line')
+    assert_selector_parses('::first-letter')
+    assert_selector_parses('::before')
+    assert_selector_parses('::after')
+    assert_selector_parses('.warning')
+    assert_selector_parses('#myid')
+    assert_selector_parses(':not(s)')
+  end
+
+  def test_attribute_selectors_with_identifiers
+    assert_selector_parses('[foo~=bar]')
+    assert_selector_parses('[foo^=bar]')
+    assert_selector_parses('[foo$=bar]')
+    assert_selector_parses('[foo*=bar]')
+    assert_selector_parses('[foo|=en]')
+  end
+
+  def test_nth_selectors
+    assert_selector_parses(':nth-child(-n)')
+    assert_selector_parses(':nth-child(+n)')
+
+    assert_selector_parses(':nth-child(even)')
+    assert_selector_parses(':nth-child(odd)')
+
+    assert_selector_parses(':nth-child(50)')
+    assert_selector_parses(':nth-child(-50)')
+    assert_selector_parses(':nth-child(+50)')
+
+    assert_selector_parses(':nth-child(2n+3)')
+    assert_selector_parses(':nth-child(2n-3)')
+    assert_selector_parses(':nth-child(+2n-3)')
+    assert_selector_parses(':nth-child(-2n+3)')
+    assert_selector_parses(':nth-child(-2n+ 3)')
+
+    assert_equal(<<CSS, render(<<SCSS))
+:nth-child(2n + 3) {
+  a: b; }
+CSS
+:nth-child( 2n + 3 ) {
+  a: b; }
+SCSS
+  end
+
+  def test_negation_selectors
+    assert_selector_parses(':not(foo|bar)')
+    assert_selector_parses(':not(*|bar)')
+
+    assert_selector_parses(':not(foo|*)')
+    assert_selector_parses(':not(*|*)')
+
+    assert_selector_parses(':not(#blah)')
+    assert_selector_parses(':not(.blah)')
+
+    assert_selector_parses(':not([foo])')
+    assert_selector_parses(':not([foo^="bar"])')
+    assert_selector_parses(':not([baz|foo~="bar"])')
+
+    assert_selector_parses(':not(:hover)')
+    assert_selector_parses(':not(:nth-child(2n + 3))')
+
+    # Not technically allowed, but what the heck
+    assert_selector_parses(':not(:not(#foo))')
+    assert_selector_parses(':not(a#foo.bar)')
+    assert_selector_parses(':not(#foo .bar > baz)')
+    assert_selector_parses(':not(h1, h2, h3)')
+  end
+
+  def test_moz_any_selector
+    assert_selector_parses(':-moz-any(h1, h2, h3)')
+    assert_selector_parses(':-moz-any(.foo)')
+    assert_selector_parses(':-moz-any(foo bar, .baz > .bang)')
+  end
+
+  def test_namespaced_selectors
+    assert_selector_parses('foo|E')
+    assert_selector_parses('*|E')
+    assert_selector_parses('foo|*')
+    assert_selector_parses('*|*')
+  end
+
+  def test_namespaced_attribute_selectors
+    assert_selector_parses('[foo|bar=baz]')
+    assert_selector_parses('[*|bar=baz]')
+    assert_selector_parses('[foo|bar|=baz]')
+  end
+
+  def test_comma_selectors
+    assert_selector_parses('E, F')
+    assert_selector_parses('E F, G H')
+    assert_selector_parses('E > F, G > H')
+  end
+
+  def test_selectors_with_newlines
+    assert_selector_parses("E,\nF")
+    assert_selector_parses("E\nF")
+    assert_selector_parses("E, F\nG, H")
+  end
+
+  def test_expression_fallback_selectors
+    assert_selector_parses('0%')
+    assert_selector_parses('60%')
+    assert_selector_parses('100%')
+    assert_selector_parses('12px')
+    assert_selector_parses('"foo"')
+  end
+
+  def test_functional_pseudo_selectors
+    assert_selector_parses(':foo("bar")')
+    assert_selector_parses(':foo(bar)')
+    assert_selector_parses(':foo(12px)')
+    assert_selector_parses(':foo(+)')
+    assert_selector_parses(':foo(-)')
+    assert_selector_parses(':foo(+"bar")')
+    assert_selector_parses(':foo(-++--baz-"bar"12px)')
+  end
+
+  def test_selector_hacks
+    assert_selector_parses('> E')
+    assert_selector_parses('+ E')
+    assert_selector_parses('~ E')
+    assert_selector_parses('> > E')
+    assert_equal <<CSS, render(<<SCSS)
+> > E {
+  a: b; }
+CSS
+>> E {
+  a: b; }
+SCSS
+
+    assert_selector_parses('E*')
+    assert_selector_parses('E*.foo')
+    assert_selector_parses('E*:hover')
+  end
+
+  ## Errors
+
+  def test_invalid_directives
+    assert_not_parses("identifier", '@<err> import "foo";')
+    assert_not_parses("identifier", '@<err>12 "foo";')
+  end
+
+  def test_invalid_classes
+    assert_not_parses("class name", 'p.<err> foo {a: b}')
+    assert_not_parses("class name", 'p.<err>1foo {a: b}')
+  end
+
+  def test_invalid_ids
+    assert_not_parses("id name", 'p#<err> foo {a: b}')
+  end
+
+  def test_no_properties_at_toplevel
+    assert_not_parses('pseudoclass or pseudoelement', 'a:<err> b;')
+  end
+
+  def test_no_scss_directives
+    assert_parses('@import "foo.sass";')
+    assert_parses <<SCSS
+@mixin foo {
+  a: b; }
+SCSS
+  end
+
+  def test_no_variables
+    assert_not_parses("selector or at-rule", "<err>$var = 12;")
+    assert_not_parses('"}"', "foo { <err>!var = 12; }")
+  end
+
+  def test_no_parent_selectors
+    assert_not_parses('"{"', "foo <err>&.bar {a: b}")
+  end
+
+  def test_no_selector_interpolation
+    assert_not_parses('"{"', 'foo <err>#{"bar"}.baz {a: b}')
+  end
+
+  def test_no_prop_name_interpolation
+    assert_not_parses('":"', 'foo {a<err>#{"bar"}baz: b}')
+  end
+
+  def test_no_prop_val_interpolation
+    assert_not_parses('"}"', 'foo {a: b <err>#{"bar"} c}')
+  end
+
+  def test_no_string_interpolation
+    assert_parses <<SCSS
+foo {
+  a: "bang \#{1 +    " bar "} bip"; }
+SCSS
+  end
+
+  def test_no_sass_script_values
+    assert_not_parses('"}"', 'foo {a: b <err>* c}')
+  end
+
+  def test_no_nested_rules
+    assert_not_parses('":"', 'foo {bar <err>{a: b}}')
+    assert_not_parses('"}"', 'foo {<err>[bar=baz] {a: b}}')
+  end
+
+  def test_no_nested_properties
+    assert_not_parses('expression (e.g. 1px, bold)', 'foo {bar: <err>{a: b}}')
+    assert_not_parses('expression (e.g. 1px, bold)', 'foo {bar: bang <err>{a: b}}')
+  end
+
+  def test_no_nested_directives
+    assert_not_parses('"}"', 'foo {<err>@bar {a: b}}')
+  end
+
+  def test_error_with_windows_newlines
+    render <<SCSS
+foo {bar}\r
+baz {a: b}
+SCSS
+    assert(false, "Expected syntax error")
+  rescue Sass::SyntaxError => e
+    assert_equal 'Invalid CSS after "foo {bar": expected ":", was "}"', e.message
+    assert_equal 1, e.sass_line
+  end
+
+  ## Regressions
+
+  def test_closing_line_comment_end_with_compact_output
+    assert_equal(<<CSS, render(<<SCSS, :style => :compact))
+/* foo */
+bar { baz: bang; }
+CSS
+/*
+ * foo
+ */
+bar {baz: bang}
+SCSS
+  end
+
+  private
+
+  def assert_selector_parses(selector)
+    assert_parses <<SCSS
+#{selector} {
+  a: b; }
+SCSS
+  end
+
+  def render(scss, options = {})
+    tree = Sass::SCSS::CssParser.new(scss).parse
+    tree.options = Sass::Engine::DEFAULT_OPTIONS.merge(options)
+    tree.render
+  end
+end