sass 3.2.7 → 3.3.0.rc.1

data/test/sass/functions_test.rb

@@ -1,37 +1,43 @@
 #!/usr/bin/env ruby
 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::String.new("no-kw-args")
+    Sass::Script::Value::String.new("no-kw-args")
   end
 
   def only_var_args(*args)
-    Sass::Script::String.new("only-var-args("+args.map{|a| a.plus(Sass::Script::Number.new(1)).to_s }.join(", ")+")")
+    Sass::Script::Value::String.new("only-var-args("+args.map{|a| a.plus(Sass::Script::Value::Number.new(1)).to_s }.join(", ")+")")
   end
   declare :only_var_args, [], :var_args => true
 
   def only_kw_args(kwargs)
-    Sass::Script::String.new("only-kw-args(" + kwargs.keys.map {|a| a.to_s}.sort.join(", ") + ")")
+    Sass::Script::Value::String.new("only-kw-args(" + kwargs.keys.map {|a| a.to_s}.sort.join(", ") + ")")
   end
   declare :only_kw_args, [], :var_kwargs => true
 end
 
 module Sass::Script::Functions::UserFunctions
-  def call_options_on_new_literal
-    str = Sass::Script::String.new("foo")
+  def call_options_on_new_value
+    str = Sass::Script::Value::String.new("foo")
     str.options[:foo]
     str
   end
 
   def user_defined
-    Sass::Script::String.new("I'm a user-defined string!")
+    Sass::Script::Value::String.new("I'm a user-defined string!")
   end
 
   def _preceding_underscore
-    Sass::Script::String.new("I'm another user-defined string!")
+    Sass::Script::Value::String.new("I'm another user-defined string!")
+  end
+
+  def fetch_the_variable
+    environment.var('variable')
   end
 end
 
@@ -84,9 +90,9 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_hsl_checks_types
-    assert_error_message("\"foo\" is not a number for `hsl'", "hsl(\"foo\", 10, 12)");
-    assert_error_message("\"foo\" is not a number for `hsl'", "hsl(10, \"foo\", 12)");
-    assert_error_message("\"foo\" is not a number for `hsl'", "hsl(10, 10, \"foo\")");
+    assert_error_message("$hue: \"foo\" is not a number for `hsl'", "hsl(\"foo\", 10, 12)");
+    assert_error_message("$saturation: \"foo\" is not a number for `hsl'", "hsl(10, \"foo\", 12)");
+    assert_error_message("$lightness: \"foo\" is not a number for `hsl'", "hsl(10, 10, \"foo\")");
   end
 
   def test_hsla
@@ -104,10 +110,10 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_hsla_checks_types
-    assert_error_message("\"foo\" is not a number for `hsla'", "hsla(\"foo\", 10, 12, 0.3)");
-    assert_error_message("\"foo\" is not a number for `hsla'", "hsla(10, \"foo\", 12, 0)");
-    assert_error_message("\"foo\" is not a number for `hsla'", "hsla(10, 10, \"foo\", 1)");
-    assert_error_message("\"foo\" is not a number for `hsla'", "hsla(10, 10, 10, \"foo\")");
+    assert_error_message("$hue: \"foo\" is not a number for `hsla'", "hsla(\"foo\", 10, 12, 0.3)");
+    assert_error_message("$saturation: \"foo\" is not a number for `hsla'", "hsla(10, \"foo\", 12, 0)");
+    assert_error_message("$lightness: \"foo\" is not a number for `hsla'", "hsla(10, 10, \"foo\", 1)");
+    assert_error_message("$alpha: \"foo\" is not a number for `hsla'", "hsla(10, 10, 10, \"foo\")");
   end
 
   def test_percentage
@@ -118,9 +124,9 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_percentage_checks_types
-    assert_error_message("25px is not a unitless number for `percentage'", "percentage(25px)")
-    assert_error_message("#cccccc is not a unitless number for `percentage'", "percentage(#ccc)")
-    assert_error_message("\"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
@@ -129,7 +135,7 @@ class SassFunctionTest < Test::Unit::TestCase
     assert_equal("5px", evaluate("round(5.49px)"))
     assert_equal("5px", evaluate("round($value: 5.49px)"))
 
-    assert_error_message("#cccccc is not a number for `round'", "round(#ccc)")
+    assert_error_message("$value: #cccccc is not a number for `round'", "round(#ccc)")
   end
 
   def test_floor
@@ -137,7 +143,7 @@ class SassFunctionTest < Test::Unit::TestCase
     assert_equal("4px", evaluate("floor(4.8px)"))
     assert_equal("4px", evaluate("floor($value: 4.8px)"))
 
-    assert_error_message("\"foo\" is not a number for `floor'", "floor(\"foo\")")
+    assert_error_message("$value: \"foo\" is not a number for `floor'", "floor(\"foo\")")
   end
 
   def test_ceil
@@ -145,7 +151,7 @@ class SassFunctionTest < Test::Unit::TestCase
     assert_equal("5px", evaluate("ceil(4.8px)"))
     assert_equal("5px", evaluate("ceil($value: 4.8px)"))
 
-    assert_error_message("\"a\" is not a number for `ceil'", "ceil(\"a\")")
+    assert_error_message("$value: \"a\" is not a number for `ceil'", "ceil(\"a\")")
   end
 
   def test_abs
@@ -155,11 +161,11 @@ class SassFunctionTest < Test::Unit::TestCase
     assert_equal("5px", evaluate("abs(5px)"))
     assert_equal("5px", evaluate("abs($value: 5px)"))
 
-    assert_error_message("#aaaaaa is not a number for `abs'", "abs(#aaa)")
+    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)"))
@@ -193,31 +199,31 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_rgb_tests_bounds
-    assert_error_message("Color value 256 must be between 0 and 255 for `rgb'",
+    assert_error_message("$red: Color value 256 must be between 0 and 255 for `rgb'",
       "rgb(256, 1, 1)")
-    assert_error_message("Color value 256 must be between 0 and 255 for `rgb'",
+    assert_error_message("$green: Color value 256 must be between 0 and 255 for `rgb'",
       "rgb(1, 256, 1)")
-    assert_error_message("Color value 256 must be between 0 and 255 for `rgb'",
+    assert_error_message("$blue: Color value 256 must be between 0 and 255 for `rgb'",
       "rgb(1, 1, 256)")
-    assert_error_message("Color value 256 must be between 0 and 255 for `rgb'",
+    assert_error_message("$green: Color value 256 must be between 0 and 255 for `rgb'",
       "rgb(1, 256, 257)")
-    assert_error_message("Color value -1 must be between 0 and 255 for `rgb'",
+    assert_error_message("$red: Color value -1 must be between 0 and 255 for `rgb'",
       "rgb(-1, 1, 1)")
   end
 
   def test_rgb_test_percent_bounds
-    assert_error_message("Color value 100.1% must be between 0% and 100% for `rgb'",
+    assert_error_message("$red: Color value 100.1% must be between 0% and 100% for `rgb'",
       "rgb(100.1%, 0, 0)")
-    assert_error_message("Color value -0.1% must be between 0% and 100% for `rgb'",
+    assert_error_message("$green: Color value -0.1% must be between 0% and 100% for `rgb'",
       "rgb(0, -0.1%, 0)")
-    assert_error_message("Color value 101% must be between 0% and 100% for `rgb'",
+    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
-    assert_error_message("\"foo\" is not a number for `rgb'", "rgb(\"foo\", 10, 12)");
-    assert_error_message("\"foo\" is not a number for `rgb'", "rgb(10, \"foo\", 12)");
-    assert_error_message("\"foo\" is not a number for `rgb'", "rgb(10, 10, \"foo\")");
+    assert_error_message("$red: \"foo\" is not a number for `rgb'", "rgb(\"foo\", 10, 12)");
+    assert_error_message("$green: \"foo\" is not a number for `rgb'", "rgb(10, \"foo\", 12)");
+    assert_error_message("$blue: \"foo\" is not a number for `rgb'", "rgb(10, 10, \"foo\")");
   end
 
   def test_rgba
@@ -228,15 +234,15 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_rgba_tests_bounds
-    assert_error_message("Color value 256 must be between 0 and 255 for `rgba'",
+    assert_error_message("$red: Color value 256 must be between 0 and 255 for `rgba'",
       "rgba(256, 1, 1, 0.3)")
-    assert_error_message("Color value 256 must be between 0 and 255 for `rgba'",
+    assert_error_message("$green: Color value 256 must be between 0 and 255 for `rgba'",
       "rgba(1, 256, 1, 0.3)")
-    assert_error_message("Color value 256 must be between 0 and 255 for `rgba'",
+    assert_error_message("$blue: Color value 256 must be between 0 and 255 for `rgba'",
       "rgba(1, 1, 256, 0.3)")
-    assert_error_message("Color value 256 must be between 0 and 255 for `rgba'",
+    assert_error_message("$green: Color value 256 must be between 0 and 255 for `rgba'",
       "rgba(1, 256, 257, 0.3)")
-    assert_error_message("Color value -1 must be between 0 and 255 for `rgba'",
+    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)")
@@ -245,10 +251,10 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_rgba_tests_types
-    assert_error_message("\"foo\" is not a number for `rgba'", "rgba(\"foo\", 10, 12, 0.2)");
-    assert_error_message("\"foo\" is not a number for `rgba'", "rgba(10, \"foo\", 12, 0.1)");
-    assert_error_message("\"foo\" is not a number for `rgba'", "rgba(10, 10, \"foo\", 0)");
-    assert_error_message("\"foo\" is not a number for `rgba'", "rgba(10, 10, 10, \"foo\")");
+    assert_error_message("$red: \"foo\" is not a number for `rgba'", "rgba(\"foo\", 10, 12, 0.2)");
+    assert_error_message("$green: \"foo\" is not a number for `rgba'", "rgba(10, \"foo\", 12, 0.1)");
+    assert_error_message("$blue: \"foo\" is not a number for `rgba'", "rgba(10, 10, \"foo\", 0)");
+    assert_error_message("$alpha: \"foo\" is not a number for `rgba'", "rgba(10, 10, 10, \"foo\")");
   end
 
   def test_rgba_with_color
@@ -258,8 +264,8 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_rgba_with_color_tests_types
-    assert_error_message("\"foo\" is not a color for `rgba'", "rgba(\"foo\", 0.2)");
-    assert_error_message("\"foo\" is not a number for `rgba'", "rgba(blue, \"foo\")");
+    assert_error_message("$color: \"foo\" is not a color for `rgba'", "rgba(\"foo\", 0.2)");
+    assert_error_message("$alpha: \"foo\" is not a number for `rgba'", "rgba(blue, \"foo\")");
   end
 
   def test_rgba_tests_num_args
@@ -275,7 +281,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_red_exception
-    assert_error_message("12 is not a color for `red'", "red(12)")
+    assert_error_message("$color: 12 is not a color for `red'", "red(12)")
   end
 
   def test_green
@@ -284,7 +290,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_green_exception
-    assert_error_message("12 is not a color for `green'", "green(12)")
+    assert_error_message("$color: 12 is not a color for `green'", "green(12)")
   end
 
   def test_blue
@@ -293,7 +299,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_blue_exception
-    assert_error_message("12 is not a color for `blue'", "blue(12)")
+    assert_error_message("$color: 12 is not a color for `blue'", "blue(12)")
   end
 
   def test_hue
@@ -302,7 +308,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_hue_exception
-    assert_error_message("12 is not a color for `hue'", "hue(12)")
+    assert_error_message("$color: 12 is not a color for `hue'", "hue(12)")
   end
 
   def test_saturation
@@ -312,7 +318,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_saturation_exception
-    assert_error_message("12 is not a color for `saturation'", "saturation(12)")
+    assert_error_message("$color: 12 is not a color for `saturation'", "saturation(12)")
   end
 
   def test_lightness
@@ -322,7 +328,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_lightness_exception
-    assert_error_message("12 is not a color for `lightness'", "lightness(12)")
+    assert_error_message("$color: 12 is not a color for `lightness'", "lightness(12)")
   end
 
   def test_alpha
@@ -333,7 +339,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_alpha_exception
-    assert_error_message("12 is not a color for `alpha'", "alpha(12)")
+    assert_error_message("$color: 12 is not a color for `alpha'", "alpha(12)")
   end
 
   def test_opacity
@@ -345,7 +351,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_opacity_exception
-    assert_error_message("\"foo\" is not a color for `opacity'", "opacity(foo)")
+    assert_error_message("$color: \"foo\" is not a color for `opacity'", "opacity(foo)")
   end
 
   def test_opacify
@@ -367,16 +373,16 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_opacify_tests_types
-    assert_error_message("\"foo\" is not a color for `opacify'", "opacify(\"foo\", 10%)")
-    assert_error_message("\"foo\" is not a number for `opacify'", "opacify(#fff, \"foo\")")
+    assert_error_message("$color: \"foo\" is not a color for `opacify'", "opacify(\"foo\", 10%)")
+    assert_error_message("$amount: \"foo\" is not a number for `opacify'", "opacify(#fff, \"foo\")")
   end
 
   def test_transparentize
     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("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("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.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)"))
@@ -390,8 +396,8 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_transparentize_tests_types
-    assert_error_message("\"foo\" is not a color for `transparentize'", "transparentize(\"foo\", 10%)")
-    assert_error_message("\"foo\" is not a number for `transparentize'", "transparentize(#fff, \"foo\")")
+    assert_error_message("$color: \"foo\" is not a color for `transparentize'", "transparentize(\"foo\", 10%)")
+    assert_error_message("$amount: \"foo\" is not a number for `transparentize'", "transparentize(#fff, \"foo\")")
   end
 
   def test_lighten
@@ -412,8 +418,8 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_lighten_tests_types
-    assert_error_message("\"foo\" is not a color for `lighten'", "lighten(\"foo\", 10%)")
-    assert_error_message("\"foo\" is not a number for `lighten'", "lighten(#fff, \"foo\")")
+    assert_error_message("$color: \"foo\" is not a color for `lighten'", "lighten(\"foo\", 10%)")
+    assert_error_message("$amount: \"foo\" is not a number for `lighten'", "lighten(#fff, \"foo\")")
   end
 
   def test_darken
@@ -434,8 +440,8 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_darken_tests_types
-    assert_error_message("\"foo\" is not a color for `darken'", "darken(\"foo\", 10%)")
-    assert_error_message("\"foo\" is not a number for `darken'", "darken(#fff, \"foo\")")
+    assert_error_message("$color: \"foo\" is not a color for `darken'", "darken(\"foo\", 10%)")
+    assert_error_message("$amount: \"foo\" is not a number for `darken'", "darken(#fff, \"foo\")")
   end
 
   def test_saturate
@@ -458,8 +464,8 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_saturate_tests_types
-    assert_error_message("\"foo\" is not a color for `saturate'", "saturate(\"foo\", 10%)")
-    assert_error_message("\"foo\" is not a number for `saturate'", "saturate(#fff, \"foo\")")
+    assert_error_message("$color: \"foo\" is not a color for `saturate'", "saturate(\"foo\", 10%)")
+    assert_error_message("$amount: \"foo\" is not a number for `saturate'", "saturate(#fff, \"foo\")")
   end
 
   def test_desaturate
@@ -481,8 +487,8 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_desaturate_tests_types
-    assert_error_message("\"foo\" is not a color for `desaturate'", "desaturate(\"foo\", 10%)")
-    assert_error_message("\"foo\" is not a number for `desaturate'", "desaturate(#fff, \"foo\")")
+    assert_error_message("$color: \"foo\" is not a color for `desaturate'", "desaturate(\"foo\", 10%)")
+    assert_error_message("$amount: \"foo\" is not a number for `desaturate'", "desaturate(#fff, \"foo\")")
   end
 
   def test_adjust_hue
@@ -498,8 +504,8 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_adjust_hue_tests_types
-    assert_error_message("\"foo\" is not a color for `adjust-hue'", "adjust-hue(\"foo\", 10%)")
-    assert_error_message("\"foo\" is not a number for `adjust-hue'", "adjust-hue(#fff, \"foo\")")
+    assert_error_message("$color: \"foo\" is not a color for `adjust-hue'", "adjust-hue(\"foo\", 10%)")
+    assert_error_message("$degrees: \"foo\" is not a number for `adjust-hue'", "adjust-hue(#fff, \"foo\")")
   end
 
   def test_adjust_color
@@ -557,7 +563,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_adjust_color_tests_types
-    assert_error_message("\"foo\" is not a color for `adjust-color'", "adjust-color(foo, $hue: 10)")
+    assert_error_message("$color: \"foo\" is not a color for `adjust-color'", "adjust-color(foo, $hue: 10)")
     # HSL
     assert_error_message("$hue: \"foo\" is not a number for `adjust-color'",
       "adjust-color(blue, $hue: foo)")
@@ -663,7 +669,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_scale_color_tests_types
-    assert_error_message("\"foo\" is not a color for `scale-color'", "scale-color(foo, $red: 10%)")
+    assert_error_message("$color: \"foo\" is not a color for `scale-color'", "scale-color(foo, $red: 10%)")
     # HSL
     assert_error_message("$saturation: \"foo\" is not a number for `scale-color'",
       "scale-color(blue, $saturation: foo)")
@@ -691,9 +697,9 @@ class SassFunctionTest < Test::Unit::TestCase
       "scale-color(blue, $alpha: -101%)")
 
     # Unit
-    assert_error_message("$saturation: Amount 80 must be a % (e.g. 80%) for `scale-color'",
+    assert_error_message("Expected $saturation to have a unit of % but got 80 for `scale-color'",
       "scale-color(blue, $saturation: 80)")
-    assert_error_message("$alpha: Amount 0.5 must be a % (e.g. 0.5%) for `scale-color'",
+    assert_error_message("Expected $alpha to have a unit of % but got 0.5 for `scale-color'",
       "scale-color(blue, $alpha: 0.5)")
 
     # Unknown argument
@@ -734,7 +740,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_change_color_tests_types
-    assert_error_message("\"foo\" is not a color for `change-color'", "change-color(foo, $red: 10%)")
+    assert_error_message("$color: \"foo\" is not a color for `change-color'", "change-color(foo, $red: 10%)")
     # HSL
     assert_error_message("$saturation: \"foo\" is not a number for `change-color'",
       "change-color(blue, $saturation: foo)")
@@ -797,9 +803,9 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_mix_tests_types
-    assert_error_message("\"foo\" is not a color for `mix'", "mix(\"foo\", #f00, 10%)")
-    assert_error_message("\"foo\" is not a color for `mix'", "mix(#f00, \"foo\", 10%)")
-    assert_error_message("\"foo\" is not a number for `mix'", "mix(#f00, #baf, \"foo\")")
+    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
 
   def test_mix_tests_bounds
@@ -811,8 +817,8 @@ class SassFunctionTest < Test::Unit::TestCase
 
   def test_grayscale
     assert_equal("#bbbbbb", evaluate("grayscale(#abc)"))
-    assert_equal("gray", evaluate("grayscale(#f00)"))
-    assert_equal("gray", evaluate("grayscale(#00f)"))
+    assert_equal("grey", evaluate("grayscale(#f00)"))
+    assert_equal("grey", evaluate("grayscale(#00f)"))
     assert_equal("white", evaluate("grayscale(white)"))
     assert_equal("black", evaluate("grayscale(black)"))
     assert_equal("black", evaluate("grayscale($color: black)"))
@@ -822,7 +828,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def tets_grayscale_tests_types
-    assert_error_message("\"foo\" is not a color for `grayscale'", "grayscale(\"foo\")")
+    assert_error_message("$color: \"foo\" is not a color for `grayscale'", "grayscale(\"foo\")")
   end
 
   def test_complement
@@ -835,7 +841,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def tets_complement_tests_types
-    assert_error_message("\"foo\" is not a color for `complement'", "complement(\"foo\")")
+    assert_error_message("$color: \"foo\" is not a color for `complement'", "complement(\"foo\")")
   end
 
   def test_invert
@@ -845,7 +851,7 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_invert_tests_types
-    assert_error_message("\"foo\" is not a color for `invert'", "invert(\"foo\")")
+    assert_error_message("$color: \"foo\" is not a color for `invert'", "invert(\"foo\")")
   end
 
   def test_unquote
@@ -861,7 +867,83 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_quote_tests_type
-    assert_error_message("#ff0000 is not a string for `quote'", "quote(#f00)")
+    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('0', evaluate('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('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
@@ -873,12 +955,17 @@ class SassFunctionTest < Test::Unit::TestCase
     assert_equal("I'm another user-defined string!", evaluate("-preceding-underscore()"))
   end
 
-  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.
+  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.
   This error is probably occurring because #to_s was called
-  on this literal within a custom Sass function without first
-  setting the #option attribute.
+  on this value within a custom Sass function without first
+  setting the #options attribute.
 MSG
   end
 
@@ -890,6 +977,22 @@ 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
@@ -900,14 +1003,14 @@ MSG
     assert_equal(%Q{"em/rem"}, evaluate("unit(10px * 5em / 30cm / 1rem)"))
     assert_equal(%Q{"em*vh/cm*rem"}, evaluate("unit(10vh * 5em / 30cm / 1rem)"))
     assert_equal(%Q{"px"}, evaluate("unit($number: 100px)"))
-    assert_error_message("#ff0000 is not a number for `unit'", "unit(#f00)")
+    assert_error_message("$number: #ff0000 is not a number for `unit'", "unit(#f00)")
   end
 
   def test_unitless
     assert_equal(%Q{true}, evaluate("unitless(100)"))
     assert_equal(%Q{false}, evaluate("unitless(100px)"))
     assert_equal(%Q{false}, evaluate("unitless($number: 100px)"))
-    assert_error_message("#ff0000 is not a number for `unitless'", "unitless(#f00)")
+    assert_error_message("$number: #ff0000 is not a number for `unitless'", "unitless(#f00)")
   end
 
   def test_comparable
@@ -915,8 +1018,8 @@ MSG
     assert_equal(%Q{true}, evaluate("comparable(10cm, 3mm)"))
     assert_equal(%Q{false}, evaluate("comparable(100px, 3em)"))
     assert_equal(%Q{false}, evaluate("comparable($number-1: 100px, $number-2: 3em)"))
-    assert_error_message("#ff0000 is not a number for `comparable'", "comparable(#f00, 1px)")
-    assert_error_message("#ff0000 is not a number for `comparable'", "comparable(1px, #f00)")
+    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
@@ -927,20 +1030,47 @@ 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 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 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 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
@@ -979,6 +1109,20 @@ MSG
     assert_equal("false", evaluate("(1, 2, ()) == join((), (1, 2))"))
 
     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
@@ -1013,12 +1157,20 @@ MSG
     assert_equal("true", evaluate("(1 2) == nth(append((), 1 2), 1)"))
 
     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
@@ -1029,12 +1181,61 @@ MSG
     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)"))
+
+    assert_equal("1", evaluate("index((foo: bar, bar: baz), (foo bar))"))
+    assert_equal("false", evaluate("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))"))
   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
+    assert_equal("counter(foo)", evaluate("counter(foo)"))
+    assert_equal('counter(item,".")', evaluate('counter(item, ".")'))
+    assert_equal('counter(item,".")', evaluate('counter(item,".")'))
+  end
+
+  def test_counters
+    assert_equal("counters(foo)", evaluate("counters(foo)"))
+    assert_equal('counters(item,".")', evaluate('counters(item, ".")'))
+    assert_equal('counters(item,".")', evaluate('counters(item,".")'))
   end
 
   def test_keyword_args_rgb
@@ -1096,6 +1297,277 @@ MSG
     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)
+      assert_not_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
+
+    assert_warning(<<WARNING) do
+DEPRECATION WARNING: Passing lists of pairs to map-get is deprecated and will
+be removed in future versions of Sass. Use Sass maps instead. For details, see
+http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#maps.
+WARNING
+      assert_equal "1", evaluate("map-get((foo 1) (bar 2), foo)")
+    end
+  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)
+
+    assert_warning(<<WARNING) do
+DEPRECATION WARNING: Passing lists of pairs to map-merge is deprecated and will
+be removed in future versions of Sass. Use Sass maps instead. For details, see
+http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#maps.
+WARNING
+      assert_equal("(foo: 1, bar: 2, baz: 3)",
+        perform("map-merge((foo 1, bar 2), (baz: 3))").to_sass)
+    end
+
+    assert_warning(<<WARNING) do
+DEPRECATION WARNING: Passing lists of pairs to map-merge is deprecated and will
+be removed in future versions of Sass. Use Sass maps instead. For details, see
+http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#maps.
+WARNING
+      assert_equal("(baz: 3, foo: 1, bar: 2)",
+        perform("map-merge((baz: 3), (foo 1, bar 2))").to_sass)
+    end
+  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)
+
+    assert_warning(<<WARNING) do
+DEPRECATION WARNING: Passing lists of pairs to map-keys is deprecated and will
+be removed in future versions of Sass. Use Sass maps instead. For details, see
+http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#maps.
+WARNING
+      assert_equal("foo, bar",
+        perform("map-keys((foo 1, bar 2))").to_sass)
+    end
+  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)
+
+    assert_warning(<<WARNING) do
+DEPRECATION WARNING: Passing lists of pairs to map-values is deprecated and will
+be removed in future versions of Sass. Use Sass maps instead. For details, see
+http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#maps.
+WARNING
+      assert_equal("1, 2", perform("map-values((foo 1, bar 2))").to_sass)
+    end
+  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)")
+
+    assert_warning(<<WARNING) do
+DEPRECATION WARNING: Passing lists of pairs to map-has-key is deprecated and will
+be removed in future versions of Sass. Use Sass maps instead. For details, see
+http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#maps.
+WARNING
+      assert_equal("true", evaluate("map-has-key((foo 1, bar 1), foo)"))
+    end
+  end
+
+  def test_keywords
+    # The actual functionality is tested in tests where real arglists are passed.
+    assert_error_message("12 is not a variable argument list for `keywords'", "keywords(12)")
+    assert_error_message("(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_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_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_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_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_existence_functions_check_argument_type
+    assert_error_message("2px is not a string for `function-exists'", "function-exists(2px)")
+    assert_error_message("2px is not a string for `mixin-exists'", "mixin-exists(2px)")
+    assert_error_message("2px is not a string for `global-variable-exists'", "global-variable-exists(2px)")
+    assert_error_message("2px is not a string for `variable-exists'", "variable-exists(2px)")
+  end
+
+
   ## Regression Tests
 
   def test_saturation_bounds
@@ -1103,13 +1575,27 @@ MSG
   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
+    return result.to_s
+  end
 
-  def evaluate(value)
-    Sass::Script::Parser.parse(value, 0, 0).perform(Sass::Environment.new).to_s
+  def perform(value, environment = env)
+    Sass::Script::Parser.parse(value, 0, 0).perform(environment)
   end
 
-  def perform(value)
-    Sass::Script::Parser.parse(value, 0, 0).perform(Sass::Environment.new)
+  def render(sass, options = {})
+    options[:syntax] ||= :scss
+    munge_filename options
+    options[:importer] ||= MockImporter.new
+    Sass::Engine.new(sass, options).render
   end
 
   def assert_error_message(message, value)
@@ -1118,5 +1604,4 @@ MSG
   rescue Sass::SyntaxError => e
     assert_equal(message, e.message)
   end
-
 end