sass 3.3.14 → 3.4.0.rc.1

data/test/sass/exec_test.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/../test_helper'
 require 'sass/util/test'
 require 'tmpdir'
 
-class ExecTest < Test::Unit::TestCase
+class ExecTest < MiniTest::Test
   include Sass::Util::Test
 
   def setup
@@ -19,7 +19,7 @@ class ExecTest < Test::Unit::TestCase
     src = get_path("src.scss")
     dest = get_path("dest.css")
     write(src, ".ruleset { margin: 0 }")
-    assert(exec(*%w[scss -t expanded --unix-newlines].push(src, dest)))
+    assert(exec(*%w[scss --sourcemap=none -t expanded --unix-newlines].push(src, dest)))
     assert_equal(".ruleset {\n  margin: 0;\n}\n", read(dest))
   end
 

data/test/sass/extend_test.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../test_helper'
 
-class ExtendTest < Test::Unit::TestCase
+class ExtendTest < MiniTest::Test
   def test_basic
     assert_equal <<CSS, render(<<SCSS)
 .foo, .bar {
@@ -310,9 +310,183 @@ SCSS
   end
 
   def test_negation_unification
-    assert_unification ':not(.foo).baz', ':not(.bar) {@extend .baz}', ':not(.foo).baz, :not(.foo):not(.bar)'
-    assert_unification ':not(.foo).baz', ':not(.foo) {@extend .baz}', ':not(.foo)'
-    assert_unification ':not([a=b]).baz', ':not([a = b]) {@extend .baz}', ':not([a=b])'
+    assert_extends ':not(.foo).baz', ':not(.bar) {@extend .baz}', ':not(.foo).baz, :not(.foo):not(.bar)'
+    # Unifying to :not(.foo) here would reduce the specificity of the original selector.
+    assert_extends ':not(.foo).baz', ':not(.foo) {@extend .baz}', ':not(.foo).baz, :not(.foo)'
+  end
+
+  def test_prefixed_pseudoclass_unification
+    assert_unification(
+      ':nth-child(2n+1 of .foo).baz',
+      ':nth-child(2n of .foo) {@extend .baz}',
+      ':nth-child(2n+1 of .foo).baz, :nth-child(2n+1 of .foo):nth-child(2n of .foo)')
+
+    assert_unification(
+      ':nth-child(2n+1 of .foo).baz',
+      ':nth-child(2n+1 of .bar) {@extend .baz}',
+      ':nth-child(2n+1 of .foo).baz, :nth-child(2n+1 of .foo):nth-child(2n+1 of .bar)')
+
+    assert_unification(
+      ':nth-child(2n+1 of .foo).baz',
+      ':nth-child(2n+1 of .foo) {@extend .baz}',
+      ':nth-child(2n+1 of .foo)')
+  end
+
+  def test_extend_into_not
+    assert_extends(':not(.foo)', '.x {@extend .foo}', ':not(.foo, .x)')
+    assert_extends(':not(.foo.bar)', '.x {@extend .bar}', ':not(.foo.bar, .foo.x)')
+    assert_extends(
+      ':not(.foo.bar, .baz.bar)',
+      '.x {@extend .bar}',
+      ':not(.foo.bar, .foo.x, .baz.bar, .baz.x)')
+  end
+
+  def test_extend_into_mergeable_pseudoclasses
+    assert_extends(':matches(.foo)', '.x {@extend .foo}', ':matches(.foo, .x)')
+    assert_extends(':matches(.foo.bar)', '.x {@extend .bar}', ':matches(.foo.bar, .foo.x)')
+    assert_extends(
+      ':matches(.foo.bar, .baz.bar)',
+      '.x {@extend .bar}',
+      ':matches(.foo.bar, .foo.x, .baz.bar, .baz.x)')
+
+    assert_extends(':-moz-any(.foo)', '.x {@extend .foo}', ':-moz-any(.foo, .x)')
+    assert_extends(':current(.foo)', '.x {@extend .foo}', ':current(.foo, .x)')
+    assert_extends(':has(.foo)', '.x {@extend .foo}', ':has(.foo, .x)')
+    assert_extends(':host(.foo)', '.x {@extend .foo}', ':host(.foo, .x)')
+    assert_extends(':host-context(.foo)', '.x {@extend .foo}', ':host-context(.foo, .x)')
+    assert_extends(':nth-child(n of .foo)', '.x {@extend .foo}', ':nth-child(n of .foo, .x)')
+    assert_extends(
+      ':nth-last-child(n of .foo)',
+      '.x {@extend .foo}',
+      ':nth-last-child(n of .foo, .x)')
+  end
+
+  def test_complex_extend_into_pseudoclass
+    assert_extends(':not(.bar)', '.x .y {@extend .bar}', ':not(.bar, .x .y)')
+    assert_extends(':matches(.bar)', '.x .y {@extend .bar}', ':matches(.bar, .x .y)')
+    assert_extends(':current(.bar)', '.x .y {@extend .bar}', ':current(.bar, .x .y)')
+    assert_extends(':has(.bar)', '.x .y {@extend .bar}', ':has(.bar, .x .y)')
+    assert_extends(':host(.bar)', '.x .y {@extend .bar}', ':host(.bar, .x .y)')
+    assert_extends(':host-context(.bar)', '.x .y {@extend .bar}', ':host-context(.bar, .x .y)')
+    assert_extends(
+      ':-moz-any(.bar)',
+      '.x .y {@extend .bar}',
+      ':-moz-any(.bar, .x .y)')
+    assert_extends(
+      ':nth-child(n of .bar)',
+      '.x .y {@extend .bar}',
+      ':nth-child(n of .bar, .x .y)')
+    assert_extends(
+      ':nth-last-child(n of .bar)',
+      '.x .y {@extend .bar}',
+      ':nth-last-child(n of .bar, .x .y)')
+  end
+
+  def test_extend_over_selector_pseudoclass
+    assert_extends(':not(.foo)', '.x {@extend :not(.foo)}', ':not(.foo), .x')
+    assert_extends(
+      ':matches(.foo, .bar)',
+      '.x {@extend :matches(.foo, .bar)}',
+      ':matches(.foo, .bar), .x')
+  end
+
+  def test_matches_within_not
+    assert_extends(
+      ':not(.foo, .bar)',
+      ':matches(.x, .y) {@extend .foo}',
+      ':not(.foo, .x, .y, .bar)')
+  end
+
+  def test_pseudoclasses_merge
+    assert_extends(':matches(.foo)', ':matches(.bar) {@extend .foo}', ':matches(.foo, .bar)')
+    assert_extends(':-moz-any(.foo)', ':-moz-any(.bar) {@extend .foo}', ':-moz-any(.foo, .bar)')
+    assert_extends(':current(.foo)', ':current(.bar) {@extend .foo}', ':current(.foo, .bar)')
+    assert_extends(
+      ':nth-child(n of .foo)',
+      ':nth-child(n of .bar) {@extend .foo}',
+      ':nth-child(n of .foo, .bar)')
+    assert_extends(
+      ':nth-last-child(n of .foo)',
+      ':nth-last-child(n of .bar) {@extend .foo}',
+      ':nth-last-child(n of .foo, .bar)')
+  end
+
+  def test_nesting_pseudoclasses_merge
+    assert_extends(':has(.foo)', ':has(.bar) {@extend .foo}', ':has(.foo, :has(.bar))')
+    assert_extends(':host(.foo)', ':host(.bar) {@extend .foo}', ':host(.foo, :host(.bar))')
+    assert_extends(
+      ':host-context(.foo)',
+      ':host-context(.bar) {@extend .foo}',
+      ':host-context(.foo, :host-context(.bar))')
+  end
+
+  def test_not_unifies_with_unique_values
+    assert_unification('foo', ':not(bar) {@extend foo}', ':not(bar)')
+    assert_unification('#foo', ':not(#bar) {@extend #foo}', ':not(#bar)')
+  end
+
+  def test_not_adds_no_specificity
+    assert_specificity_equals(':not(.foo)', '.foo')
+  end
+
+  def test_matches_has_a_specificity_range
+    # `:matches(.foo, #bar)` has minimum specificity equal to that of `.foo`,
+    # which means `:matches(.foo, #bar) .a` can have less specificity than
+    # `#b.a`. Thus the selector generated by `#b.a` should be preserved.
+    assert_equal <<CSS, render(<<SCSS)
+:matches(.foo, #bar) .a, :matches(.foo, #bar) #b.a {
+  a: b; }
+CSS
+:matches(.foo, #bar) %x {a: b}
+.a {@extend %x}
+#b.a {@extend %x}
+SCSS
+
+    # `:matches(.foo, #bar)` has maximum specificity equal to that of `#bar`,
+    # which means `:matches(.foo, #bar).b` can have greater specificity than `.a
+    # .b`. Thus the selector generated by `:matches(.foo, #bar).b` should be
+    # preserved.
+    assert_equal <<CSS, render(<<SCSS)
+.a .b, .a .b:matches(.foo, #bar) {
+  a: b; }
+CSS
+.a %x {a: b}
+.b {@extend %x}
+.b:matches(.foo, #bar) {@extend %x}
+SCSS
+  end
+
+  def test_extend_into_not_and_normal_extend
+    assert_equal <<CSS, render(<<SCSS)
+.x:not(.y, .bar), .foo:not(.y, .bar) {
+  a: b; }
+CSS
+.x:not(.y) {a: b}
+.foo {@extend .x}
+.bar {@extend .y}
+SCSS
+  end
+
+  def test_extend_into_matches_and_normal_extend
+    assert_equal <<CSS, render(<<SCSS)
+.x:matches(.y, .bar), .foo:matches(.y, .bar) {
+  a: b; }
+CSS
+.x:matches(.y) {a: b}
+.foo {@extend .x}
+.bar {@extend .y}
+SCSS
+  end
+
+  def test_multilayer_pseudoclass_extend
+    assert_equal <<CSS, render(<<SCSS)
+:matches(.x, .foo, .bar) {
+  a: b; }
+CSS
+:matches(.x) {a: b}
+.foo {@extend .x}
+.bar {@extend .foo}
+SCSS
   end
 
   def test_comma_extendee
@@ -516,7 +690,7 @@ SCSS
   end
 
   def test_nested_extender_with_trailing_child_selector
-    assert_raise(Sass::SyntaxError, "bar > can't extend: invalid selector") do
+    assert_raises(Sass::SyntaxError, "bar > can't extend: invalid selector") do
       render("bar > {@extend .baz}")
     end
   end
@@ -650,10 +824,10 @@ SCSS
 
   def test_basic_extend_loop
     assert_equal <<CSS, render(<<SCSS)
-.bar, .foo {
+.foo, .bar {
   a: b; }
 
-.foo, .bar {
+.bar, .foo {
   c: d; }
 CSS
 .foo {a: b; @extend .bar}
@@ -663,13 +837,13 @@ SCSS
 
   def test_three_level_extend_loop
     assert_equal <<CSS, render(<<SCSS)
-.baz, .bar, .foo {
+.foo, .baz, .bar {
   a: b; }
 
-.foo, .baz, .bar {
+.bar, .foo, .baz {
   c: d; }
 
-.bar, .foo, .baz {
+.baz, .bar, .foo {
   e: f; }
 CSS
 .foo {a: b; @extend .bar}
@@ -692,6 +866,18 @@ CSS
 SCSS
   end
 
+  def test_cross_loop
+    # The first law of extend means the selector should stick around.
+    assert_equal <<CSS, render(<<SCSS)
+.foo.bar, .foo, .bar {
+  a: b; }
+CSS
+.foo.bar {a: b}
+.foo {@extend .bar}
+.bar {@extend .foo}
+SCSS
+  end
+
   def test_multiple_extender_merges_with_superset_selector
     assert_equal <<CSS, render(<<SCSS)
 a.bar.baz, a.foo {
@@ -830,6 +1016,17 @@ $foo: foo;
 SCSS
   end
 
+  def test_placeholder_in_selector_pseudoclass
+    assert_equal <<CSS, render(<<SCSS)
+:matches(.bar, .baz) {
+  color: blue; }
+CSS
+:matches(%foo) {color: blue}
+.bar {@extend %foo}
+.baz {@extend %foo}
+SCSS
+  end
+
   def test_media_in_placeholder_selector
     assert_equal <<CSS, render(<<SCSS)
 .baz {
@@ -1005,7 +1202,7 @@ SCSS
   end
 
   def test_extend_with_subject_transfers_subject_to_extender
-    assert_equal(<<CSS, render(<<SCSS))
+    silence_warnings {assert_equal(<<CSS, render(<<SCSS))}
 foo bar! baz, foo .bip .bap! baz, .bip foo .bap! baz {
   a: b; }
 CSS
@@ -1013,7 +1210,7 @@ foo bar! baz {a: b}
 .bip .bap {@extend bar}
 SCSS
 
-    assert_equal(<<CSS, render(<<SCSS))
+    silence_warnings {assert_equal(<<CSS, render(<<SCSS))}
 foo.x bar.y! baz.z, foo.x .bip bar.bap! baz.z, .bip foo.x bar.bap! baz.z {
   a: b; }
 CSS
@@ -1023,7 +1220,7 @@ SCSS
   end
 
   def test_extend_with_subject_retains_subject_on_target
-    assert_equal(<<CSS, render(<<SCSS))
+    silence_warnings {assert_equal(<<CSS, render(<<SCSS))}
 .foo! .bar, .foo! .bip .bap, .bip .foo! .bap {
   a: b; }
 CSS
@@ -1033,7 +1230,7 @@ SCSS
   end
 
   def test_extend_with_subject_transfers_subject_to_target
-    assert_equal(<<CSS, render(<<SCSS))
+    silence_warnings {assert_equal(<<CSS, render(<<SCSS))}
 a.foo .bar, .bip a.bap! .bar {
   a: b; }
 CSS
@@ -1043,7 +1240,7 @@ SCSS
   end
 
   def test_extend_with_subject_retains_subject_on_extender
-    assert_equal(<<CSS, render(<<SCSS))
+    silence_warnings {assert_equal(<<CSS, render(<<SCSS))}
 .foo .bar, .foo .bip! .bap, .bip! .foo .bap {
   a: b; }
 CSS
@@ -1053,7 +1250,7 @@ SCSS
   end
 
   def test_extend_with_subject_fails_with_conflicting_subject
-    assert_equal(<<CSS, render(<<SCSS))
+    silence_warnings {assert_equal(<<CSS, render(<<SCSS))}
 x! .bar {
   a: b; }
 CSS
@@ -1408,7 +1605,7 @@ Use "@extend #{target} !optional" if the extend should be able to fail.
 ERR
   end
 
-  def assert_unification(selector, extension, unified)
+  def assert_unification(selector, extension, unified, nested = true)
     # Do some trickery so the first law of extend doesn't get in our way.
     assert_extends(
       "%-a #{selector}",
@@ -1416,6 +1613,22 @@ ERR
       unified.split(', ').map {|s| "-a #{s}"}.join(', '))
   end
 
+  def assert_specificity_equals(sel1, sel2)
+    assert_specificity_gte(sel1, sel2)
+    assert_specificity_gte(sel2, sel1)
+  end
+
+  def assert_specificity_gte(sel1, sel2)
+    assert_equal <<CSS, render(<<SCSS)
+#{sel1} .a {
+  a: b; }
+CSS
+#{sel1} %-a {a: b}
+.a {@extend %-a}
+#{sel2}.a {@extend %-a}
+SCSS
+  end
+
   def render_unification(selector, extension)
     render_extends(
       "%-a #{selector}",
@@ -1429,6 +1642,10 @@ ERR
 CSS
   end
 
+  def assert_extends_to_nothing(selector, extension)
+    assert_equal '', render_extends(selector, extension)
+  end
+
   def render_extends(selector, extension)
     render(<<SCSS)
 #{selector} {a: b}

data/test/sass/functions_test.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-require 'test/unit'
+require 'minitest/autorun'
 require File.dirname(__FILE__) + '/../test_helper'
 require File.dirname(__FILE__) + '/test_helper'
 require 'sass/script'
@@ -19,6 +19,12 @@ module Sass::Script::Functions
     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
+
+  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
@@ -45,7 +51,7 @@ module Sass::Script::Functions
   include Sass::Script::Functions::UserFunctions
 end
 
-class SassFunctionTest < Test::Unit::TestCase
+class SassFunctionTest < MiniTest::Test
   # 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
@@ -123,12 +129,6 @@ class SassFunctionTest < Test::Unit::TestCase
     assert_equal("50%",  evaluate("percentage($number: 0.5)"))
   end
 
-  def test_percentage_deprecated_arg_name
-    assert_warning(<<WARNING) {assert_equal("50%", evaluate("percentage($value: 0.5)"))}
-DEPRECATION WARNING: The `$value' argument for `percentage()' has been renamed to `$number'.
-WARNING
-  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)")
@@ -142,12 +142,6 @@ WARNING
     assert_equal("5px", evaluate("round($number: 5.49px)"))
   end
 
-  def test_round_deprecated_arg_name
-    assert_warning(<<WARNING) {assert_equal("5px", evaluate("round($value: 5.49px)"))}
-DEPRECATION WARNING: The `$value' argument for `round()' has been renamed to `$number'.
-WARNING
-  end
-
   def test_round_checks_types
     assert_error_message("$value: #cccccc is not a number for `round'", "round(#ccc)")
   end
@@ -158,12 +152,6 @@ WARNING
     assert_equal("4px", evaluate("floor($number: 4.8px)"))
   end
 
-  def test_floor_deprecated_arg_name
-    assert_warning(<<WARNING) {assert_equal("4px", evaluate("floor($value: 4.8px)"))}
-DEPRECATION WARNING: The `$value' argument for `floor()' has been renamed to `$number'.
-WARNING
-  end
-
   def test_floor_checks_types
     assert_error_message("$value: \"foo\" is not a number for `floor'", "floor(\"foo\")")
   end
@@ -174,12 +162,6 @@ WARNING
     assert_equal("5px", evaluate("ceil($number: 4.8px)"))
   end
 
-  def test_ceil_deprecated_arg_name
-    assert_warning(<<WARNING) {assert_equal("5px", evaluate("ceil($value: 4.8px)"))}
-DEPRECATION WARNING: The `$value' argument for `ceil()' has been renamed to `$number'.
-WARNING
-  end
-
   def test_ceil_checks_types
     assert_error_message("$value: \"a\" is not a number for `ceil'", "ceil(\"a\")")
   end
@@ -192,12 +174,6 @@ WARNING
     assert_equal("5px", evaluate("abs($number: 5px)"))
   end
 
-  def test_abs_deprecated_arg_name
-    assert_warning(<<WARNING) {assert_equal("5px", evaluate("abs($value: 5px)"))}
-DEPRECATION WARNING: The `$value' argument for `abs()' has been renamed to `$number'.
-WARNING
-  end
-
   def test_abs_checks_types
     assert_error_message("$value: #aaaaaa is not a number for `abs'", "abs(#aaa)")
   end
@@ -840,32 +816,6 @@ WARNING
     assert_equal("rgba(255, 0, 0, 0)", evaluate("mix($color1: transparentize(#f00, 1), $color2: #00f, $weight: 100%)"))
   end
 
-  def test_mix_deprecated_arg_name
-    assert_warning <<WARNING do
-DEPRECATION WARNING: The `$color-1' argument for `mix()' has been renamed to `$color1'.
-DEPRECATION WARNING: The `$color-2' argument for `mix()' has been renamed to `$color2'.
-WARNING
-      assert_equal("rgba(255, 0, 0, 0)",
-        evaluate("mix($color-1: transparentize(#f00, 1), $color-2: #00f, $weight: 100%)"))
-    end
-
-    assert_warning <<WARNING do
-DEPRECATION WARNING: The `$color-1' argument for `mix()' has been renamed to `$color1'.
-DEPRECATION WARNING: The `$color-2' argument for `mix()' has been renamed to `$color2'.
-WARNING
-      assert_equal("rgba(0, 0, 255, 0.5)",
-        evaluate("mix($color-1: transparentize(#f00, 1), $color-2: #00f)"))
-    end
-
-    assert_warning <<WARNING do
-DEPRECATION WARNING: The `$color_1' argument for `mix()' has been renamed to `$color1'.
-DEPRECATION WARNING: The `$color_2' argument for `mix()' has been renamed to `$color2'.
-WARNING
-      assert_equal("rgba(0, 0, 255, 0.5)",
-        evaluate("mix($color_1: transparentize(#f00, 1), $color_2: #00f)"))
-    end
-  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%)")
@@ -995,7 +945,6 @@ WARNING
     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
@@ -1085,22 +1034,6 @@ MSG
     assert_equal(%Q{false}, evaluate("comparable($number1: 100px, $number2: 3em)"))
   end
 
-  def test_comparable_deprecated_arg_name
-    assert_warning <<WARNING do
-DEPRECATION WARNING: The `$number-1' argument for `comparable()' has been renamed to `$number1'.
-DEPRECATION WARNING: The `$number-2' argument for `comparable()' has been renamed to `$number2'.
-WARNING
-      assert_equal("false", evaluate("comparable($number-1: 100px, $number-2: 3em)"))
-    end
-
-    assert_warning <<WARNING do
-DEPRECATION WARNING: The `$number_1' argument for `comparable()' has been renamed to `$number1'.
-DEPRECATION WARNING: The `$number_2' argument for `comparable()' has been renamed to `$number2'.
-WARNING
-      assert_equal("false", evaluate("comparable($number_1: 100px, $number_2: 3em)"))
-    end
-  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)")
@@ -1258,76 +1191,17 @@ WARNING
   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("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(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("false", evaluate("index((foo: bar, bar: baz), (foo: bar))"))
-  end
-
-  def test_index_deprecation_warning
-    assert_warning(<<WARNING) do
-DEPRECATION WARNING: The return value of index() will change from "false" to
-"null" in future versions of Sass. For compatibility, avoid using "== false" on
-the return value. For example, instead of "@if index(...) == false", just write
-"@if not index(...)".
-WARNING
-      assert_equal("true", evaluate("index(1, 2 3 4) == false"))
-    end
-
-    assert_warning(<<WARNING) do
-DEPRECATION WARNING: The return value of index() will change from "false" to
-"null" in future versions of Sass. For compatibility, avoid using "!= null" on
-the return value.
-WARNING
-      assert_equal("true", evaluate("index(1, 2 3 4) != null"))
-    end
-
-    assert_warning(<<WARNING) do
-DEPRECATION WARNING: The return value of index() will change from "false" to
-"null" in future versions of Sass. For compatibility, avoid using "== false" on
-the return value. For example, instead of "@if index(...) == false", just write
-"@if not index(...)".
-WARNING
-      assert_equal("true", evaluate("false == index(1, 2 3 4)"))
-    end
-
-    assert_warning(<<WARNING) do
-DEPRECATION WARNING: The return value of index() will change from "false" to
-"null" in future versions of Sass. For compatibility, avoid using "!= null" on
-the return value.
-WARNING
-      assert_equal("true", evaluate("null != index(1, 2 3 4)"))
-    end
-  end
-
-  def test_index_deprecation_warning_is_only_emitted_once_per_call
-    assert_warning(<<WARNING) do
-DEPRECATION WARNING: The return value of index() will change from "false" to
-"null" in future versions of Sass. For compatibility, avoid using "== false" on
-the return value. For example, instead of "@if index(...) == false", just write
-"@if not index(...)".
-        on line 3 of test_index_deprecation_warning_is_only_emitted_once_per_call_inline.scss
-DEPRECATION WARNING: The return value of index() will change from "false" to
-"null" in future versions of Sass. For compatibility, avoid using "== false" on
-the return value. For example, instead of "@if index(...) == false", just write
-"@if not index(...)".
-        on line 6 of test_index_deprecation_warning_is_only_emitted_once_per_call_inline.scss
-WARNING
-      render(<<SCSS)
-@for $i from 1 to 10 {
-  $var1: index(1, 2 3 4);
-  $var2: $var1 == false;
-  $var3: $var1 != null;
-}
-$var4: index(1, 2 3 4) == false;
-SCSS
-    end
+    assert_equal(null, perform("index((foo: bar, bar: baz), (foo: bar))"))
   end
 
   def test_list_separator
@@ -1447,7 +1321,7 @@ SCSS
     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
+      refute_equal last_id, current_id
     end
   end
 
@@ -1458,16 +1332,6 @@ SCSS
     assert_equal "null", perform("map-get((), foo)").to_sass
   end
 
-  def test_map_get_deprecation_warning
-    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_get_checks_type
     assert_error_message("$map: 12 is not a map for `map-get'", "map-get(12, bar)")
   end
@@ -1481,26 +1345,6 @@ WARNING
       perform("map-merge((foo: 1, bar: 2), ())").to_sass)
   end
 
-  def test_map_merge_deprecation_warning
-    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_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)")
@@ -1509,18 +1353,12 @@ WARNING
   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)
-  end
-
-  def test_map_remove_deprecation_warning
-    assert_warning(<<WARNING) do
-DEPRECATION WARNING: Passing lists of pairs to map-remove 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, baz: 3)",
-        perform("map-remove((foo 1, bar 2, baz 3), bar)").to_sass)
-    end
+    assert_equal("()", perform("map-remove((), foo, bar)").to_sass)
   end
 
   def test_map_remove_checks_type
@@ -1533,17 +1371,6 @@ WARNING
     assert_equal("()", perform("map-keys(())").to_sass)
   end
 
-  def test_map_keys_deprecation_warning
-    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_keys_checks_type
     assert_error_message("$map: 12 is not a map for `map-keys'", "map-keys(12)")
   end
@@ -1555,16 +1382,6 @@ WARNING
     assert_equal("()", perform("map-values(())").to_sass)
   end
 
-  def test_map_values_deprecation_warning
-    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_values_checks_type
     assert_error_message("$map: 12 is not a map for `map-values'", "map-values(12)")
   end
@@ -1575,16 +1392,6 @@ WARNING
     assert_equal "false", evaluate("map-has-key((), foo)")
   end
 
-  def test_map_has_key_deprecation_warning
-    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_map_has_key_checks_type
     assert_error_message("$map: 12 is not a map for `map-has-key'", "map-has-key(12, foo)")
   end
@@ -1839,7 +1646,255 @@ SCSS
     if Sass::Script::Functions.instance_variable_defined?("@random_number_generator")
       Sass::Script::Functions.send(:remove_instance_variable, "@random_number_generator")
     end
-    assert_not_equal evaluate("random()"), evaluate("random()")
+    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