sass 3.1.0 → 3.3.0

data/test/sass/script_test.rb

@@ -5,21 +5,29 @@ require 'sass/engine'
 module Sass::Script::Functions::UserFunctions
   def assert_options(val)
     val.options[:foo]
-    Sass::Script::String.new("Options defined!")
+    Sass::Script::Value::String.new("Options defined!")
   end
+
+  def arg_error
+    assert_options
+  end
+end
+
+module Sass::Script::Functions
+  include Sass::Script::Functions::UserFunctions
 end
 
 class SassScriptTest < Test::Unit::TestCase
   include Sass::Script
 
   def test_color_checks_input
-    assert_raise_message(ArgumentError, "Blue value must be between 0 and 255") {Color.new([1, 2, -1])}
-    assert_raise_message(ArgumentError, "Red value must be between 0 and 255") {Color.new([256, 2, 3])}
+    assert_raise_message(ArgumentError, "Blue value -1 must be between 0 and 255") {Sass::Script::Value::Color.new([1, 2, -1])}
+    assert_raise_message(ArgumentError, "Red value 256 must be between 0 and 255") {Sass::Script::Value::Color.new([256, 2, 3])}
   end
 
   def test_color_checks_rgba_input
-    assert_raise_message(ArgumentError, "Alpha channel must be between 0 and 1") {Color.new([1, 2, 3, 1.1])}
-    assert_raise_message(ArgumentError, "Alpha channel must be between 0 and 1") {Color.new([1, 2, 3, -0.1])}
+    assert_raise_message(ArgumentError, "Alpha channel 1.1 must be between 0 and 1") {Sass::Script::Value::Color.new([1, 2, 3, 1.1])}
+    assert_raise_message(ArgumentError, "Alpha channel -0.1 must be between 0 and 1") {Sass::Script::Value::Color.new([1, 2, 3, -0.1])}
   end
 
   def test_string_escapes
@@ -34,27 +42,23 @@ class SassScriptTest < Test::Unit::TestCase
     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
     assert_equal "white", resolve("white")
     assert_equal "white", resolve("#ffffff")
     assert_equal "#fffffe", resolve("white - #000001")
+    assert_equal "transparent", resolve("transparent")
+    assert_equal "transparent", resolve("rgba(0, 0, 0, 0)")
   end
 
   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 Sass::Script::Value::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 Sass::Script::Value::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 Sass::Script::Value::Color.new([1, 2, 3]), eval("rgba(1, 2, 3, 1)")
+    assert_equal Sass::Script::Value::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
@@ -80,7 +84,7 @@ class SassScriptTest < Test::Unit::TestCase
   end
 
   def test_rgba_rounding
-    assert_equal "rgba(10, 1, 0, 0.123)", resolve("rgba(10.0, 1.23456789, 0.0, 0.1234567)")
+    assert_equal "rgba(10, 1, 0, 0.12346)", resolve("rgba(10.0, 1.23456789, 0.0, 0.1234567)")
   end
 
   def test_compressed_colors
@@ -93,6 +97,7 @@ class SassScriptTest < Test::Unit::TestCase
     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)
+    assert_equal "transparent", resolve("rgba(0, 0, 0, 0)", :style => :compressed)
   end
 
   def test_compressed_comma
@@ -102,8 +107,8 @@ class SassScriptTest < Test::Unit::TestCase
   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::Value::String.new("foo"), eval("foo")
+    assert_equal Sass::Script::Value::String.new("foo/bar"), eval("foo/bar")
   end
 
   def test_basic_interpolation
@@ -130,6 +135,9 @@ class SassScriptTest < Test::Unit::TestCase
     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, 11', resolve('#{1 + 2}, #{3 + 4}, #{5 + 6}')
+    assert_equal '3, 7, 11', resolve('3, #{3 + 4}, 11')
+    assert_equal '3, 7, 11', resolve('3, 7, #{5 + 6}')
 
     assert_equal '3 / 7', resolve('3 / #{3 + 4}')
     assert_equal '3 /7', resolve('3 /#{3 + 4}')
@@ -167,6 +175,9 @@ class SassScriptTest < Test::Unit::TestCase
     assert_equal "foo bar baz bang", resolve('"foo #{"#{"ba" + "r"} baz"} bang"')
     assert_equal 'foo #{bar baz} bang', resolve('"foo \#{#{"ba" + "r"} baz} bang"')
     assert_equal 'foo #{baz bang', resolve('"foo #{"\#{" + "baz"} bang"')
+    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_rule_interpolation
@@ -221,9 +232,9 @@ SASS
   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)", {}, env('foo' => Sass::Script::Value::String.new("foo-bar")))
+    assert_equal "url(foo-bar baz)", resolve("url($foo $bar)", {}, env('foo' => Sass::Script::Value::String.new("foo-bar"), 'bar' => Sass::Script::Value::String.new("baz")))
+    assert_equal "url(foo baz)", resolve("url(foo $bar)", {}, env('bar' => Sass::Script::Value::String.new("baz")))
     assert_equal "url(foo bar)", resolve("url(foo    bar)")
   end
 
@@ -235,7 +246,7 @@ SASS
   end
 
   def test_hyphenated_variables
-    assert_equal("a-b", resolve("$a-b", {}, env("a-b" => Sass::Script::String.new("a-b"))))
+    assert_equal("a-b", resolve("$a-b", {}, env("a-b" => Sass::Script::Value::String.new("a-b"))))
   end
 
   def test_ruby_equality
@@ -253,6 +264,10 @@ SASS
     assert_equal "false", resolve("false")
   end
 
+  def test_null
+    assert_equal "", resolve("null")
+  end
+
   def test_boolean_ops
     assert_equal "true", resolve("true and true")
     assert_equal "true", resolve("false or true")
@@ -271,6 +286,18 @@ SASS
     assert_equal "false", resolve("false and 1")
     assert_equal "2", resolve("2 or 3")
     assert_equal "3", resolve("2 and 3")
+
+    assert_equal "true", resolve("null or true")
+    assert_equal "true", resolve("true or null")
+    assert_equal "", resolve("null or null")
+    assert_equal "", resolve("null and true")
+    assert_equal "", resolve("true and null")
+    assert_equal "", resolve("null and null")
+
+    assert_equal "true", resolve("not null")
+
+    assert_equal "1", resolve("null or 1")
+    assert_equal "", resolve("null and 1")
   end
 
   def test_arithmetic_ops
@@ -316,9 +343,40 @@ SASS
     assert_equal "false", resolve("3 <= 2")
   end
 
+  def test_null_ops
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "null plus 1".') {eval("null + 1")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "null minus 1".') {eval("null - 1")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "null times 1".') {eval("null * 1")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "null div 1".') {eval("null / 1")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "null mod 1".') {eval("null % 1")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "1 plus null".') {eval("1 + null")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "1 minus null".') {eval("1 - null")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "1 times null".') {eval("1 * null")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "1 div null".') {eval("1 / null")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "1 mod null".') {eval("1 % null")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "1 gt null".') {eval("1 > null")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "null lt 1".') {eval("null < 1")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: "null plus null".') {eval("null + null")}
+    assert_raise_message(Sass::SyntaxError,
+      'Invalid null operation: ""foo" plus null".') {eval("foo + null")}
+  end
+
   def test_equals
     assert_equal("true", resolve('"foo" == $foo', {},
-        env("foo" => Sass::Script::String.new("foo"))))
+        env("foo" => Sass::Script::Value::String.new("foo"))))
     assert_equal "true", resolve("1 == 1.0")
     assert_equal "true", resolve("false != true")
     assert_equal "false", resolve("1em == 1px")
@@ -331,6 +389,22 @@ SASS
     assert_equal "false", resolve('(1 (2 3)) == (1 2 3)')
     assert_equal "false", resolve('((1, 2) (3, 4)) == (1, 2 3, 4)')
     assert_equal "false", resolve('(1 2 3) == (1, 2, 3)')
+
+    assert_equal "true", resolve('null == null')
+    assert_equal "false", resolve('"null" == null')
+    assert_equal "false", resolve('0 == null')
+    assert_equal "false", resolve('() == null')
+
+    assert_equal "false", resolve('null != null')
+    assert_equal "true", resolve('"null" != null')
+    assert_equal "true", resolve('0 != null')
+    assert_equal "true", resolve('() != null')
+  end
+
+  def test_mod
+    assert_equal "5", resolve("29 % 12")
+    assert_equal "5px", resolve("29px % 12")
+    assert_equal "5px", resolve("29px % 12px")
   end
 
   def test_operation_precedence
@@ -349,6 +423,7 @@ SASS
 
   def test_operator_unit_conversion
     assert_equal "1.1cm", resolve("1cm + 1mm")
+    assert_equal "2in", resolve("1in + 96px")
     assert_equal "true", resolve("2mm < 1cm")
     assert_equal "true", resolve("10mm == 1cm")
     assert_equal "true", resolve("1 == 1cm")
@@ -414,8 +489,235 @@ SASS
     assert_raise_message(Sass::SyntaxError, "() isn't a valid CSS value.") {resolve("nth(append((), ()), 1)")}
   end
 
+  def test_list_with_nulls
+    assert_equal "1, 2, 3", resolve("1, 2, null, 3")
+    assert_equal "1 2 3", resolve("1 2 null 3")
+    assert_equal "1, 2, 3", resolve("1, 2, 3, null")
+    assert_equal "1 2 3", resolve("1 2 3 null")
+    assert_equal "1, 2, 3", resolve("null, 1, 2, 3")
+    assert_equal "1 2 3", resolve("null 1 2 3")
+  end
+
+  def test_map_can_have_trailing_comma
+    assert_equal("(foo: 1, bar: 2)", eval("(foo: 1, bar: 2,)").to_sass)
+  end
+
+  def test_list_can_have_trailing_comma
+    assert_equal("1, 2, 3", resolve("1, 2, 3,"))
+  end
+
+  def test_trailing_comma_defines_singleton_list
+    assert_equal("1 2 3", resolve("nth((1 2 3,), 1)"))
+  end
+
+  def test_map_cannot_have_duplicate_keys
+    assert_raise_message(Sass::SyntaxError, 'Duplicate key "foo" in map (foo: bar, foo: baz).') do
+      eval("(foo: bar, foo: baz)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Duplicate key "foo" in map (foo: bar, fo + o: baz).') do
+      eval("(foo: bar, fo + o: baz)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Duplicate key "foo" in map (foo: bar, "foo": baz).') do
+      eval("(foo: bar, 'foo': baz)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Duplicate key 2px in map (2px: bar, 1px + 1px: baz).') do
+      eval("(2px: bar, 1px + 1px: baz)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Duplicate key #0000ff in map (blue: bar, blue: baz).') do
+      eval("(blue: bar, #00f: baz)")
+    end
+  end
+
+  def test_non_duplicate_map_keys
+    # These shouldn't throw errors
+    eval("(foo: foo, bar: bar)")
+    eval("(2px: foo, 2: bar)")
+    eval("(2px: foo, 2em: bar)")
+    eval("('2px': foo, 2px: bar)")
+  end
+
+  def test_map_syntax_errors
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "(foo:": expected expression (e.g. 1px, bold), was ")"') do
+      eval("(foo:)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "(": expected ")", was ":bar)"') do
+      eval("(:bar)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "(foo, bar": expected ")", was ": baz)"') do
+      eval("(foo, bar: baz)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "(foo: bar, baz": expected ":", was ")"') do
+      eval("(foo: bar, baz)")
+    end
+  end
+
+  def test_deep_argument_error_not_unwrapped
+    # JRuby (as of 1.6.7.2) offers no way of distinguishing between
+    # argument errors caused by programming errors in a function and
+    # argument errors explicitly thrown within that function.
+    return if RUBY_PLATFORM =~ /java/
+
+    # Don't validate the message; it's different on Rubinius.
+    assert_raise(ArgumentError) {resolve("arg-error()")}
+  end
+
+  def test_shallow_argument_error_unwrapped
+    assert_raise_message(Sass::SyntaxError, "wrong number of arguments (1 for 0) for `arg-error'") {resolve("arg-error(1)")}
+  end
+
+  def test_boolean_ops_short_circuit
+    assert_equal "false", resolve("$ie and $ie <= 7", {}, env('ie' => Sass::Script::Value::Bool.new(false)))
+    assert_equal "true", resolve("$ie or $undef", {}, env('ie' => Sass::Script::Value::Bool.new(true)))
+  end
+
+  def test_setting_global_variable_locally_warns
+    assert_warning(<<WARNING) {assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))}
+DEPRECATION WARNING on line 4 of test_setting_global_variable_locally_warns_inline.scss:
+Assigning to global variable "$var" by default is deprecated.
+In future versions of Sass, this will create a new local variable.
+If you want to assign to the global variable, use "$var: x !global" instead.
+Note that this will be incompatible with Sass 3.2.
+WARNING
+.foo {
+  a: x; }
+
+.bar {
+  b: x; }
+CSS
+$var: 1;
+
+.foo {
+  $var: x;
+  a: $var;
+}
+
+.bar {
+  b: $var;
+}
+SCSS
+  end
+
+  def test_setting_global_variable_locally_warns_only_once
+    assert_warning(<<WARNING) {assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))}
+DEPRECATION WARNING on line 3 of test_setting_global_variable_locally_warns_only_once_inline.scss:
+Assigning to global variable "$var" by default is deprecated.
+In future versions of Sass, this will create a new local variable.
+If you want to assign to the global variable, use "$var: x !global" instead.
+Note that this will be incompatible with Sass 3.2.
+WARNING
+CSS
+$var: 1;
+
+@mixin foo {$var: x}
+@include foo;
+@include foo;
+@include foo;
+SCSS
+  end
+
+  def test_setting_global_variable_globally
+    assert_no_warning {assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))}
+.foo {
+  a: 1; }
+
+.bar {
+  b: 2; }
+CSS
+$var: 1;
+
+.foo {
+  a: $var;
+}
+
+$var: 2;
+
+.bar {
+  b: $var;
+}
+SCSS
+  end
+
+  def test_setting_global_variable_with_flag
+    assert_no_warning {assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))}
+.bar {
+  a: x;
+  b: y;
+  c: z; }
+CSS
+$var1: 1;
+$var3: 3;
+
+.foo {
+  $var1: x !global;
+  $var2: y !global;
+  @each $var3 in _ {
+    $var3: z !global;
+  }
+}
+
+.bar {
+  a: $var1;
+  b: $var2;
+  c: $var3;
+}
+SCSS
+  end
+
+  def test_setting_global_variable_with_flag_and_default
+    assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))
+.bar {
+  a: 1;
+  b: y;
+  c: z; }
+CSS
+$var1: 1;
+
+.foo {
+  $var1: x !global !default;
+  $var2: y !global !default;
+  @each $var3 in _ {
+    $var3: z !global !default;
+  }
+}
+
+.bar {
+  a: $var1;
+  b: $var2;
+  c: $var3;
+}
+SCSS
+  end
+
   # Regression Tests
 
+  def test_minus_without_whitespace
+    assert_equal "5px", resolve("15px-10px")
+  end
+
+  def test_user_defined_function_forces_division
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  b: 10px; }
+CSS
+@function foo()
+  @return 20px
+
+a
+  b: (foo() / 2)
+SASS
+
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  b: 10px; }
+CSS
+@function foo()
+  @return 20px
+
+a
+  b: foo() / 2
+SASS
+end
+
   def test_funcall_has_higher_precedence_than_color_name
     assert_equal "teal(12)", resolve("teal(12)")
     assert_equal "tealbang(12)", resolve("tealbang(12)")
@@ -423,6 +725,13 @@ SASS
     assert_equal "teal\\+bang(12)", resolve("teal\\+bang(12)")
   end
 
+  def test_funcall_has_higher_precedence_than_true_false_null
+    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
@@ -444,33 +753,68 @@ SASS
     assert_equal "and-bang", resolve("and-bang")
   end
 
+  def test_number_initialization
+    assert_equal Sass::Script::Value::Number.new(10, ["px"]), Sass::Script::Value::Number.new(10, "px")
+    assert_equal Sass::Script::Value::Number.new(10, ["px"], ["em"]), Sass::Script::Value::Number.new(10, "px", "em")
+  end
+
+  def test_is_unit
+    assert Sass::Script::Value::Number.new(10, "px").is_unit?("px")
+    assert Sass::Script::Value::Number.new(10).is_unit?(nil)
+    assert !Sass::Script::Value::Number.new(10, "px", "em").is_unit?("px")
+    assert !Sass::Script::Value::Number.new(10, [], "em").is_unit?("em")
+    assert !Sass::Script::Value::Number.new(10, ["px", "em"]).is_unit?("px")
+  end
+
+  def test_rename_redirect
+    assert_no_warning do
+      assert_equal Sass::Script::Value::Base, Sass::Script::Literal
+      assert_equal Sass::Script::Tree::Node, Sass::Script::Node
+      assert_equal Sass::Script::Tree::Operation, Sass::Script::Operation
+      assert_equal Sass::Script::Value::String, Sass::Script::String
+    end
+  end
+
+  def test_number_printing
+    assert_equal "1", resolve("1")
+    assert_equal "1", resolve("1.0")
+    assert_equal "1000000000", resolve("1000000000")
+    assert_equal "0.00001", resolve("0.00001")
+    assert_equal "1.12121", resolve("1.121214")
+    assert_equal "1.12122", resolve("1.121215")
+    assert_equal "Infinity", resolve("(1.0/0.0)")
+    assert_equal "-Infinity", resolve("(-1.0/0.0)")
+    assert_equal "NaN", resolve("(0.0/0.0)")
+  end
+
   private
 
   def resolve(str, opts = {}, environment = env)
     munge_filename opts
     val = eval(str, opts, environment)
-    val.is_a?(Sass::Script::String) ? val.value : val.to_s
+    assert_kind_of Sass::Script::Value::Base, val
+    val.is_a?(Sass::Script::Value::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_kind_of Sass::Script::Value::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_kind_of Sass::Script::Value::String, val
     assert_equal :string, val.type
   end
 
   def eval(str, opts = {}, environment = env)
     munge_filename opts
-    environment.options = opts
     Sass::Script.parse(str, opts.delete(:line) || 1,
-      opts.delete(:offset) || 0, opts).perform(environment)
+      opts.delete(:offset) || 0, opts).
+      perform(Sass::Environment.new(environment, opts))
   end
 
   def render(sass, options = {})
@@ -484,13 +828,13 @@ SASS
     env
   end
 
-  def test_number_printing
-    assert_equal "1", eval("1")
-    assert_equal "1", eval("1.0")
-    assert_equal "1.121", eval("1.1214")
-    assert_equal "1.122", eval("1.1215")
-    assert_equal "Infinity", eval("1.0/0.0")
-    assert_equal "-Infinity", eval("-1.0/0.0")
-    assert_equal "NaN", eval("0.0/0.0")
+  def selector(str)
+    parser = Sass::SCSS::StaticParser.new(
+      str, filename_for_test, Sass::Importers::Filesystem.new('.'))
+    parser.parse_selector
+  end
+
+  def test_null_is_a_singleton
+    assert_same Sass::Script::Value::Null.new, Sass::Script::Value::Null.new
   end
 end