oreorenasass 3.4.4 → 3.4.5

data/test/sass/functions_test.rb

@@ -1,49 +1,37 @@
 #!/usr/bin/env ruby
-require 'minitest/autorun'
+require 'test/unit'
 require File.dirname(__FILE__) + '/../test_helper'
-require File.dirname(__FILE__) + '/test_helper'
 require 'sass/script'
-require 'mock_importer'
 
 module Sass::Script::Functions
   def no_kw_args
-    Sass::Script::Value::String.new("no-kw-args")
+    Sass::Script::String.new("no-kw-args")
   end
 
   def only_var_args(*args)
-    Sass::Script::Value::String.new("only-var-args("+args.map{|a| a.plus(Sass::Script::Value::Number.new(1)).to_s }.join(", ")+")")
+    Sass::Script::String.new("only-var-args("+args.map{|a| a.plus(Sass::Script::Number.new(1)).to_s }.join(", ")+")")
   end
   declare :only_var_args, [], :var_args => true
 
   def only_kw_args(kwargs)
-    Sass::Script::Value::String.new("only-kw-args(" + kwargs.keys.map {|a| a.to_s}.sort.join(", ") + ")")
+    Sass::Script::String.new("only-kw-args(" + kwargs.keys.map {|a| a.to_s}.sort.join(", ") + ")")
   end
   declare :only_kw_args, [], :var_kwargs => true
-
-  def deprecated_arg_fn(arg1, arg2, arg3 = nil)
-    Sass::Script::Value::List.new([arg1, arg2, arg3 || Sass::Script::Value::Null.new], :space)
-  end
-  declare :deprecated_arg_fn, [:arg1, :arg2, :arg3], :deprecated => [:arg_1, :arg_2, :arg3]
-  declare :deprecated_arg_fn, [:arg1, :arg2], :deprecated => [:arg_1, :arg_2]
 end
 
 module Sass::Script::Functions::UserFunctions
-  def call_options_on_new_value
-    str = Sass::Script::Value::String.new("foo")
+  def call_options_on_new_literal
+    str = Sass::Script::String.new("foo")
     str.options[:foo]
     str
   end
 
   def user_defined
-    Sass::Script::Value::String.new("I'm a user-defined string!")
+    Sass::Script::String.new("I'm a user-defined string!")
   end
 
   def _preceding_underscore
-    Sass::Script::Value::String.new("I'm another user-defined string!")
-  end
-
-  def fetch_the_variable
-    environment.var('variable')
+    Sass::Script::String.new("I'm another user-defined string!")
   end
 end
 
@@ -51,7 +39,7 @@ module Sass::Script::Functions
   include Sass::Script::Functions::UserFunctions
 end
 
-class SassFunctionTest < MiniTest::Test
+class SassFunctionTest < Test::Unit::TestCase
   # Tests taken from:
   #   http://www.w3.org/Style/CSS/Test/CSS3/Color/20070927/html4/t040204-hsl-h-rotating-b.htm
   #   http://www.w3.org/Style/CSS/Test/CSS3/Color/20070927/html4/t040204-hsl-values-b.htm
@@ -90,9 +78,9 @@ class SassFunctionTest < MiniTest::Test
     assert_equal "#33cccc", evaluate("hsl($hue: 180, $saturation: 60%, $lightness: 50%)")
   end
 
-  def test_hsl_clamps_bounds
-    assert_equal("#1f1f1f", evaluate("hsl(10, -114, 12)"))
-    assert_equal("white", evaluate("hsl(10, 10, 256%)"))
+  def test_hsl_checks_bounds
+    assert_error_message("Saturation -114 must be between 0% and 100% for `hsl'", "hsl(10, -114, 12)");
+    assert_error_message("Lightness 256% must be between 0% and 100% for `hsl'", "hsl(10, 10, 256%)");
   end
 
   def test_hsl_checks_types
@@ -108,11 +96,11 @@ class SassFunctionTest < MiniTest::Test
     assert_equal "rgba(51, 204, 204, 0.4)", evaluate("hsla($hue: 180, $saturation: 60%, $lightness: 50%, $alpha: 0.4)")
   end
 
-  def test_hsla_clamps_bounds
-    assert_equal("#1f1f1f", evaluate("hsla(10, -114, 12, 1)"))
-    assert_equal("rgba(255, 255, 255, 0)", evaluate("hsla(10, 10, 256%, 0)"))
-    assert_equal("rgba(28, 24, 23, 0)", evaluate("hsla(10, 10, 10, -0.1)"))
-    assert_equal("#1c1817", evaluate("hsla(10, 10, 10, 1.1)"))
+  def test_hsla_checks_bounds
+    assert_error_message("Saturation -114 must be between 0% and 100% for `hsla'", "hsla(10, -114, 12, 1)");
+    assert_error_message("Lightness 256% must be between 0% and 100% for `hsla'", "hsla(10, 10, 256%, 0)");
+    assert_error_message("Alpha channel -0.1 must be between 0 and 1 for `hsla'", "hsla(10, 10, 10, -0.1)");
+    assert_error_message("Alpha channel 1.1 must be between 0 and 1 for `hsla'", "hsla(10, 10, 10, 1.1)");
   end
 
   def test_hsla_checks_types
@@ -126,43 +114,37 @@ class SassFunctionTest < MiniTest::Test
     assert_equal("50%",  evaluate("percentage(.5)"))
     assert_equal("100%", evaluate("percentage(1)"))
     assert_equal("25%",  evaluate("percentage(25px / 100px)"))
-    assert_equal("50%",  evaluate("percentage($number: 0.5)"))
+    assert_equal("50%",  evaluate("percentage($value: 0.5)"))
   end
 
   def test_percentage_checks_types
-    assert_error_message("$number: 25px is not a unitless number for `percentage'", "percentage(25px)")
-    assert_error_message("$number: #cccccc is not a unitless number for `percentage'", "percentage(#ccc)")
-    assert_error_message("$number: \"string\" is not a unitless number for `percentage'", %Q{percentage("string")})
+    assert_error_message("$value: 25px is not a unitless number for `percentage'", "percentage(25px)")
+    assert_error_message("$value: #cccccc is not a unitless number for `percentage'", "percentage(#ccc)")
+    assert_error_message("$value: \"string\" is not a unitless number for `percentage'", %Q{percentage("string")})
   end
 
   def test_round
     assert_equal("5",   evaluate("round(4.8)"))
     assert_equal("5px", evaluate("round(4.8px)"))
     assert_equal("5px", evaluate("round(5.49px)"))
-    assert_equal("5px", evaluate("round($number: 5.49px)"))
-  end
+    assert_equal("5px", evaluate("round($value: 5.49px)"))
 
-  def test_round_checks_types
     assert_error_message("$value: #cccccc is not a number for `round'", "round(#ccc)")
   end
 
   def test_floor
     assert_equal("4",   evaluate("floor(4.8)"))
     assert_equal("4px", evaluate("floor(4.8px)"))
-    assert_equal("4px", evaluate("floor($number: 4.8px)"))
-  end
+    assert_equal("4px", evaluate("floor($value: 4.8px)"))
 
-  def test_floor_checks_types
     assert_error_message("$value: \"foo\" is not a number for `floor'", "floor(\"foo\")")
   end
 
   def test_ceil
     assert_equal("5",   evaluate("ceil(4.1)"))
     assert_equal("5px", evaluate("ceil(4.8px)"))
-    assert_equal("5px", evaluate("ceil($number: 4.8px)"))
-  end
+    assert_equal("5px", evaluate("ceil($value: 4.8px)"))
 
-  def test_ceil_checks_types
     assert_error_message("$value: \"a\" is not a number for `ceil'", "ceil(\"a\")")
   end
 
@@ -171,15 +153,13 @@ class SassFunctionTest < MiniTest::Test
     assert_equal("5px", evaluate("abs(-5px)"))
     assert_equal("5",   evaluate("abs(5)"))
     assert_equal("5px", evaluate("abs(5px)"))
-    assert_equal("5px", evaluate("abs($number: 5px)"))
-  end
+    assert_equal("5px", evaluate("abs($value: 5px)"))
 
-  def test_abs_checks_types
     assert_error_message("$value: #aaaaaa is not a number for `abs'", "abs(#aaa)")
   end
 
   def test_min
-    assert_equal("1", evaluate("min(1, 2, 3)"))
+    #assert_equal("1", evaluate("min(1, 2, 3)"))
     assert_equal("1", evaluate("min(3px, 2px, 1)"))
     assert_equal("4em", evaluate("min(4em)"))
     assert_equal("10cm", evaluate("min(10cm, 6in)"))
@@ -212,18 +192,26 @@ class SassFunctionTest < MiniTest::Test
     assert_equal("springgreen", evaluate("rgb(0%, 100%, 50%)"))
   end
 
-  def test_rgb_clamps_bounds
-    assert_equal("#ff0101", evaluate("rgb(256, 1, 1)"))
-    assert_equal("#01ff01", evaluate("rgb(1, 256, 1)"))
-    assert_equal("#0101ff", evaluate("rgb(1, 1, 256)"))
-    assert_equal("#01ffff", evaluate("rgb(1, 256, 257)"))
-    assert_equal("#000101", evaluate("rgb(-1, 1, 1)"))
+  def test_rgb_tests_bounds
+    assert_error_message("$red: Color value 256 must be between 0 and 255 for `rgb'",
+      "rgb(256, 1, 1)")
+    assert_error_message("$green: Color value 256 must be between 0 and 255 for `rgb'",
+      "rgb(1, 256, 1)")
+    assert_error_message("$blue: Color value 256 must be between 0 and 255 for `rgb'",
+      "rgb(1, 1, 256)")
+    assert_error_message("$green: Color value 256 must be between 0 and 255 for `rgb'",
+      "rgb(1, 256, 257)")
+    assert_error_message("$red: Color value -1 must be between 0 and 255 for `rgb'",
+      "rgb(-1, 1, 1)")
   end
 
-  def test_rgb_clamps_percent_bounds
-    assert_equal("red", evaluate("rgb(100.1%, 0, 0)"))
-    assert_equal("black", evaluate("rgb(0, -0.1%, 0)"))
-    assert_equal("blue", evaluate("rgb(0, 0, 101%)"))
+  def test_rgb_test_percent_bounds
+    assert_error_message("$red: Color value 100.1% must be between 0% and 100% for `rgb'",
+      "rgb(100.1%, 0, 0)")
+    assert_error_message("$green: Color value -0.1% must be between 0% and 100% for `rgb'",
+      "rgb(0, -0.1%, 0)")
+    assert_error_message("$blue: Color value 101% must be between 0% and 100% for `rgb'",
+      "rgb(0, 0, 101%)")
   end
 
   def test_rgb_tests_types
@@ -239,14 +227,21 @@ class SassFunctionTest < MiniTest::Test
     assert_equal("rgba(0, 255, 127, 0)", evaluate("rgba($red: 0, $green: 255, $blue: 127, $alpha: 0)"))
   end
 
-  def test_rgba_clamps_bounds
-    assert_equal("rgba(255, 1, 1, 0.3)", evaluate("rgba(256, 1, 1, 0.3)"))
-    assert_equal("rgba(1, 255, 1, 0.3)", evaluate("rgba(1, 256, 1, 0.3)"))
-    assert_equal("rgba(1, 1, 255, 0.3)", evaluate("rgba(1, 1, 256, 0.3)"))
-    assert_equal("rgba(1, 255, 255, 0.3)", evaluate("rgba(1, 256, 257, 0.3)"))
-    assert_equal("rgba(0, 1, 1, 0.3)", evaluate("rgba(-1, 1, 1, 0.3)"))
-    assert_equal("rgba(1, 1, 1, 0)", evaluate("rgba(1, 1, 1, -0.2)"))
-    assert_equal("#010101", evaluate("rgba(1, 1, 1, 1.2)"))
+  def test_rgba_tests_bounds
+    assert_error_message("$red: Color value 256 must be between 0 and 255 for `rgba'",
+      "rgba(256, 1, 1, 0.3)")
+    assert_error_message("$green: Color value 256 must be between 0 and 255 for `rgba'",
+      "rgba(1, 256, 1, 0.3)")
+    assert_error_message("$blue: Color value 256 must be between 0 and 255 for `rgba'",
+      "rgba(1, 1, 256, 0.3)")
+    assert_error_message("$green: Color value 256 must be between 0 and 255 for `rgba'",
+      "rgba(1, 256, 257, 0.3)")
+    assert_error_message("$red: Color value -1 must be between 0 and 255 for `rgba'",
+      "rgba(-1, 1, 1, 0.3)")
+    assert_error_message("Alpha channel -0.2 must be between 0 and 1 for `rgba'",
+      "rgba(1, 1, 1, -0.2)")
+    assert_error_message("Alpha channel 1.2 must be between 0 and 1 for `rgba'",
+      "rgba(1, 1, 1, 1.2)")
   end
 
   def test_rgba_tests_types
@@ -380,8 +375,8 @@ class SassFunctionTest < MiniTest::Test
     assert_equal("rgba(0, 0, 0, 0.3)", evaluate("transparentize(rgba(0, 0, 0, 0.5), 0.2)"))
     assert_equal("rgba(0, 0, 0, 0.1)", evaluate("transparentize(rgba(0, 0, 0, 0.2), 0.1)"))
     assert_equal("rgba(0, 0, 0, 0.2)", evaluate("fade-out(rgba(0, 0, 0, 0.5), 0.3px)"))
-    assert_equal("transparent", evaluate("fade_out(rgba(0, 0, 0, 0.2), 0.2)"))
-    assert_equal("transparent", evaluate("transparentize(rgba(0, 0, 0, 0.2), 1)"))
+    assert_equal("rgba(0, 0, 0, 0)", evaluate("fade_out(rgba(0, 0, 0, 0.2), 0.2)"))
+    assert_equal("rgba(0, 0, 0, 0)", evaluate("transparentize(rgba(0, 0, 0, 0.2), 1)"))
     assert_equal("rgba(0, 0, 0, 0.2)", evaluate("transparentize(rgba(0, 0, 0, 0.2), 0)"))
     assert_equal("rgba(0, 0, 0, 0.2)", evaluate("transparentize($color: rgba(0, 0, 0, 0.2), $amount: 0)"))
     assert_equal("rgba(0, 0, 0, 0.2)", evaluate("fade-out($color: rgba(0, 0, 0, 0.2), $amount: 0)"))
@@ -696,9 +691,9 @@ class SassFunctionTest < MiniTest::Test
       "scale-color(blue, $alpha: -101%)")
 
     # Unit
-    assert_error_message("Expected $saturation to have a unit of % but got 80 for `scale-color'",
+    assert_error_message("$saturation: Amount 80 must be a % (e.g. 80%) for `scale-color'",
       "scale-color(blue, $saturation: 80)")
-    assert_error_message("Expected $alpha to have a unit of % but got 0.5 for `scale-color'",
+    assert_error_message("$alpha: Amount 0.5 must be a % (e.g. 0.5%) for `scale-color'",
       "scale-color(blue, $alpha: 0.5)")
 
     # Unknown argument
@@ -798,12 +793,12 @@ class SassFunctionTest < MiniTest::Test
     assert_equal("blue", evaluate("mix(transparentize(#f00, 1), #00f, 0%)"))
     assert_equal("rgba(0, 0, 255, 0)", evaluate("mix(#f00, transparentize(#00f, 1), 0%)"))
     assert_equal("rgba(255, 0, 0, 0)", evaluate("mix(transparentize(#f00, 1), #00f, 100%)"))
-    assert_equal("rgba(255, 0, 0, 0)", evaluate("mix($color1: transparentize(#f00, 1), $color2: #00f, $weight: 100%)"))
+    assert_equal("rgba(255, 0, 0, 0)", evaluate("mix($color-1: transparentize(#f00, 1), $color-2: #00f, $weight: 100%)"))
   end
 
   def test_mix_tests_types
-    assert_error_message("$color1: \"foo\" is not a color for `mix'", "mix(\"foo\", #f00, 10%)")
-    assert_error_message("$color2: \"foo\" is not a color for `mix'", "mix(#f00, \"foo\", 10%)")
+    assert_error_message("$color-1: \"foo\" is not a color for `mix'", "mix(\"foo\", #f00, 10%)")
+    assert_error_message("$color-2: \"foo\" is not a color for `mix'", "mix(#f00, \"foo\", 10%)")
     assert_error_message("$weight: \"foo\" is not a number for `mix'", "mix(#f00, #baf, \"foo\")")
   end
 
@@ -869,83 +864,6 @@ class SassFunctionTest < MiniTest::Test
     assert_error_message("$string: #ff0000 is not a string for `quote'", "quote(#f00)")
   end
 
-  def test_str_length
-    assert_equal('3', evaluate('str-length(foo)'))
-  end
-
-  def test_str_length_requires_a_string
-    assert_error_message("$string: #ff0000 is not a string for `str-length'", "str-length(#f00)")
-  end
-
-  def test_str_insert
-    assert_equal('Xabcd', evaluate('str-insert(abcd, X, 0)'))
-    assert_equal('Xabcd', evaluate('str-insert(abcd, X, 1)'))
-    assert_equal('abcXd', evaluate('str-insert(abcd, X, 4)'))
-    assert_equal('abcdX', evaluate('str-insert(abcd, X, 100)'))
-    assert_equal('Xabcd', evaluate('str-insert(abcd, X, -100)'))
-    assert_equal('aXbcd', evaluate('str-insert(abcd, X, -4)'))
-    assert_equal('abcdX', evaluate('str-insert(abcd, X, -1)'))
-  end
-
-  def test_str_insert_maintains_quote_of_primary_string
-    assert_equal('"Xfoo"', evaluate('str-insert("foo", X, 1)'))
-    assert_equal('"Xfoo"', evaluate('str-insert("foo", "X", 1)'))
-    assert_equal('Xfoo', evaluate('str-insert(foo, "X", 1)'))
-  end
-
-  def test_str_insert_asserts_types
-    assert_error_message("$string: #ff0000 is not a string for `str-insert'", "str-insert(#f00, X, 1)")
-    assert_error_message("$insert: #ff0000 is not a string for `str-insert'", "str-insert(foo, #f00, 1)")
-    assert_error_message("$index: #ff0000 is not a number for `str-insert'", "str-insert(foo, X, #f00)")
-    assert_error_message("Expected $index to be unitless but got 10px for `str-insert'", "str-insert(foo, X, 10px)")
-  end
-
-  def test_str_index
-    assert_equal('1', evaluate('str-index(abcd, a)'))
-    assert_equal('1', evaluate('str-index(abcd, ab)'))
-    assert_equal(Sass::Script::Value::Null.new, perform('str-index(abcd, X)'))
-    assert_equal('3', evaluate('str-index(abcd, c)'))
-  end
-
-  def test_str_index_asserts_types
-    assert_error_message("$string: #ff0000 is not a string for `str-index'", "str-index(#f00, X)")
-    assert_error_message("$substring: #ff0000 is not a string for `str-index'", "str-index(asdf, #f00)")
-  end
-
-  def test_to_lower_case
-    assert_equal('abcd', evaluate('to-lower-case(ABCD)'))
-    assert_equal('"abcd"', evaluate('to-lower-case("ABCD")'))
-    assert_error_message("$string: #ff0000 is not a string for `to-lower-case'", "to-lower-case(#f00)")
-  end
-
-  def test_to_upper_case
-    assert_equal('ABCD', evaluate('to-upper-case(abcd)'))
-    assert_equal('"ABCD"', evaluate('to-upper-case("abcd")'))
-    assert_error_message("$string: #ff0000 is not a string for `to-upper-case'", "to-upper-case(#f00)")
-  end
-
-  def test_str_slice
-    assert_equal('bc',   evaluate('str-slice(abcd,2,3)'))    # in the middle of the string
-    assert_equal('a',    evaluate('str-slice(abcd,1,1)'))    # when start = end
-    assert_equal('ab',   evaluate('str-slice(abcd,1,2)'))    # for completeness
-    assert_equal('abcd', evaluate('str-slice(abcd,1,4)'))    # at the end points
-    assert_equal('abcd', evaluate('str-slice(abcd,0,4)'))    # when start is before the start of the string
-    assert_equal('',     evaluate('str-slice(abcd,1,0)'))    # when end is before the start of the string
-    assert_equal('abcd', evaluate('str-slice(abcd,1,100)'))  # when end is past the end of the string
-    assert_equal('',     evaluate('str-slice(abcd,2,1)'))    # when end is before start
-    assert_equal('"bc"', evaluate('str-slice("abcd",2,3)'))  # when used with a quoted string
-    assert_equal('bcd',  evaluate('str-slice(abcd,2)'))      # when end is omitted, you get the remainder of the string
-    assert_equal('cd',   evaluate('str-slice(abcd,-2)'))     # when start is negative, it counts from the beginning
-    assert_equal('bc',   evaluate('str-slice(abcd,2,-2)'))   # when end is negative it counts in from the end
-    assert_equal('',     evaluate('str-slice(abcd,3,-3)'))   # when end is negative and comes before the start
-    assert_equal('bc',   evaluate('str-slice(abcd,-3,-2)'))  # when both are negative
-    assert_error_message("$string: #ff0000 is not a string for `str-slice'", "str-slice(#f00,2,3)")
-    assert_error_message("$start-at: #ff0000 is not a number for `str-slice'", "str-slice(abcd,#f00,3)")
-    assert_error_message("$end-at: #ff0000 is not a number for `str-slice'", "str-slice(abcd,2,#f00)")
-    assert_error_message("Expected $end-at to be unitless but got 3px for `str-slice'", "str-slice(abcd,2,3px)")
-    assert_error_message("Expected $start-at to be unitless but got 2px for `str-slice'", "str-slice(abcd,2px,3)")
-  end
-
   def test_user_defined_function
     assert_equal("I'm a user-defined string!", evaluate("user_defined()"))
   end
@@ -955,17 +873,12 @@ class SassFunctionTest < MiniTest::Test
     assert_equal("I'm another user-defined string!", evaluate("-preceding-underscore()"))
   end
 
-  def test_user_defined_function_using_environment
-    environment = env('variable' => Sass::Script::Value::String.new('The variable'))
-    assert_equal("The variable", evaluate("fetch_the_variable()", environment))
-  end
-
-  def test_options_on_new_values_fails
-    assert_error_message(<<MSG, "call-options-on-new-value()")
-The #options attribute is not set on this Sass::Script::Value::String.
+  def test_options_on_new_literals_fails
+    assert_error_message(<<MSG, "call-options-on-new-literal()")
+The #options attribute is not set on this Sass::Script::String.
   This error is probably occurring because #to_s was called
-  on this value within a custom Sass function without first
-  setting the #options attribute.
+  on this literal within a custom Sass function without first
+  setting the #option attribute.
 MSG
   end
 
@@ -977,22 +890,6 @@ MSG
     assert_equal("color", evaluate("type-of(#fff)"))
     assert_equal("color", evaluate("type-of($value: #fff)"))
     assert_equal("null", evaluate("type-of(null)"))
-    assert_equal("list", evaluate("type-of(1 2 3)"))
-    assert_equal("list", evaluate("type-of((1, 2, 3))"))
-    assert_equal("list", evaluate("type-of(())"))
-    assert_equal("map", evaluate("type-of((foo: bar))"))
-  end
-
-  def test_feature_exists
-    assert_raises ArgumentError do
-      Sass.add_feature("my-test-feature")
-    end
-    Sass.add_feature("-my-test-feature")
-    assert_equal("true", evaluate("feature-exists(-my-test-feature)"))
-    assert_equal("false", evaluate("feature-exists(whatisthisidontevenknow)"))
-    assert_equal("true", evaluate("feature-exists($feature: -my-test-feature)"))
-  ensure
-    Sass::Features::KNOWN_FEATURES.delete("-my-test-feature")
   end
 
   def test_unit
@@ -1017,12 +914,9 @@ MSG
     assert_equal(%Q{true}, evaluate("comparable(2px, 1px)"))
     assert_equal(%Q{true}, evaluate("comparable(10cm, 3mm)"))
     assert_equal(%Q{false}, evaluate("comparable(100px, 3em)"))
-    assert_equal(%Q{false}, evaluate("comparable($number1: 100px, $number2: 3em)"))
-  end
-
-  def test_comparable_checks_types
-    assert_error_message("$number1: #ff0000 is not a number for `comparable'", "comparable(#f00, 1px)")
-    assert_error_message("$number2: #ff0000 is not a number for `comparable'", "comparable(1px, #f00)")
+    assert_equal(%Q{false}, evaluate("comparable($number-1: 100px, $number-2: 3em)"))
+    assert_error_message("$number-1: #ff0000 is not a number for `comparable'", "comparable(#f00, 1px)")
+    assert_error_message("$number-2: #ff0000 is not a number for `comparable'", "comparable(1px, #f00)")
   end
 
   def test_length
@@ -1033,47 +927,21 @@ MSG
     assert_equal("1", evaluate("length(#f00)"))
     assert_equal("0", evaluate("length(())"))
     assert_equal("4", evaluate("length(1 2 () 3)"))
-
-    assert_equal("2", evaluate("length((foo: bar, bar: baz))"))
   end
 
   def test_nth
     assert_equal("1", evaluate("nth(1 2 3, 1)"))
     assert_equal("2", evaluate("nth(1 2 3, 2)"))
-    assert_equal("3", evaluate("nth(1 2 3, -1)"))
-    assert_equal("1", evaluate("nth(1 2 3, -3)"))
     assert_equal("3", evaluate("nth((1, 2, 3), 3)"))
-    assert_equal("3", evaluate("nth($list: (1, 2, 3), $n: 3)"))
     assert_equal("foo", evaluate("nth(foo, 1)"))
     assert_equal("bar baz", evaluate("nth(foo (bar baz) bang, 2)"))
-    assert_error_message("List index 0 must be a non-zero integer for `nth'", "nth(foo, 0)")
-    assert_error_message("List index is -10 but list is only 1 item long for `nth'", "nth(foo, -10)")
-    assert_error_message("List index 1.5 must be a non-zero integer for `nth'", "nth(foo, 1.5)")
+    assert_error_message("List index 0 must be greater than or equal to 1 for `nth'", "nth(foo, 0)")
+    assert_error_message("List index -10 must be greater than or equal to 1 for `nth'", "nth(foo, -10)")
+    assert_error_message("List index 1.5 must be an integer for `nth'", "nth(foo, 1.5)")
     assert_error_message("List index is 5 but list is only 4 items long for `nth'", "nth(1 2 3 4, 5)")
     assert_error_message("List index is 2 but list is only 1 item long for `nth'", "nth(foo, 2)")
     assert_error_message("List index is 1 but list has no items for `nth'", "nth((), 1)")
     assert_error_message("$n: \"foo\" is not a number for `nth'", "nth(1 2 3, foo)")
-
-    assert_equal("foo bar", evaluate("nth((foo: bar, bar: baz), 1)"))
-    assert_equal("bar baz", evaluate("nth((foo: bar, bar: baz), 2)"))
-  end
-
-  def test_set_nth
-    assert_equal("a 2 3", evaluate("set-nth(1 2 3, 1, a)"))
-    assert_equal("1 a 3", evaluate("set-nth(1 2 3, 2, a)"))
-    assert_equal("1 2 a", evaluate("set-nth(1 2 3, -1, a)"))
-    assert_equal("a 2 3", evaluate("set-nth(1 2 3, -3, a)"))
-    assert_equal("a 2 3", evaluate("set-nth($list: 1 2 3, $n: -3, $value: a)"))
-    assert_equal("1, 2, a", evaluate("set-nth((1, 2, 3), 3, a)"))
-    assert_equal("a", evaluate("set-nth(foo, 1, a)"))
-    assert_equal("foo, a b, baz", evaluate("set-nth((foo, bar, baz), 2, (a b))"))
-    assert_error_message("List index 0 must be a non-zero integer for `set-nth'", "set-nth(foo, 0, a)")
-    assert_error_message("List index is -10 but list is only 1 item long for `set-nth'", "set-nth(foo, -10, a)")
-    assert_error_message("List index 1.5 must be a non-zero integer for `set-nth'", "set-nth(foo, 1.5, a)")
-    assert_error_message("List index is 5 but list is only 4 items long for `set-nth'", "set-nth(1 2 3 4, 5, a)")
-    assert_error_message("List index is 2 but list is only 1 item long for `set-nth'", "set-nth(foo, 2, a)")
-    assert_error_message("List index is 1 but list has no items for `set-nth'", "set-nth((), 1, a)")
-    assert_error_message("$n: \"foo\" is not a number for `set-nth'", "set-nth(1 2 3, foo, a)")
   end
 
   def test_join
@@ -1113,19 +981,6 @@ MSG
 
     assert_error_message("Separator name must be space, comma, or auto for `join'", "join(1, 2, baboon)")
     assert_error_message("$separator: 12 is not a string for `join'", "join(1, 2, 12)")
-
-    assert_equal("foo bar, bar baz, baz bip, bip bop",
-      perform("join((foo: bar, bar: baz), (baz: bip, bip: bop))").to_sass)
-    assert_equal("(foo bar) (bar baz) (baz bip) (bip bop)",
-      perform("join((foo: bar, bar: baz), (baz: bip, bip: bop), space)").to_sass)
-    assert_equal("foo bar (baz bip) (bip bop)",
-      perform("join(foo bar, (baz: bip, bip: bop))").to_sass)
-    assert_equal("foo bar, bar baz, bip, bop",
-      perform("join((foo: bar, bar: baz), bip bop)").to_sass)
-    assert_equal("baz bip, bip bop",
-      perform("join((), (baz: bip, bip: bop))").to_sass)
-    assert_equal("foo bar, bar baz",
-      perform("join((foo: bar, bar: baz), ())").to_sass)
   end
 
   def test_append
@@ -1161,73 +1016,28 @@ MSG
 
     assert_error_message("Separator name must be space, comma, or auto for `append'", "append(1, 2, baboon)")
     assert_error_message("$separator: 12 is not a string for `append'", "append(1, 2, 12)")
-
-    assert_equal("1 2 (foo: bar)", perform("append(1 2, (foo: bar))").to_sass)
-    assert_equal("foo bar, bar baz, 1", perform("append((foo: bar, bar: baz), 1)").to_sass)
-    assert_equal("foo bar, bar baz, (baz: bip)",
-      perform("append((foo: bar, bar: baz), (baz: bip))").to_sass)
   end
 
   def test_zip
     assert_equal("1 3 5, 2 4 6", evaluate("zip(1 2, 3 4, 5 6)"))
     assert_equal("1 4 7, 2 5 8", evaluate("zip(1 2 3, 4 5 6, 7 8)"))
     assert_equal("1 2 3", evaluate("zip(1, 2, 3)"))
-    assert_equal("(foo bar) 1 3, (bar baz) 2 4",
-      perform("zip((foo: bar, bar: baz), 1 2, 3 4)").to_sass)
   end
 
   def test_index
-    null = Sass::Script::Value::Null.new
     assert_equal("1", evaluate("index(1px solid blue, 1px)"))
     assert_equal("2", evaluate("index(1px solid blue, solid)"))
     assert_equal("3", evaluate("index(1px solid blue, #00f)"))
     assert_equal("1", evaluate("index(1px, 1px)"))
-    assert_equal(null, perform("index(1px solid blue, 1em)"))
-    assert_equal(null, perform("index(1px solid blue, notfound)"))
-    assert_equal(null, perform("index(1px, #00f)"))
-
-    assert_equal("1", evaluate("index((foo: bar, bar: baz), (foo bar))"))
-    assert_equal(null, perform("index((foo: bar, bar: baz), (foo: bar))"))
-  end
-
-  def test_list_separator
-    assert_equal("space", evaluate("list-separator(1 2 3 4 5)"))
-    assert_equal("comma", evaluate("list-separator((foo, bar, baz, bip))"))
-    assert_equal("comma", evaluate("list-separator((foo, bar, baz bip))"))
-    assert_equal("comma", evaluate("list-separator((foo, bar, (baz, bip)))"))
-    assert_equal("space", evaluate("list-separator(#f00)"))
-    assert_equal("space", evaluate("list-separator(())"))
-    assert_equal("space", evaluate("list-separator(1 2 () 3)"))
-
-    assert_equal("comma", evaluate("list-separator((foo: bar, bar: baz))"))
+    assert_equal("false", evaluate("index(1px solid blue, 1em)"))
+    assert_equal("false", evaluate("index(1px solid blue, notfound)"))
+    assert_equal("false", evaluate("index(1px, #00f)"))
   end
 
   def test_if
     assert_equal("1px", evaluate("if(true, 1px, 2px)"))
     assert_equal("2px", evaluate("if(false, 1px, 2px)"))
     assert_equal("2px", evaluate("if(null, 1px, 2px)"))
-    assert_equal("1px", evaluate("if(true, 1px, $broken)"))
-    assert_equal("1px", evaluate("if(false, $broken, 1px)"))
-    assert_equal("1px", evaluate("if(false, $if-true: $broken, $if-false: 1px)"))
-    assert_equal("1px", evaluate("if(true, $if-true: 1px, $if-false: $broken)"))
-    assert_equal(<<CSS, render(<<SCSS))
-.if {
-  result: yay; }
-CSS
-.if {
-  $something: yay;
-  result: if(true, $if-true: $something, $if-false: $broken);
-}
-SCSS
-    assert_equal(<<CSS, render(<<SCSS))
-.if {
-  result: 1px; }
-CSS
-.if {
-  $splat: 1px, 2px;
-  result: if(true, $splat...);
-}
-SCSS
   end
 
   def test_counter
@@ -1301,620 +1111,22 @@ SCSS
     assert_equal "only-kw-args(a, b, c)", evaluate("only-kw-args($a: 1, $b: 2, $c: 3)")
   end
 
-  def test_unique_id
-    last_id, current_id = nil, evaluate("unique-id()")
-
-    50.times do
-      last_id, current_id = current_id, evaluate("unique-id()")
-      assert_match(/u[a-z0-9]{8}/, current_id)
-      refute_equal last_id, current_id
-    end
-  end
-
-  def test_map_get
-    assert_equal "1", evaluate("map-get((foo: 1, bar: 2), foo)")
-    assert_equal "2", evaluate("map-get((foo: 1, bar: 2), bar)")
-    assert_equal "null", perform("map-get((foo: 1, bar: 2), baz)").to_sass
-    assert_equal "null", perform("map-get((), foo)").to_sass
-  end
-
-  def test_map_get_checks_type
-    assert_error_message("$map: 12 is not a map for `map-get'", "map-get(12, bar)")
-  end
-
-  def test_map_merge
-    assert_equal("(foo: 1, bar: 2, baz: 3)",
-      perform("map-merge((foo: 1, bar: 2), (baz: 3))").to_sass)
-    assert_equal("(foo: 1, bar: 2)",
-      perform("map-merge((), (foo: 1, bar: 2))").to_sass)
-    assert_equal("(foo: 1, bar: 2)",
-      perform("map-merge((foo: 1, bar: 2), ())").to_sass)
-  end
-
-  def test_map_merge_checks_type
-    assert_error_message("$map1: 12 is not a map for `map-merge'", "map-merge(12, (foo: 1))")
-    assert_error_message("$map2: 12 is not a map for `map-merge'", "map-merge((foo: 1), 12)")
-  end
-
-  def test_map_remove
-    assert_equal("(foo: 1, baz: 3)",
-      perform("map-remove((foo: 1, bar: 2, baz: 3), bar)").to_sass)
-    assert_equal("(foo: 1, baz: 3)",
-      perform("map-remove($map: (foo: 1, bar: 2, baz: 3), $key: bar)").to_sass)
-    assert_equal("()",
-      perform("map-remove((foo: 1, bar: 2, baz: 3), foo, bar, baz)").to_sass)
-    assert_equal("()", perform("map-remove((), foo)").to_sass)
-    assert_equal("()", perform("map-remove((), foo, bar)").to_sass)
-  end
-
-  def test_map_remove_checks_type
-    assert_error_message("$map: 12 is not a map for `map-remove'", "map-remove(12, foo)")
-  end
-
-  def test_map_keys
-    assert_equal("foo, bar",
-      perform("map-keys((foo: 1, bar: 2))").to_sass)
-    assert_equal("()", perform("map-keys(())").to_sass)
-  end
-
-  def test_map_keys_checks_type
-    assert_error_message("$map: 12 is not a map for `map-keys'", "map-keys(12)")
-  end
-
-  def test_map_values
-    assert_equal("1, 2", perform("map-values((foo: 1, bar: 2))").to_sass)
-    assert_equal("1, 2, 2",
-      perform("map-values((foo: 1, bar: 2, baz: 2))").to_sass)
-    assert_equal("()", perform("map-values(())").to_sass)
-  end
-
-  def test_map_values_checks_type
-    assert_error_message("$map: 12 is not a map for `map-values'", "map-values(12)")
-  end
-
-  def test_map_has_key
-    assert_equal "true", evaluate("map-has-key((foo: 1, bar: 1), foo)")
-    assert_equal "false", evaluate("map-has-key((foo: 1, bar: 1), baz)")
-    assert_equal "false", evaluate("map-has-key((), foo)")
-  end
-
-  def test_map_has_key_checks_type
-    assert_error_message("$map: 12 is not a map for `map-has-key'", "map-has-key(12, foo)")
-  end
-
-  def test_keywords
-    # The actual functionality is tested in tests where real arglists are passed.
-    assert_error_message("$args: 12 is not a variable argument list for `keywords'", "keywords(12)")
-    assert_error_message(
-      "$args: (1 2 3) is not a variable argument list for `keywords'", "keywords(1 2 3)")
-  end
-
-  def test_partial_list_of_pairs_doesnt_work_as_a_map
-    assert_raises(Sass::SyntaxError) {evaluate("map-get((foo bar, baz bang, bip), 1)")}
-    assert_raises(Sass::SyntaxError) {evaluate("map-get((foo bar, baz bang, bip bap bop), 1)")}
-    assert_raises(Sass::SyntaxError) {evaluate("map-get((foo bar), 1)")}
-  end
-
-  def test_assert_unit
-    ctx = Sass::Script::Functions::EvaluationContext.new(Sass::Environment.new(nil, {}))
-    ctx.assert_unit Sass::Script::Value::Number.new(10, ["px"], []), "px"
-    ctx.assert_unit Sass::Script::Value::Number.new(10, [], []), nil
-
-    begin
-      ctx.assert_unit Sass::Script::Value::Number.new(10, [], []), "px"
-      fail
-    rescue ArgumentError => e
-      assert_equal "Expected 10 to have a unit of px", e.message
-    end
-
-    begin
-      ctx.assert_unit Sass::Script::Value::Number.new(10, ["px"], []), nil
-      fail
-    rescue ArgumentError => e
-      assert_equal "Expected 10px to be unitless", e.message
-    end
-
-    begin
-      ctx.assert_unit Sass::Script::Value::Number.new(10, [], []), "px", "arg"
-      fail
-    rescue ArgumentError => e
-      assert_equal "Expected $arg to have a unit of px but got 10", e.message
-    end
-
-    begin
-      ctx.assert_unit Sass::Script::Value::Number.new(10, ["px"], []), nil, "arg"
-      fail
-    rescue ArgumentError => e
-      assert_equal "Expected $arg to be unitless but got 10px", e.message
-    end
-  end
-
-  def test_call_with_positional_arguments
-    assert_equal evaluate("lighten(blue, 5%)"), evaluate("call(lighten, blue, 5%)")
-  end
-
-  def test_call_with_keyword_arguments
-    assert_equal(
-      evaluate("lighten($color: blue, $amount: 5%)"),
-      evaluate("call(lighten, $color: blue, $amount: 5%)"))
-  end
-
-  def test_call_with_keyword_and_positional_arguments
-    assert_equal(
-      evaluate("lighten(blue, $amount: 5%)"),
-      evaluate("call(lighten, blue, $amount: 5%)"))
-  end
-
-  def test_call_with_dynamic_name
-    assert_equal(
-      evaluate("lighten($color: blue, $amount: 5%)"),
-      evaluate("call($fn, $color: blue, $amount: 5%)",
-        env("fn" => Sass::Script::String.new("lighten"))))
-  end
-
-  def test_call_uses_local_scope
-    assert_equal <<CSS, render(<<SCSS)
-.first-scope {
-  a: local; }
-
-.second-scope {
-  a: global; }
-CSS
-@function foo() {@return global}
-
-.first-scope {
-  @function foo() {@return local}
-  a: call(foo);
-}
-
-.second-scope {
-  a: call(foo);
-}
-SCSS
-  end
-
-  def test_call_unknown_function
-    assert_equal evaluate("unknown(red, blue)"), evaluate("call(unknown, red, blue)")
-  end
-
-  def test_call_with_non_string_argument
-    assert_error_message "$name: 3px is not a string for `call'", "call(3px)"
-  end
-
-  def test_errors_in_called_function
-    assert_error_message "$color: 3px is not a color for `lighten'", "call(lighten, 3px, 5%)"
-  end
-
-  def test_variable_exists
-    assert_equal <<CSS, render(<<SCSS)
-.test {
-  false: false;
-  true: true;
-  true: true;
-  true: true;
-  true: true; }
-CSS
-$global-var: has-value;
-.test {
-  false: variable-exists(foo);
-  $foo: has-value;
-  true: variable-exists(foo);
-  true: variable-exists($name: foo);
-  true: variable-exists(global-var);
-  true: variable-exists($name: global-var);
-}
-SCSS
-  end
-
-  def test_variable_exists_checks_type
-    assert_error_message("$name: 1 is not a string for `variable-exists'", "variable-exists(1)")
-  end
-
-  def test_global_variable_exists
-    assert_equal <<CSS, render(<<SCSS)
-.test {
-  false: false;
-  false: false;
-  true: true;
-  true: true;
-  false: false;
-  true: true;
-  true: true; }
-CSS
-$g: something;
-$h: null;
-$false: global-variable-exists(foo);
-$true: global-variable-exists(g);
-$named: global-variable-exists($name: g);
-.test {
-  $foo: locally-defined;
-  false: global-variable-exists(foo);
-  false: global-variable-exists(foo2);
-  true: global-variable-exists(g);
-  true: global-variable-exists(h);
-  false: $false;
-  true: $true;
-  true: $named;
-}
-SCSS
-  end
-
-  def test_global_variable_exists_checks_type
-    assert_error_message("$name: 1 is not a string for `global-variable-exists'",
-      "global-variable-exists(1)")
-  end
-
-  def test_function_exists
-    # built-ins
-    assert_equal "true", evaluate("function-exists(lighten)")
-    # with named argument
-    assert_equal "true", evaluate("function-exists($name: lighten)")
-    # user-defined
-    assert_equal <<CSS, render(<<SCSS)
-.test {
-  foo-exists: true;
-  bar-exists: false; }
-CSS
-@function foo() { @return "foo" }
-.test {
-  foo-exists: function-exists(foo);
-  bar-exists: function-exists(bar);
-}
-SCSS
-  end
-
-  def test_function_exists_checks_type
-    assert_error_message("$name: 1 is not a string for `function-exists'", "function-exists(1)")
-  end
-
-  def test_mixin_exists
-    assert_equal "false", evaluate("mixin-exists(foo)")
-    # with named argument
-    assert_equal "false", evaluate("mixin-exists($name: foo)")
-    assert_equal <<CSS, render(<<SCSS)
-.test {
-  foo-exists: true;
-  bar-exists: false; }
-CSS
-@mixin foo() { foo: exists }
-.test {
-  foo-exists: mixin-exists(foo);
-  bar-exists: mixin-exists(bar);
-}
-SCSS
-  end
-
-  def test_mixin_exists_checks_type
-    assert_error_message("$name: 1 is not a string for `mixin-exists'", "mixin-exists(1)")
-  end
-
-  def test_inspect
-    assert_equal "()", evaluate("inspect(())")
-    assert_equal "null", evaluate("inspect(null)")
-    assert_equal "1px null 3px", evaluate("inspect(1px null 3px)")
-    assert_equal "(a: 1, b: 2)", evaluate("inspect((a: 1, b: 2))")
-  end
-
-  def test_random
-    Sass::Script::Functions.random_seed = 1
-    assert_equal "0.41702", evaluate("random()")
-    assert_equal "13", evaluate("random(100)")
-  end
-
-  def test_random_works_without_a_seed
-    if Sass::Script::Functions.instance_variable_defined?("@random_number_generator")
-      Sass::Script::Functions.send(:remove_instance_variable, "@random_number_generator")
-    end
-
-    result = perform("random()")
-    assert_kind_of Sass::Script::Number, result
-    assert result.value >= 0, "Random number was below 0"
-    assert result.value <= 1, "Random number was above 1"
-  end
-
-  def test_random_with_limit_one
-    # Passing 1 as the limit should always return 1, since limit calls return
-    # integers from 1 to the argument, so when the argument is 1, its a predicatble
-    # outcome
-    assert "1", evaluate("random(1)")
-  end
-
-  def test_random_with_limit_too_low
-    assert_error_message("$limit 0 must be greater than or equal to 1 for `random'", "random(0)")
-  end
-
-  def test_random_with_non_integer_limit
-    assert_error_message("Expected $limit to be an integer but got 1.5 for `random'", "random(1.5)")
-  end
-
-  # This could *possibly* fail, but exceedingly unlikely
-  def test_random_is_semi_unique
-    if Sass::Script::Functions.instance_variable_defined?("@random_number_generator")
-      Sass::Script::Functions.send(:remove_instance_variable, "@random_number_generator")
-    end
-    refute_equal evaluate("random()"), evaluate("random()")
-  end
-
-  def test_deprecated_arg_names
-    assert_warning <<WARNING do
-DEPRECATION WARNING: The `$arg-1' argument for `deprecated-arg-fn()' has been renamed to `$arg1'.
-DEPRECATION WARNING: The `$arg-2' argument for `deprecated-arg-fn()' has been renamed to `$arg2'.
-WARNING
-      assert_equal("1 2 3",
-        evaluate("deprecated-arg-fn($arg-1: 1, $arg-2: 2, $arg3: 3)"))
-    end
-
-    assert_warning <<WARNING do
-DEPRECATION WARNING: The `$arg-1' argument for `deprecated-arg-fn()' has been renamed to `$arg1'.
-DEPRECATION WARNING: The `$arg-2' argument for `deprecated-arg-fn()' has been renamed to `$arg2'.
-WARNING
-      assert_equal("1 2",
-        evaluate("deprecated-arg-fn($arg-1: 1, $arg-2: 2)"))
-    end
-
-    assert_warning <<WARNING do
-DEPRECATION WARNING: The `$arg_1' argument for `deprecated-arg-fn()' has been renamed to `$arg1'.
-DEPRECATION WARNING: The `$arg_2' argument for `deprecated-arg-fn()' has been renamed to `$arg2'.
-WARNING
-      assert_equal("1 2",
-        evaluate("deprecated-arg-fn($arg_1: 1, $arg_2: 2)"))
-    end
-  end
-
-  def test_non_deprecated_arg_names
-    assert_equal("1 2 3", evaluate("deprecated-arg-fn($arg1: 1, $arg2: 2, $arg3: 3)"))
-    assert_equal("1 2", evaluate("deprecated-arg-fn($arg1: 1, $arg2: 2)"))
-  end
-
-  ## Selector Functions
-
-  def test_selector_argument_parsing
-    assert_equal("true", evaluate("selector-parse('.foo') == (join(('.foo',), (), space),)"))
-    assert_equal("true", evaluate("selector-parse('.foo .bar') == ('.foo' '.bar',)"))
-    assert_equal("true",
-      evaluate("selector-parse('.foo .bar, .baz .bang') == ('.foo' '.bar', '.baz' '.bang')"))
-
-    assert_equal(".foo %bar", evaluate("selector-parse('.foo %bar')"))
-
-    assert_equal("true",
-      evaluate("selector-parse(('.foo', '.bar')) == selector-parse('.foo, .bar')"))
-    assert_equal("true",
-      evaluate("selector-parse('.foo' '.bar') == selector-parse('.foo .bar')"))
-
-    assert_equal("true", evaluate("selector-parse(('.foo' '.bar', '.baz' '.bang')) == " +
-        "selector-parse('.foo .bar, .baz .bang')"))
-    assert_equal("true", evaluate("selector-parse(('.foo .bar', '.baz .bang')) == " +
-        "selector-parse('.foo .bar, .baz .bang')"))
-
-    # This may throw an error in the future.
-    assert_equal("true", evaluate("selector-parse(('.foo, .bar' '.baz, .bang')) == " +
-        "selector-parse('.foo, .bar .baz, .bang')"))
-  end
-
-  def test_selector_argument_validation
-    assert_error_message("$selector: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-parse'", "selector-parse(12)")
-    assert_error_message("$selector: (((\".foo\" \".bar\"), \".baz\") (\".bang\", \".qux\")) is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-parse'",
-      "selector-parse(('.foo' '.bar', '.baz') ('.bang', '.qux'))")
-    assert_error_message("$selector: \".#\" is not a valid selector: Invalid CSS after \".\": " +
-      "expected class name, was \"#\" for `selector-parse'", "selector-parse('.#')")
-    assert_error_message("$selector: \"&.foo\" is not a valid selector: Invalid CSS after \"\": " +
-      "expected selector, was \"&.foo\" for `selector-parse'", "selector-parse('&.foo')")
-  end
-
-  def test_selector_nest
-    assert_equal(".foo", evaluate("selector-nest('.foo')"))
-    assert_equal(".foo .bar", evaluate("selector-nest('.foo', '.bar')"))
-    assert_equal(".foo .bar .baz", evaluate("selector-nest('.foo', '.bar', '.baz')"))
-    assert_equal(".a .foo .b .bar", evaluate("selector-nest('.a .foo', '.b .bar')"))
-    assert_equal(".foo.bar", evaluate("selector-nest('.foo', '&.bar')"))
-    assert_equal(".baz .foo.bar", evaluate("selector-nest('.foo', '&.bar', '.baz &')"))
-  end
-
-  def test_selector_nest_checks_types
-    assert_error_message("$selectors: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-nest'",
-      "selector-nest(12)")
-    assert_error_message("$selectors: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-nest'",
-      "selector-nest('.foo', 12)")
-  end
-
-  def test_selector_nest_argument_validation
-    assert_error_message("$selectors: At least one selector must be passed for `selector-nest'",
-      "selector-nest()")
-  end
-
-  def test_selector_append
-    assert_equal(".foo.bar", evaluate("selector-append('.foo', '.bar')"))
-    assert_equal(".a .foo.b .bar", evaluate("selector-append('.a .foo', '.b .bar')"))
-    assert_equal(".foo-suffix", evaluate("selector-append('.foo', '-suffix')"))
-    assert_equal(".foo.bar, .foo-suffix", evaluate("selector-append('.foo', '.bar, -suffix')"))
-    assert_equal(".foo--suffix", evaluate("selector-append('.foo', '--suffix')"))
-    assert_equal(".foo.bar, .foo--suffix", evaluate("selector-append('.foo', '.bar, --suffix')"))
-  end
-
-  def test_selector_append_checks_types
-    assert_error_message("$selectors: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-append'",
-      "selector-append(12)")
-    assert_error_message("$selectors: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-append'",
-      "selector-append('.foo', 12)")
-  end
-
-  def test_selector_append_errors
-    assert_error_message("$selectors: At least one selector must be passed for `selector-append'",
-      "selector-append()")
-    assert_error_message("Can't append \"> .bar\" to \".foo\" for `selector-append'",
-      "selector-append('.foo', '> .bar')")
-    assert_error_message("Can't append \"*.bar\" to \".foo\" for `selector-append'",
-      "selector-append('.foo', '*.bar')")
-    assert_error_message("Can't append \"ns|suffix\" to \".foo\" for `selector-append'",
-      "selector-append('.foo', 'ns|suffix')")
-  end
-
-  def test_selector_extend
-    assert_equal(".foo .x, .foo .a .bar, .a .foo .bar",
-      evaluate("selector-extend('.foo .x', '.x', '.a .bar')"))
-    assert_equal(".foo .x, .foo .bang, .x.bar, .bar.bang",
-      evaluate("selector-extend('.foo .x, .x.bar', '.x', '.bang')"))
-    assert_equal(".y .x, .foo .x, .y .foo, .foo .foo",
-      evaluate("selector-extend('.y .x', '.x, .y', '.foo')"))
-    assert_equal(".foo .x, .foo .bar, .foo .bang",
-      evaluate("selector-extend('.foo .x', '.x', '.bar, .bang')"))
-    assert_equal(".foo.x, .foo",
-      evaluate("selector-extend('.foo.x', '.x', '.foo')"))
-  end
-
-  def test_selector_extend_checks_types
-    assert_error_message("$selector: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-extend'",
-      "selector-extend(12, '.foo', '.bar')")
-    assert_error_message("$extendee: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-extend'",
-      "selector-extend('.foo', 12, '.bar')")
-    assert_error_message("$extender: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-extend'",
-      "selector-extend('.foo', '.bar', 12)")
-  end
-
-  def test_selector_extend_errors
-    assert_error_message("Can't extend .bar .baz: can't extend nested selectors for " +
-      "`selector-extend'", "selector-extend('.foo', '.bar .baz', '.bang')")
-    assert_error_message("Can't extend >: invalid selector for `selector-extend'",
-      "selector-extend('.foo', '>', '.bang')")
-    assert_error_message(".bang > can't extend: invalid selector for `selector-extend'",
-      "selector-extend('.foo', '.bar', '.bang >')")
-  end
-
-  def test_selector_replace
-    assert_equal(".bar", evaluate("selector-replace('.foo', '.foo', '.bar')"))
-    assert_equal(".foo.baz", evaluate("selector-replace('.foo.bar', '.bar', '.baz')"))
-    assert_equal(".a .foo.baz", evaluate("selector-replace('.foo.bar', '.bar', '.a .baz')"))
-    assert_equal(".foo.bar", evaluate("selector-replace('.foo.bar', '.baz.bar', '.qux')"))
-    assert_equal(".bar.qux", evaluate("selector-replace('.foo.bar.baz', '.foo.baz', '.qux')"))
-
-    assert_equal(":not(.bar)", evaluate("selector-replace(':not(.foo)', '.foo', '.bar')"))
-    assert_equal(".bar", evaluate("selector-replace(':not(.foo)', ':not(.foo)', '.bar')"))
-  end
-
-  def test_selector_replace_checks_types
-    assert_error_message("$selector: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-replace'",
-      "selector-replace(12, '.foo', '.bar')")
-    assert_error_message("$original: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-replace'",
-      "selector-replace('.foo', 12, '.bar')")
-    assert_error_message("$replacement: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-replace'",
-      "selector-replace('.foo', '.bar', 12)")
-  end
-
-  def test_selector_replace_errors
-    assert_error_message("Can't extend .bar .baz: can't extend nested selectors for " +
-      "`selector-replace'", "selector-replace('.foo', '.bar .baz', '.bang')")
-    assert_error_message("Can't extend >: invalid selector for `selector-replace'",
-      "selector-replace('.foo', '>', '.bang')")
-    assert_error_message(".bang > can't extend: invalid selector for `selector-replace'",
-      "selector-replace('.foo', '.bar', '.bang >')")
-  end
-
-  def test_selector_unify
-    assert_equal(".foo", evaluate("selector-unify('.foo', '.foo')"))
-    assert_equal(".foo.bar", evaluate("selector-unify('.foo', '.bar')"))
-    assert_equal(".foo.bar.baz", evaluate("selector-unify('.foo.bar', '.bar.baz')"))
-    assert_equal(".a .b .foo.bar, .b .a .foo.bar", evaluate("selector-unify('.a .foo', '.b .bar')"))
-    assert_equal(".a .foo.bar", evaluate("selector-unify('.a .foo', '.a .bar')"))
-    assert_equal("", evaluate("selector-unify('p', 'a')"))
-    assert_equal("", evaluate("selector-unify('.foo >', '.bar')"))
-    assert_equal("", evaluate("selector-unify('.foo', '.bar >')"))
-    assert_equal(".foo.baz, .foo.bang, .bar.baz, .bar.bang",
-      evaluate("selector-unify('.foo, .bar', '.baz, .bang')"))
-  end
-
-  def test_selector_unify_checks_types
-    assert_error_message("$selector1: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-unify'",
-      "selector-unify(12, '.foo')")
-    assert_error_message("$selector2: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `selector-unify'",
-      "selector-unify('.foo', 12)")
-  end
-
-  def test_simple_selectors
-    assert_equal('(.foo,)', evaluate("inspect(simple-selectors('.foo'))"))
-    assert_equal('.foo, .bar', evaluate("inspect(simple-selectors('.foo.bar'))"))
-    assert_equal('.foo, .bar, :pseudo("flip, flap")',
-      evaluate("inspect(simple-selectors('.foo.bar:pseudo(\"flip, flap\")'))"))
-  end
-
-  def test_simple_selectors_checks_types
-    assert_error_message("$selector: 12 is not a string for `simple-selectors'",
-      "simple-selectors(12)")
-  end
-
-  def test_simple_selectors_errors
-    assert_error_message("$selector: \".foo .bar\" is not a compound selector for `simple-selectors'",
-      "simple-selectors('.foo .bar')")
-    assert_error_message("$selector: \".foo,.bar\" is not a compound selector for `simple-selectors'",
-      "simple-selectors('.foo,.bar')")
-    assert_error_message("$selector: \".#\" is not a valid selector: Invalid CSS after \".\": " +
-      "expected class name, was \"#\" for `simple-selectors'", "simple-selectors('.#')")
-  end
-
-  def test_is_superselector
-    assert_equal("true", evaluate("is-superselector('.foo', '.foo.bar')"))
-    assert_equal("false", evaluate("is-superselector('.foo.bar', '.foo')"))
-    assert_equal("true", evaluate("is-superselector('.foo', '.foo')"))
-    assert_equal("true", evaluate("is-superselector('.bar', '.foo .bar')"))
-    assert_equal("false", evaluate("is-superselector('.foo .bar', '.bar')"))
-    assert_equal("true", evaluate("is-superselector('.foo .bar', '.foo > .bar')"))
-    assert_equal("false", evaluate("is-superselector('.foo > .bar', '.foo .bar')"))
-  end
-
-  def test_is_superselector_checks_types
-    assert_error_message("$super: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `is-superselector'",
-      "is-superselector(12, '.foo')")
-    assert_error_message("$sub: 12 is not a valid selector: it must be a string,\n" +
-      "a list of strings, or a list of lists of strings for `is-superselector'",
-      "is-superselector('.foo', 12)")
-  end
-
   ## Regression Tests
 
-  def test_inspect_nested_empty_lists
-    assert_equal "() ()", evaluate("inspect(() ())")
-  end
-
   def test_saturation_bounds
     assert_equal "#fbfdff", evaluate("hsl(hue(#fbfdff), saturation(#fbfdff), lightness(#fbfdff))")
   end
 
   private
-  def env(hash = {}, parent = nil)
-    env = Sass::Environment.new(parent)
-    hash.each {|k, v| env.set_var(k, v)}
-    env
-  end
 
-  def evaluate(value, environment = env)
-    result = perform(value, environment)
-    assert_kind_of Sass::Script::Value::Base, result
+  def evaluate(value)
+    result = perform(value)
+    assert_kind_of Sass::Script::Literal, result
     return result.to_s
   end
 
-  def perform(value, environment = env)
-    Sass::Script::Parser.parse(value, 0, 0).perform(environment)
-  end
-
-  def render(sass, options = {})
-    options[:syntax] ||= :scss
-    munge_filename options
-    options[:importer] ||= MockImporter.new
-    Sass::Engine.new(sass, options).render
+  def perform(value)
+    Sass::Script::Parser.parse(value, 0, 0).perform(Sass::Environment.new)
   end
 
   def assert_error_message(message, value)
@@ -1923,4 +1135,5 @@ WARNING
   rescue Sass::SyntaxError => e
     assert_equal(message, e.message)
   end
+
 end