oreorenasass 3.4.4 → 3.4.5

data/test/sass/scss/css_test.rb

@@ -6,7 +6,7 @@ require 'sass/scss/css_parser'
 # These tests just test the parsing of CSS
 # (both standard and any hacks we intend to support).
 # Tests of SCSS-specific behavior go in scss_test.rb.
-class ScssCssTest < MiniTest::Test
+class ScssCssTest < Test::Unit::TestCase
   include ScssTestHelper
 
   def test_basic_scss
@@ -94,7 +94,7 @@ foo {a /*: b; c */: d}
 SCSS
   end
 
-  def test_crazy_comments
+  def test_crazy_comments 
     # http://www.w3.org/Style/CSS/Test/CSS2.1/current/xhtml1/t040109-c17-comments-00-b.xht
     assert_equal <<CSS, render(<<SCSS)
 /* This is a CSS comment. */
@@ -499,24 +499,10 @@ SCSS
 
   def test_import_directive
     assert_parses '@import "foo.css";'
+    assert_parses "@import 'foo.css';"
     assert_parses '@import url("foo.css");'
     assert_parses "@import url('foo.css');"
     assert_parses '@import url(foo.css);'
-
-    assert_equal <<CSS, render(<<SCSS)
-@import "foo.css";
-CSS
-@import 'foo.css';
-SCSS
-  end
-
-  def test_import_directive_with_backslash_newline
-    assert_equal <<CSS, render(<<SCSS)
-@import "foobar.css";
-CSS
-@import "foo\\
-bar.css";
-SCSS
   end
 
   def test_string_import_directive_with_media
@@ -587,6 +573,7 @@ SCSS
     assert_parses <<SCSS
 @foo bar {
   a: b; }
+
 @bar baz {
   c: d; }
 SCSS
@@ -606,6 +593,7 @@ SCSS
     assert_equal <<CSS, render(<<SCSS)
 @foo {
   a: b; }
+
 @bar {
   a: b; }
 CSS
@@ -667,40 +655,15 @@ CSS
 SCSS
   end
 
-  def test_keyframes
-    assert_equal <<CSS, render(<<SCSS)
-@keyframes identifier {
-  0% {
-    top: 0;
-    left: 0; }
-  30% {
-    top: 50px; }
-  68%, 72% {
-    left: 50px; }
-  100% {
-    top: 100px;
-    left: 100%; } }
-CSS
-@keyframes identifier {
-  0% {top: 0; left: 0}
-  30% {top: 50px}
-  68%, 72% {left: 50px}
-  100% {top: 100px; left: 100%}
-}
-SCSS
-  end
-
   ## Selectors
 
   # Taken from http://dev.w3.org/csswg/selectors4/#overview
-  def test_summarized_selectors_with_element
+  def test_summarized_selectors
     assert_selector_parses('*')
     assert_selector_parses('E')
     assert_selector_parses('E:not(s)')
     assert_selector_parses('E:not(s1, s2)')
     assert_selector_parses('E:matches(s1, s2)')
-    assert_selector_parses('E:has(s1, s2)')
-    assert_selector_parses('E:has(> s1, > s2)')
     assert_selector_parses('E.warning')
     assert_selector_parses('E#myid')
     assert_selector_parses('E[foo]')
@@ -751,22 +714,20 @@ SCSS
     assert_selector_parses('E:last-of-type')
     assert_selector_parses('E:nth-last-of-type(n)')
     assert_selector_parses('E:only-of-type')
-    assert_selector_parses('E:nth-child(n of selector)')
-    assert_selector_parses('E:nth-last-child(n of selector)')
-    assert_selector_parses('E:nth-child(n)')
-    assert_selector_parses('E:nth-last-child(n)')
+    assert_selector_parses('E:nth-match(n of selector)')
+    assert_selector_parses('E:nth-last-match(n of selector)')
+    assert_selector_parses('E:column(selector)')
+    assert_selector_parses('E:nth-column(n)')
+    assert_selector_parses('E:nth-last-column(n)')
     assert_selector_parses('E F')
     assert_selector_parses('E > F')
     assert_selector_parses('E + F')
     assert_selector_parses('E ~ F')
     assert_selector_parses('E /foo/ F')
-    silence_warnings {assert_selector_parses('E! > F')}
+    assert_selector_parses('E! > F')
 
     assert_selector_parses('E /ns|foo/ F')
-
-    # From http://dev.w3.org/csswg/css-scoping-1/
-    assert_selector_parses('E:host(s)')
-    assert_selector_parses('E:host-context(s)')
+    assert_selector_parses('E /*|foo/ F')
   end
 
   # Taken from http://dev.w3.org/csswg/selectors4/#overview, but without element
@@ -775,8 +736,6 @@ SCSS
     assert_selector_parses(':not(s)')
     assert_selector_parses(':not(s1, s2)')
     assert_selector_parses(':matches(s1, s2)')
-    assert_selector_parses(':has(s1, s2)')
-    assert_selector_parses(':has(> s1, > s2)')
     assert_selector_parses('.warning')
     assert_selector_parses('#myid')
     assert_selector_parses('[foo]')
@@ -827,14 +786,11 @@ SCSS
     assert_selector_parses(':last-of-type')
     assert_selector_parses(':nth-last-of-type(n)')
     assert_selector_parses(':only-of-type')
-    assert_selector_parses(':nth-child(n of selector)')
-    assert_selector_parses(':nth-last-child(n of selector)')
-    assert_selector_parses(':nth-child(n)')
-    assert_selector_parses(':nth-last-child(n)')
-
-    # From http://dev.w3.org/csswg/css-scoping-1/
-    assert_selector_parses(':host(s)')
-    assert_selector_parses(':host-context(s)')
+    assert_selector_parses(':nth-match(n of selector)')
+    assert_selector_parses(':nth-last-match(n of selector)')
+    assert_selector_parses(':column(selector)')
+    assert_selector_parses(':nth-column(n)')
+    assert_selector_parses(':nth-last-column(n)')
   end
 
   def test_attribute_selectors_with_identifiers
@@ -874,18 +830,15 @@ SCSS
   def test_selectors_containing_selectors
     assert_selector_can_contain_selectors(':not(<sel>)')
     assert_selector_can_contain_selectors(':current(<sel>)')
-    assert_selector_can_contain_selectors(':nth-child(n of <sel>)')
-    assert_selector_can_contain_selectors(':nth-last-child(n of <sel>)')
+    assert_selector_can_contain_selectors(':nth-match(n of <sel>)')
+    assert_selector_can_contain_selectors(':nth-last-match(n of <sel>)')
+    assert_selector_can_contain_selectors(':column(<sel>)')
     assert_selector_can_contain_selectors(':-moz-any(<sel>)')
-    assert_selector_can_contain_selectors(':has(<sel>)')
-    assert_selector_can_contain_selectors(':has(+ <sel>)')
-    assert_selector_can_contain_selectors(':host(<sel>)')
-    assert_selector_can_contain_selectors(':host-context(<sel>)')
   end
 
   def assert_selector_can_contain_selectors(sel)
     try = lambda {|subsel| assert_selector_parses(sel.gsub('<sel>', subsel))}
-
+    
     try['foo|bar']
     try['*|bar']
 
@@ -937,11 +890,11 @@ SCSS
   end
 
   def test_expression_fallback_selectors
-    assert_directive_parses('0%')
-    assert_directive_parses('60%')
-    assert_directive_parses('100%')
-    assert_directive_parses('12px')
-    assert_directive_parses('"foo"')
+    assert_selector_parses('0%')
+    assert_selector_parses('60%')
+    assert_selector_parses('100%')
+    assert_selector_parses('12px')
+    assert_selector_parses('"foo"')
   end
 
   def test_functional_pseudo_selectors
@@ -978,29 +931,6 @@ SCSS
     assert_equal "E + F {\n  a: b; }\n", render("E+F { a: b;} ")
   end
 
-  def test_subject_selector_deprecation
-    assert_warning(<<WARNING) {render(".foo .bar! .baz {a: b}")}
-DEPRECATION WARNING on line 1, column 1:
-The subject selector operator "!" is deprecated and will be removed in a future release.
-This operator has been replaced by ":has()" in the CSS spec.
-For example: .foo .bar:has(.baz)
-WARNING
-
-    assert_warning(<<WARNING) {render(".foo .bar! > .baz {a: b}")}
-DEPRECATION WARNING on line 1, column 1:
-The subject selector operator "!" is deprecated and will be removed in a future release.
-This operator has been replaced by ":has()" in the CSS spec.
-For example: .foo .bar:has(> .baz)
-WARNING
-
-    assert_warning(<<WARNING) {render(".foo .bar! {a: b}")}
-DEPRECATION WARNING on line 1, column 1:
-The subject selector operator "!" is deprecated and will be removed in a future release.
-This operator has been replaced by ":has()" in the CSS spec.
-For example: .foo .bar
-WARNING
-  end
-
   ## Errors
 
   def test_invalid_directives
@@ -1086,41 +1016,8 @@ SCSS
     assert_equal 1, e.sass_line
   end
 
-  def test_newline_in_property_value
-    assert_equal(<<CSS, render(<<SCSS))
-.foo {
-  bar: "bazbang"; }
-CSS
-.foo {
-  bar: "baz\\
-bang";
-}
-SCSS
-  end
-
   ## Regressions
 
-  def test_very_long_comment_doesnt_take_forever
-    string = 'asdf' * (100000)
-    assert_equal(<<CSS, render(<<SCSS))
-/*
-  #{string}
-*/
-CSS
-/*
-  #{string}
-*/
-SCSS
-  end
-
-  def test_long_unclosed_comment_doesnt_take_forever
-    assert_raise_message(Sass::SyntaxError,
-      'Invalid CSS after "/*": expected "/", was "//*************..."') {render(<<SCSS)}
-/*
-//**************************************************************************
-SCSS
-  end
-
   def test_double_space_string
     assert_equal(<<CSS, render(<<SCSS))
 .a {
@@ -1193,22 +1090,10 @@ SCSS
 #{selector} {
   a: b; }
 SCSS
-
-    assert_parses <<SCSS
-:not(#{selector}) {
-  a: b; }
-SCSS
-  end
-
-  def assert_directive_parses(param)
-    assert_parses <<SCSS
-@keyframes #{param} {
-  a: b; }
-SCSS
   end
 
   def render(scss, options = {})
-    tree = Sass::SCSS::CssParser.new(scss, options[:filename], nil).parse
+    tree = Sass::SCSS::CssParser.new(scss, options[:filename]).parse
     tree.options = Sass::Engine::DEFAULT_OPTIONS.merge(options)
     tree.render
   end

data/test/sass/scss/rx_test.rb

@@ -3,7 +3,7 @@
 require File.dirname(__FILE__) + '/../../test_helper'
 require 'sass/engine'
 
-class ScssRxTest < MiniTest::Test
+class ScssRxTest < Test::Unit::TestCase
   include Sass::SCSS::RX
 
   def test_identifiers
@@ -26,7 +26,6 @@ class ScssRxTest < MiniTest::Test
     assert_match IDENT, "_foo" # Can put a _ before anything
     assert_match IDENT, "_\xC3\xBFoo"
     assert_match IDENT, "_\\f oo"
-    assert_match IDENT, "--foo" # "Custom" identifier
 
     assert_match IDENT, "foo-bar"
     assert_match IDENT, "f012-23"
@@ -60,6 +59,7 @@ class ScssRxTest < MiniTest::Test
     assert_no_match IDENT, ""
     assert_no_match IDENT, "1foo"
     assert_no_match IDENT, "-1foo"
+    assert_no_match IDENT, "--foo"
     assert_no_match IDENT, "foo bar"
     assert_no_match IDENT, "foo~bar"
 
@@ -144,13 +144,13 @@ class ScssRxTest < MiniTest::Test
   private
 
   def assert_match(rx, str)
-    refute_nil(match = rx.match(str))
+    assert_not_nil(match = rx.match(str))
     assert_equal str.size, match[0].size
   end
 
   def assert_no_match(rx, str)
     match = rx.match(str)
-    refute_equal str.size, match && match[0].size
+    assert_not_equal str.size, match && match[0].size
   end
 
 end

data/test/sass/scss/scss_test.rb

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 require File.dirname(__FILE__) + '/test_helper'
 
-class ScssTest < MiniTest::Test
+class ScssTest < Test::Unit::TestCase
   include ScssTestHelper
 
   ## One-Line Comments
@@ -115,14 +115,6 @@ SCSS
     end
   end
 
-  def test_error_directive
-    assert_raise_message(Sass::SyntaxError, "hello world!") {render(<<SCSS)}
-foo {a: b}
-@error "hello world!";
-bar {c: d}
-SCSS
-  end
-
   def test_warn_directive
     expected_warning = <<EXPECTATION
 WARNING: this is a warning
@@ -171,51 +163,6 @@ CSS
 SCSS
   end
 
-  def test_for_directive_with_same_start_and_end
-    assert_equal <<CSS, render(<<SCSS)
-CSS
-.foo {
-  @for $var from 1 to 1 {a: $var;}
-}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  a: 1; }
-CSS
-.foo {
-  @for $var from 1 through 1 {a: $var;}
-}
-SCSS
-  end
-
-  def test_decrementing_estfor_directive
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  a: 5;
-  a: 4;
-  a: 3;
-  a: 2;
-  a: 1; }
-CSS
-.foo {
-  @for $var from 5 through 1 {a: $var;}
-}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  a: 5;
-  a: 4;
-  a: 3;
-  a: 2; }
-CSS
-.foo {
-  @for $var from 5 to 1 {a: $var;}
-}
-SCSS
-  end
-
   def test_if_directive
     assert_equal <<CSS, render(<<SCSS)
 foo {
@@ -282,7 +229,7 @@ $i: 1;
 .foo {
   @while $i != 5 {
     a: $i;
-    $i: $i + 1 !global;
+    $i: $i + 1;
   }
 }
 SCSS
@@ -315,31 +262,6 @@ c {
 SCSS
   end
 
-  def test_destructuring_each_directive
-    assert_equal <<CSS, render(<<SCSS)
-a {
-  foo: 1px;
-  bar: 2px;
-  baz: 3px; }
-
-c {
-  foo: "Value is bar";
-  bar: "Value is baz";
-  bang: "Value is "; }
-CSS
-a {
-  @each $name, $number in (foo: 1px, bar: 2px, baz: 3px) {
-    \#{$name}: $number;
-  }
-}
-c {
-  @each $key, $value in (foo bar) (bar, baz) bang {
-    \#{$key}: "Value is \#{$value}";
-  }
-}
-SCSS
-  end
-
   def test_css_import_directive
     assert_equal "@import url(foo.css);\n", render('@import "foo.css";')
     assert_equal "@import url(foo.css);\n", render("@import 'foo.css';")
@@ -544,17 +466,11 @@ foo :baz {
   c: d; }
 foo bang:bop {
   e: f; }
-foo ::qux {
-  g: h; }
-foo zap::fblthp {
-  i: j; }
 CSS
 foo {
   .bar {a: b}
   :baz {c: d}
-  bang:bop {e: f}
-  ::qux {g: h}
-  zap::fblthp {i: j}}
+  bang:bop {e: f}}
 SCSS
   end
 
@@ -659,7 +575,7 @@ SCSS
   end
 
   def test_parent_selector_with_subject
-    silence_warnings {assert_equal <<CSS, render(<<SCSS)}
+    assert_equal <<CSS, render(<<SCSS)
 bar foo.baz! .bip {
   a: b; }
 
@@ -674,47 +590,6 @@ foo bar {
 SCSS
   end
 
-  def test_parent_selector_with_suffix
-    assert_equal <<CSS, render(<<SCSS)
-.foo-bar {
-  a: b; }
-.foo_bar {
-  c: d; }
-.foobar {
-  e: f; }
-.foo123 {
-  e: f; }
-
-:hover-suffix {
-  g: h; }
-CSS
-.foo {
-  &-bar {a: b}
-  &_bar {c: d}
-  &bar {e: f}
-  &123 {e: f}
-}
-
-:hover {
-  &-suffix {g: h}
-}
-SCSS
-  end
-
-  def test_unknown_directive_bubbling
-    assert_equal(<<CSS, render(<<SCSS, :style => :nested))
-@fblthp {
-  .foo .bar {
-    a: b; } }
-CSS
-.foo {
-  @fblthp {
-    .bar {a: b}
-  }
-}
-SCSS
-  end
-
   ## Namespace Properties
 
   def test_namespace_properties
@@ -813,27 +688,18 @@ SCSS
   def test_no_namespace_properties_without_space_even_when_its_unambiguous
     render(<<SCSS)
 foo {
-  bar:baz calc(1 + 2) {
+  bar:1px {
     bip: bop }}
 SCSS
     assert(false, "Expected syntax error")
   rescue Sass::SyntaxError => e
-    assert_equal 'Invalid CSS after "bar:baz calc": expected selector, was "(1 + 2)"', e.message
+    assert_equal <<MESSAGE, e.message
+Invalid CSS: a space is required between a property and its definition
+when it has other properties nested beneath it.
+MESSAGE
     assert_equal 2, e.sass_line
   end
 
-  def test_namespace_properties_without_space_allowed_for_non_identifier
-    assert_equal <<CSS, render(<<SCSS)
-foo {
-  bar: 1px;
-    bar-bip: bop; }
-CSS
-foo {
-  bar:1px {
-    bip: bop }}
-SCSS
-  end
-
   ## Mixins
 
   def test_basic_mixins
@@ -926,33 +792,6 @@ CSS
 SCSS
   end
 
-  def test_keyframes_rules_in_content
-    assert_equal <<CSS, render(<<SCSS)
-@keyframes identifier {
-  0% {
-    top: 0;
-    left: 0; }
-  30% {
-    top: 50px; }
-  68%, 72% {
-    left: 50px; }
-  100% {
-    top: 100px;
-    left: 100%; } }
-CSS
-@mixin keyframes {
-  @keyframes identifier { @content }
-}
-
-@include keyframes {
-  0% {top: 0; left: 0}
-  \#{"30%"} {top: 50px}
-  68%, 72% {left: 50px}
-  100% {top: 100px; left: 100%}
-}
-SCSS
-  end
-
   ## Functions
 
   def test_basic_function
@@ -1142,2101 +981,579 @@ CSS
 SCSS
   end
 
-  def test_mixin_var_keyword_args
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  a: 1;
-  b: 2;
-  c: 3; }
-CSS
-@mixin foo($args...) {
-  a: map-get(keywords($args), a);
-  b: map-get(keywords($args), b);
-  c: map-get(keywords($args), c);
+  def test_mixin_var_args_with_keyword
+    assert_raise_message(Sass::SyntaxError, "Positional arguments must come before keyword arguments.") {render <<SCSS}
+@mixin foo($a, $b...) {
+  a: $a;
+  b: $b;
 }
 
-.foo {@include foo($a: 1, $b: 2, $c: 3)}
+.foo {@include foo($a: 1, 2, 3, 4)}
 SCSS
   end
 
-  def test_mixin_empty_var_keyword_args
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  length: 0; }
-CSS
-@mixin foo($args...) {
-  length: length(keywords($args));
+  def test_mixin_keyword_for_var_arg
+    assert_raise_message(Sass::SyntaxError, "Argument $b of mixin foo cannot be used as a named argument.") {render <<SCSS}
+@mixin foo($a, $b...) {
+  a: $a;
+  b: $b;
 }
 
-.foo {@include foo}
+.foo {@include foo(1, $b: 2 3 4)}
 SCSS
   end
 
-  def test_mixin_map_splat
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  a: 1;
-  b: 2;
-  c: 3; }
-CSS
-@mixin foo($a, $b, $c) {
+  def test_mixin_keyword_for_unknown_arg_with_var_args
+    assert_raise_message(Sass::SyntaxError, "Mixin foo doesn't have an argument named $c.") {render <<SCSS}
+@mixin foo($a, $b...) {
   a: $a;
   b: $b;
-  c: $c;
 }
 
-.foo {
-  $map: (a: 1, b: 2, c: 3);
-  @include foo($map...);
-}
+.foo {@include foo(1, $c: 2 3 4)}
 SCSS
   end
 
-  def test_mixin_map_and_list_splat
+  def test_function_var_args
     assert_equal <<CSS, render(<<SCSS)
 .foo {
-  a: x;
-  b: y;
-  c: z;
-  d: 1;
-  e: 2;
-  f: 3; }
-CSS
-@mixin foo($a, $b, $c, $d, $e, $f) {
-  a: $a;
-  b: $b;
-  c: $c;
-  d: $d;
-  e: $e;
-  f: $f;
+  val: "a: 1, b: 2, 3, 4"; }
+CSS
+@function foo($a, $b...) {
+  @return "a: \#{$a}, b: \#{$b}";
 }
 
-.foo {
-  $list: x y z;
-  $map: (d: 1, e: 2, f: 3);
-  @include foo($list..., $map...);
-}
+.foo {val: foo(1, 2, 3, 4)}
 SCSS
   end
 
-  def test_mixin_map_splat_takes_precedence_over_pass_through
+  def test_function_empty_var_args
     assert_equal <<CSS, render(<<SCSS)
 .foo {
-  a: 1;
-  b: 2;
-  c: z; }
+  val: "a: 1, b: 0"; }
 CSS
-@mixin foo($args...) {
-  $map: (c: z);
-  @include bar($args..., $map...);
-}
-
-@mixin bar($a, $b, $c) {
-  a: $a;
-  b: $b;
-  c: $c;
+@function foo($a, $b...) {
+  @return "a: \#{$a}, b: \#{length($b)}";
 }
 
-.foo {
-  @include foo(1, $b: 2, $c: 3);
-}
+.foo {val: foo(1)}
 SCSS
   end
 
-  def test_mixin_list_of_pairs_splat_treated_as_list
+  def test_function_var_args_act_like_list
     assert_equal <<CSS, render(<<SCSS)
 .foo {
-  a: a 1;
-  b: b 2;
-  c: c 3; }
+  val: "a: 3, b: 3"; }
 CSS
-@mixin foo($a, $b, $c) {
-  a: $a;
-  b: $b;
-  c: $c;
+@function foo($a, $b...) {
+  @return "a: \#{length($b)}, b: \#{nth($b, 2)}";
 }
 
-.foo {
-  @include foo((a 1, b 2, c 3)...);
-}
+.foo {val: foo(1, 2, 3, 4)}
 SCSS
   end
 
-  def test_mixin_splat_after_keyword_args
+  def test_function_splat_args
     assert_equal <<CSS, render(<<SCSS)
 .foo {
-  a: 1;
-  b: 2;
-  c: 3; }
+  val: "a: 1, b: 2, c: 3, d: 4"; }
 CSS
-@mixin foo($a, $b, $c) {
-  a: 1;
-  b: 2;
-  c: 3;
+@function foo($a, $b, $c, $d) {
+  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}, d: \#{$d}";
 }
 
-.foo {
-  @include foo(1, $c: 3, 2...);
-}
+$list: 2, 3, 4;
+.foo {val: foo(1, $list...)}
 SCSS
   end
 
-  def test_mixin_keyword_args_after_splat
+  def test_function_splat_expression
     assert_equal <<CSS, render(<<SCSS)
 .foo {
-  a: 1;
-  b: 2;
-  c: 3; }
+  val: "a: 1, b: 2, c: 3, d: 4"; }
 CSS
-@mixin foo($a, $b, $c) {
-  a: 1;
-  b: 2;
-  c: 3;
+@function foo($a, $b, $c, $d) {
+  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}, d: \#{$d}";
 }
 
-.foo {
-  @include foo(1, 2..., $c: 3);
-}
+.foo {val: foo(1, (2, 3, 4)...)}
 SCSS
   end
 
-  def test_mixin_keyword_splat_after_keyword_args
+  def test_function_splat_args_with_var_args
     assert_equal <<CSS, render(<<SCSS)
 .foo {
-  a: 1;
-  b: 2;
-  c: 3; }
+  val: "a: 1, b: 2, 3, 4"; }
 CSS
-@mixin foo($a, $b, $c) {
-  a: 1;
-  b: 2;
-  c: 3;
+@function foo($a, $b...) {
+  @return "a: \#{$a}, b: \#{$b}";
 }
 
-.foo {
-  @include foo(1, $b: 2, (c: 3)...);
-}
+$list: 2, 3, 4;
+.foo {val: foo(1, $list...)}
 SCSS
   end
 
-  def test_mixin_triple_keyword_splat_merge
+  def test_function_splat_args_with_var_args_and_normal_args
     assert_equal <<CSS, render(<<SCSS)
 .foo {
-  foo: 1;
-  bar: 2;
-  kwarg: 3;
-  a: 3;
-  b: 2;
-  c: 3; }
+  val: "a: 1, b: 2, c: 3, 4"; }
 CSS
-@mixin foo($foo, $bar, $kwarg, $a, $b, $c) {
-  foo: $foo;
-  bar: $bar;
-  kwarg: $kwarg;
-  a: $a;
-  b: $b;
-  c: $c;
-}
-
-@mixin bar($args...) {
-  @include foo($args..., $bar: 2, $a: 2, $b: 2, (kwarg: 3, a: 3, c: 3)...);
+@function foo($a, $b, $c...) {
+  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
 }
 
-.foo {
-  @include bar($foo: 1, $a: 1, $b: 1, $c: 1);
-}
+$list: 2, 3, 4;
+.foo {val: foo(1, $list...)}
 SCSS
   end
 
-  def test_mixin_map_splat_converts_hyphens_and_underscores_for_real_args
+  def test_function_splat_args_with_var_args_preserves_separator
     assert_equal <<CSS, render(<<SCSS)
 .foo {
-  a: 1;
-  b: 2;
-  c: 3;
-  d: 4; }
+  val: "a: 1, b: 2 3 4 5"; }
 CSS
-@mixin foo($a-1, $b-2, $c_3, $d_4) {
-  a: $a-1;
-  b: $b-2;
-  c: $c_3;
-  d: $d_4;
+@function foo($a, $b...) {
+  @return "a: \#{$a}, b: \#{$b}";
 }
 
-.foo {
-  $map: (a-1: 1, b_2: 2, c-3: 3, d_4: 4);
-  @include foo($map...);
-}
+$list: 3 4 5;
+.foo {val: foo(1, 2, $list...)}
 SCSS
   end
 
-  def test_mixin_map_splat_doesnt_convert_hyphens_and_underscores_for_var_args
+  def test_function_var_and_splat_args_pass_through_keywords
     assert_equal <<CSS, render(<<SCSS)
 .foo {
-  a-1: 1;
-  b_2: 2;
-  c-3: 3;
-  d_4: 4; }
-CSS
-@mixin foo($args...) {
-  @each $key, $value in keywords($args) {
-    \#{$key}: $value;
-  }
+  val: "a: 3, b: 1, c: 2"; }
+CSS
+@function foo($a...) {
+  @return bar($a...);
 }
 
-.foo {
-  $map: (a-1: 1, b_2: 2, c-3: 3, d_4: 4);
-  @include foo($map...);
+@function bar($b, $c, $a) {
+  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
 }
+
+.foo {val: foo(1, $c: 2, $a: 3)}
 SCSS
   end
 
-  def test_mixin_conflicting_splat_after_keyword_args
-    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
-Mixin foo was passed argument $b both by position and by name.
-MESSAGE
-@mixin foo($a, $b, $c) {
-  a: 1;
-  b: 2;
-  c: 3;
+  def test_function_var_args_with_keyword
+    assert_raise_message(Sass::SyntaxError, "Positional arguments must come before keyword arguments.") {render <<SCSS}
+@function foo($a, $b...) {
+  @return "a: \#{$a}, b: $b";
 }
 
-.foo {
-  @include foo(1, $b: 2, 3...);
-}
+.foo {val: foo($a: 1, 2, 3, 4)}
 SCSS
   end
 
-  def test_mixin_keyword_splat_must_have_string_keys
-    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render <<SCSS}
-Variable keyword argument map must have string keys.
-12 is not a string in (12: 1).
-MESSAGE
-@mixin foo($a) {
-  a: $a;
-}
-
-.foo {@include foo((12: 1)...)}
-SCSS
-  end
-
-  def test_mixin_positional_arg_after_splat
-    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
-Only keyword arguments may follow variable arguments (...).
-MESSAGE
-@mixin foo($a, $b, $c) {
-  a: 1;
-  b: 2;
-  c: 3;
-}
-
-.foo {
-  @include foo(1, 2..., 3);
-}
-SCSS
-  end
-
-  def test_mixin_var_args_with_keyword
-    assert_raise_message(Sass::SyntaxError, "Positional arguments must come before keyword arguments.") {render <<SCSS}
-@mixin foo($a, $b...) {
-  a: $a;
-  b: $b;
-}
-
-.foo {@include foo($a: 1, 2, 3, 4)}
-SCSS
-  end
-
-  def test_mixin_keyword_for_var_arg
-    assert_raise_message(Sass::SyntaxError, "Argument $b of mixin foo cannot be used as a named argument.") {render <<SCSS}
-@mixin foo($a, $b...) {
-  a: $a;
-  b: $b;
-}
-
-.foo {@include foo(1, $b: 2 3 4)}
-SCSS
-  end
-
-  def test_mixin_keyword_for_unknown_arg_with_var_args
-    assert_raise_message(Sass::SyntaxError, "Mixin foo doesn't have an argument named $c.") {render <<SCSS}
-@mixin foo($a, $b...) {
-  a: $a;
-  b: $b;
-}
-
-.foo {@include foo(1, $c: 2 3 4)}
-SCSS
-  end
-
-  def test_mixin_map_splat_before_list_splat
-    assert_raise_message(Sass::SyntaxError, "Variable keyword arguments must be a map (was (2 3)).") {render <<SCSS}
-@mixin foo($a, $b, $c) {
-  a: $a;
-  b: $b;
-  c: $c;
-}
-
-.foo {
-  @include foo((a: 1)..., (2 3)...);
-}
-SCSS
-  end
-
-  def test_mixin_map_splat_with_unknown_keyword
-    assert_raise_message(Sass::SyntaxError, "Mixin foo doesn't have an argument named $c.") {render <<SCSS}
-@mixin foo($a, $b) {
-  a: $a;
-  b: $b;
-}
-
-.foo {
-  @include foo(1, 2, (c: 1)...);
-}
-SCSS
-  end
-
-  def test_mixin_map_splat_with_wrong_type
-    assert_raise_message(Sass::SyntaxError, "Variable keyword arguments must be a map (was 12).") {render <<SCSS}
-@mixin foo($a, $b) {
-  a: $a;
-  b: $b;
-}
-
-.foo {
-  @include foo((1, 2)..., 12...);
-}
-SCSS
-  end
-
-  def test_function_var_args
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 2, 3, 4"; }
-CSS
-@function foo($a, $b...) {
-  @return "a: \#{$a}, b: \#{$b}";
-}
-
-.foo {val: foo(1, 2, 3, 4)}
-SCSS
-  end
-
-  def test_function_empty_var_args
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 0"; }
-CSS
-@function foo($a, $b...) {
-  @return "a: \#{$a}, b: \#{length($b)}";
-}
-
-.foo {val: foo(1)}
-SCSS
-  end
-
-  def test_function_var_args_act_like_list
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 3, b: 3"; }
-CSS
-@function foo($a, $b...) {
-  @return "a: \#{length($b)}, b: \#{nth($b, 2)}";
-}
-
-.foo {val: foo(1, 2, 3, 4)}
-SCSS
-  end
-
-  def test_function_splat_args
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 2, c: 3, d: 4"; }
-CSS
-@function foo($a, $b, $c, $d) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}, d: \#{$d}";
-}
-
-$list: 2, 3, 4;
-.foo {val: foo(1, $list...)}
-SCSS
-  end
-
-  def test_function_splat_expression
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 2, c: 3, d: 4"; }
-CSS
-@function foo($a, $b, $c, $d) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}, d: \#{$d}";
-}
-
-.foo {val: foo(1, (2, 3, 4)...)}
-SCSS
-  end
-
-  def test_function_splat_args_with_var_args
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 2, 3, 4"; }
-CSS
-@function foo($a, $b...) {
-  @return "a: \#{$a}, b: \#{$b}";
-}
-
-$list: 2, 3, 4;
-.foo {val: foo(1, $list...)}
-SCSS
-  end
-
-  def test_function_splat_args_with_var_args_and_normal_args
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 2, c: 3, 4"; }
-CSS
-@function foo($a, $b, $c...) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
-}
-
-$list: 2, 3, 4;
-.foo {val: foo(1, $list...)}
-SCSS
-  end
-
-  def test_function_splat_args_with_var_args_preserves_separator
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 2 3 4 5"; }
-CSS
+  def test_function_keyword_for_var_arg
+    assert_raise_message(Sass::SyntaxError, "Argument $b of function foo cannot be used as a named argument.") {render <<SCSS}
 @function foo($a, $b...) {
-  @return "a: \#{$a}, b: \#{$b}";
-}
-
-$list: 3 4 5;
-.foo {val: foo(1, 2, $list...)}
-SCSS
-  end
-
-  def test_function_var_and_splat_args_pass_through_keywords
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 3, b: 1, c: 2"; }
-CSS
-@function foo($a...) {
-  @return bar($a...);
-}
-
-@function bar($b, $c, $a) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
-}
-
-.foo {val: foo(1, $c: 2, $a: 3)}
-SCSS
-  end
-
-  def test_function_var_keyword_args
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 2, c: 3"; }
-CSS
-@function foo($args...) {
-  @return "a: \#{map-get(keywords($args), a)}, " +
-    "b: \#{map-get(keywords($args), b)}, " +
-    "c: \#{map-get(keywords($args), c)}";
-}
-
-.foo {val: foo($a: 1, $b: 2, $c: 3)}
-SCSS
-  end
-
-  def test_function_empty_var_keyword_args
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  length: 0; }
-CSS
-@function foo($args...) {
-  @return length(keywords($args));
-}
-
-.foo {length: foo()}
-SCSS
-  end
-
-  def test_function_map_splat
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 2, c: 3"; }
-CSS
-@function foo($a, $b, $c) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
-}
-
-.foo {
-  $map: (a: 1, b: 2, c: 3);
-  val: foo($map...);
-}
-SCSS
-  end
-
-  def test_function_map_and_list_splat
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: x, b: y, c: z, d: 1, e: 2, f: 3"; }
-CSS
-@function foo($a, $b, $c, $d, $e, $f) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}, d: \#{$d}, e: \#{$e}, f: \#{$f}";
-}
-
-.foo {
-  $list: x y z;
-  $map: (d: 1, e: 2, f: 3);
-  val: foo($list..., $map...);
-}
-SCSS
-  end
-
-  def test_function_map_splat_takes_precedence_over_pass_through
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 2, c: z"; }
-CSS
-@function foo($args...) {
-  $map: (c: z);
-  @return bar($args..., $map...);
-}
-
-@function bar($a, $b, $c) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
-}
-
-.foo {
-  val: foo(1, $b: 2, $c: 3);
-}
-SCSS
-  end
-
-  def test_ruby_function_map_splat_takes_precedence_over_pass_through
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: 1 2 3 z; }
-CSS
-@function foo($args...) {
-  $map: (val: z);
-  @return append($args..., $map...);
-}
-
-.foo {
-  val: foo(1 2 3, $val: 4)
-}
-SCSS
-  end
-
-  def test_function_list_of_pairs_splat_treated_as_list
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: a 1, b: b 2, c: c 3"; }
-CSS
-@function foo($a, $b, $c) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
-}
-
-.foo {
-  val: foo((a 1, b 2, c 3)...);
-}
-SCSS
-  end
-
-  def test_function_splat_after_keyword_args
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 2, c: 3"; }
-CSS
-@function foo($a, $b, $c) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
-}
-
-.foo {
-  val: foo(1, $c: 3, 2...);
-}
-SCSS
-  end
-
-  def test_function_keyword_args_after_splat
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 2, c: 3"; }
-CSS
-@function foo($a, $b, $c) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
-}
-
-.foo {
-  val: foo(1, 2..., $c: 3);
-}
-SCSS
-  end
-
-  def test_function_keyword_splat_after_keyword_args
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "a: 1, b: 2, c: 3"; }
-CSS
-@function foo($a, $b, $c) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
-}
-
-.foo {
-  val: foo(1, $b: 2, (c: 3)...);
-}
-SCSS
-  end
-
-  def test_function_triple_keyword_splat_merge
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: "foo: 1, bar: 2, kwarg: 3, a: 3, b: 2, c: 3"; }
-CSS
-@function foo($foo, $bar, $kwarg, $a, $b, $c) {
-  @return "foo: \#{$foo}, bar: \#{$bar}, kwarg: \#{$kwarg}, a: \#{$a}, b: \#{$b}, c: \#{$c}";
-}
-
-@function bar($args...) {
-  @return foo($args..., $bar: 2, $a: 2, $b: 2, (kwarg: 3, a: 3, c: 3)...);
-}
-
-.foo {
-  val: bar($foo: 1, $a: 1, $b: 1, $c: 1);
-}
-SCSS
-  end
-
-  def test_function_conflicting_splat_after_keyword_args
-    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
-Function foo was passed argument $b both by position and by name.
-MESSAGE
-@function foo($a, $b, $c) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
-}
-
-.foo {
-  val: foo(1, $b: 2, 3...);
-}
-SCSS
-  end
-
-  def test_function_positional_arg_after_splat
-    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
-Only keyword arguments may follow variable arguments (...).
-MESSAGE
-@function foo($a, $b, $c) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
-}
-
-.foo {
-  val: foo(1, 2..., 3);
-}
-SCSS
-  end
-
-  def test_function_var_args_with_keyword
-    assert_raise_message(Sass::SyntaxError, "Positional arguments must come before keyword arguments.") {render <<SCSS}
-@function foo($a, $b...) {
-  @return "a: \#{$a}, b: \#{$b}";
-}
-
-.foo {val: foo($a: 1, 2, 3, 4)}
-SCSS
-  end
-
-  def test_function_keyword_for_var_arg
-    assert_raise_message(Sass::SyntaxError, "Argument $b of function foo cannot be used as a named argument.") {render <<SCSS}
-@function foo($a, $b...) {
-  @return "a: \#{$a}, b: \#{$b}";
-}
-
-.foo {val: foo(1, $b: 2 3 4)}
-SCSS
-  end
-
-  def test_function_keyword_for_unknown_arg_with_var_args
-    assert_raise_message(Sass::SyntaxError, "Function foo doesn't have an argument named $c.") {render <<SCSS}
-@function foo($a, $b...) {
-  @return "a: \#{$a}, b: \#{length($b)}";
-}
-
-.foo {val: foo(1, $c: 2 3 4)}
-SCSS
-  end
-
-  def test_function_var_args_passed_to_native
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  val: #102035; }
-CSS
-@function foo($args...) {
-  @return adjust-color($args...);
-}
-
-.foo {val: foo(#102030, $blue: 5)}
-SCSS
-  end
-
-  def test_function_map_splat_before_list_splat
-    assert_raise_message(Sass::SyntaxError, "Variable keyword arguments must be a map (was (2 3)).") {render <<SCSS}
-@function foo($a, $b, $c) {
-  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
-}
-
-.foo {
-  val: foo((a: 1)..., (2 3)...);
-}
-SCSS
-  end
-
-  def test_function_map_splat_with_unknown_keyword
-    assert_raise_message(Sass::SyntaxError, "Function foo doesn't have an argument named $c.") {render <<SCSS}
-@function foo($a, $b) {
-  @return "a: \#{$a}, b: \#{$b}";
-}
-
-.foo {
-  val: foo(1, 2, (c: 1)...);
-}
-SCSS
-  end
-
-  def test_function_map_splat_with_wrong_type
-    assert_raise_message(Sass::SyntaxError, "Variable keyword arguments must be a map (was 12).") {render <<SCSS}
-@function foo($a, $b) {
-  @return "a: \#{$a}, b: \#{$b}";
-}
-
-.foo {
-  val: foo((1, 2)..., 12...);
-}
-SCSS
-  end
-
-  def test_function_keyword_splat_must_have_string_keys
-    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render <<SCSS}
-Variable keyword argument map must have string keys.
-12 is not a string in (12: 1).
-MESSAGE
-@function foo($a) {
-  @return $a;
-}
-
-.foo {val: foo((12: 1)...)}
-SCSS
-  end
-
-  ## Interpolation
-
-  def test_basic_selector_interpolation
-    assert_equal <<CSS, render(<<SCSS)
-foo ab baz {
-  a: b; }
-CSS
-foo \#{'a' + 'b'} baz {a: b}
-SCSS
-    assert_equal <<CSS, render(<<SCSS)
-foo.bar baz {
-  a: b; }
-CSS
-foo\#{".bar"} baz {a: b}
-SCSS
-    assert_equal <<CSS, render(<<SCSS)
-foo.bar baz {
-  a: b; }
-CSS
-\#{"foo"}.bar baz {a: b}
-SCSS
-  end
-
-  def test_selector_only_interpolation
-    assert_equal <<CSS, render(<<SCSS)
-foo bar {
-  a: b; }
-CSS
-\#{"foo" + " bar"} {a: b}
-SCSS
-  end
-
-  def test_selector_interpolation_before_element_name
-    assert_equal <<CSS, render(<<SCSS)
-foo barbaz {
-  a: b; }
-CSS
-\#{"foo" + " bar"}baz {a: b}
-SCSS
-  end
-
-  def test_selector_interpolation_in_string
-    assert_equal <<CSS, render(<<SCSS)
-foo[val="bar foo bar baz"] {
-  a: b; }
-CSS
-foo[val="bar \#{"foo" + " bar"} baz"] {a: b}
-SCSS
-  end
-
-  def test_selector_interpolation_in_pseudoclass
-    assert_equal <<CSS, render(<<SCSS)
-foo:nth-child(5n) {
-  a: b; }
-CSS
-foo:nth-child(\#{5 + "n"}) {a: b}
-SCSS
-  end
-
-  def test_selector_interpolation_at_class_begininng
-    assert_equal <<CSS, render(<<SCSS)
-.zzz {
-  a: b; }
-CSS
-$zzz: zzz;
-.\#{$zzz} { a: b; }
-SCSS
-  end
-
-  def test_selector_interpolation_at_id_begininng
-    assert_equal <<CSS, render(<<SCSS)
-#zzz {
-  a: b; }
-CSS
-$zzz: zzz;
-#\#{$zzz} { a: b; }
-SCSS
-  end
-
-  def test_selector_interpolation_at_pseudo_begininng
-    assert_equal <<CSS, render(<<SCSS)
-:zzz::zzz {
-  a: b; }
-CSS
-$zzz: zzz;
-:\#{$zzz}::\#{$zzz} { a: b; }
-SCSS
-  end
-
-  def test_selector_interpolation_at_attr_beginning
-    assert_equal <<CSS, render(<<SCSS)
-[zzz=foo] {
-  a: b; }
-CSS
-$zzz: zzz;
-[\#{$zzz}=foo] { a: b; }
-SCSS
-  end
-
-  def test_selector_interpolation_at_attr_end
-    assert_equal <<CSS, render(<<SCSS)
-[foo=zzz] {
-  a: b; }
-CSS
-$zzz: zzz;
-[foo=\#{$zzz}] { a: b; }
-SCSS
-  end
-
-  def test_selector_interpolation_at_dashes
-    assert_equal <<CSS, render(<<SCSS)
-div {
-  -foo-a-b-foo: foo; }
-CSS
-$a : a;
-$b : b;
-div { -foo-\#{$a}-\#{$b}-foo: foo }
-SCSS
-  end
-
-  def test_selector_interpolation_in_reference_combinator
-    assert_equal <<CSS, render(<<SCSS)
-.foo /a/ .bar /b|c/ .baz {
-  a: b; }
-CSS
-$a: a;
-$b: b;
-$c: c;
-.foo /\#{$a}/ .bar /\#{$b}|\#{$c}/ .baz {a: b}
-SCSS
-  end
-
-  def test_parent_selector_with_parent_and_subject
-    silence_warnings {assert_equal <<CSS, render(<<SCSS)}
-bar foo.baz! .bip {
-  c: d; }
-CSS
-$subject: "!";
-foo {
-  bar &.baz\#{$subject} .bip {c: d}}
-SCSS
-  end
-
-  def test_basic_prop_name_interpolation
-    assert_equal <<CSS, render(<<SCSS)
-foo {
-  barbazbang: blip; }
-CSS
-foo {bar\#{"baz" + "bang"}: blip}
-SCSS
-    assert_equal <<CSS, render(<<SCSS)
-foo {
-  bar3: blip; }
-CSS
-foo {bar\#{1 + 2}: blip}
-SCSS
-  end
-
-  def test_prop_name_only_interpolation
-    assert_equal <<CSS, render(<<SCSS)
-foo {
-  bazbang: blip; }
-CSS
-foo {\#{"baz" + "bang"}: blip}
-SCSS
-  end
-
-  def test_directive_interpolation
-    assert_equal <<CSS, render(<<SCSS)
-@foo bar12 qux {
-  a: b; }
-CSS
-$baz: 12;
-@foo bar\#{$baz} qux {a: b}
-SCSS
-  end
-
-  def test_media_interpolation
-    assert_equal <<CSS, render(<<SCSS)
-@media bar12 {
-  a: b; }
-CSS
-$baz: 12;
-@media bar\#{$baz} {a: b}
-SCSS
-  end
-
-  def test_script_in_media
-    assert_equal <<CSS, render(<<SCSS)
-@media screen and (-webkit-min-device-pixel-ratio: 20), only print {
-  a: b; }
-CSS
-$media1: screen;
-$media2: print;
-$var: -webkit-min-device-pixel-ratio;
-$val: 20;
-@media \#{$media1} and ($var: $val), only \#{$media2} {a: b}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-@media screen and (-webkit-min-device-pixel-ratio: 13) {
-  a: b; }
-CSS
-$vals: 1 2 3;
-@media screen and (-webkit-min-device-pixel-ratio: 5 + 6 + nth($vals, 2)) {a: b}
-SCSS
-  end
-
-  def test_media_interpolation_with_reparse
-    assert_equal <<CSS, render(<<SCSS)
-@media screen and (max-width: 300px) {
-  a: b; }
-@media screen and (max-width: 300px) {
-  a: b; }
-@media screen and (max-width: 300px) {
-  a: b; }
-@media screen and (max-width: 300px), print and (max-width: 300px) {
-  a: b; }
-CSS
-$constraint: "(max-width: 300px)";
-$fragment: "nd \#{$constraint}";
-$comma: "een, pri";
-@media screen and \#{$constraint} {a: b}
-@media screen {
-  @media \#{$constraint} {a: b}
-}
-@media screen a\#{$fragment} {a: b}
-@media scr\#{$comma}nt {
-  @media \#{$constraint} {a: b}
-}
-SCSS
-  end
-
-  def test_moz_document_interpolation
-    assert_equal <<CSS, render(<<SCSS)
-@-moz-document url(http://sass-lang.com/),
-               url-prefix(http://sass-lang.com/docs),
-               domain(sass-lang.com),
-               domain("sass-lang.com") {
-  .foo {
-    a: b; } }
-CSS
-$domain: "sass-lang.com";
-@-moz-document url(http://\#{$domain}/),
-               url-prefix(http://\#{$domain}/docs),
-               domain(\#{$domain}),
-               \#{domain($domain)} {
-  .foo {a: b}
-}
-SCSS
-  end
-
-  def test_supports_with_expressions
-    assert_equal <<CSS, render(<<SCSS)
-@supports (feature1: val) and (feature2: val) or (not (feature23: val4)) {
-  foo {
-    a: b; } }
-CSS
-$query: "(feature1: val)";
-$feature: feature2;
-$val: val;
-@supports \#{$query} and ($feature: $val) or (not ($feature + 3: $val + 4)) {
-  foo {a: b}
-}
-SCSS
-  end
-
-  def test_supports_bubbling
-    assert_equal <<CSS, render(<<SCSS)
-@supports (foo: bar) {
-  a {
-    b: c; }
-    @supports (baz: bang) {
-      a {
-        d: e; } } }
-CSS
-a {
-  @supports (foo: bar) {
-    b: c;
-    @supports (baz: bang) {
-      d: e;
-    }
-  }
-}
-SCSS
-  end
-
-  def test_random_directive_interpolation
-    assert_equal <<CSS, render(<<SCSS)
-@foo url(http://sass-lang.com/),
-     domain("sass-lang.com"),
-     "foobarbaz",
-     foobarbaz {
-  .foo {
-    a: b; } }
-CSS
-$domain: "sass-lang.com";
-@foo url(http://\#{$domain}/),
-     \#{domain($domain)},
-     "foo\#{'ba' + 'r'}baz",
-     foo\#{'ba' + 'r'}baz {
-  .foo {a: b}
-}
-SCSS
-  end
-
-  def test_color_interpolation_warning_in_selector
-    assert_warning(<<WARNING) {assert_equal <<CSS, render(<<SCSS)}
-WARNING on line 1, column 4 of #{filename_for_test(:scss)}:
-You probably don't mean to use the color value `blue' in interpolation here.
-It may end up represented as #0000ff, which will likely produce invalid CSS.
-Always quote color names when using them as strings (for example, "blue").
-If you really want to use the color value here, use `"" + blue'.
-WARNING
-fooblue {
-  a: b; }
-CSS
-foo\#{blue} {a: b}
-SCSS
-  end
-
-  def test_color_interpolation_warning_in_directive
-    assert_warning(<<WARNING) {assert_equal <<CSS, render(<<SCSS)}
-WARNING on line 1, column 12 of #{filename_for_test(:scss)}:
-You probably don't mean to use the color value `blue' in interpolation here.
-It may end up represented as #0000ff, which will likely produce invalid CSS.
-Always quote color names when using them as strings (for example, "blue").
-If you really want to use the color value here, use `"" + blue'.
-WARNING
-@fblthp fooblue {
-  a: b; }
-CSS
-@fblthp foo\#{blue} {a: b}
-SCSS
-  end
-
-  def test_color_interpolation_warning_in_property_name
-    assert_warning(<<WARNING) {assert_equal <<CSS, render(<<SCSS)}
-WARNING on line 1, column 8 of #{filename_for_test(:scss)}:
-You probably don't mean to use the color value `blue' in interpolation here.
-It may end up represented as #0000ff, which will likely produce invalid CSS.
-Always quote color names when using them as strings (for example, "blue").
-If you really want to use the color value here, use `"" + blue'.
-WARNING
-foo {
-  a-blue: b; }
-CSS
-foo {a-\#{blue}: b}
-SCSS
-  end
-
-  def test_no_color_interpolation_warning_in_property_value
-    assert_no_warning {assert_equal <<CSS, render(<<SCSS)}
-foo {
-  a: b-blue; }
-CSS
-foo {a: b-\#{blue}}
-SCSS
-  end
-
-  def test_no_color_interpolation_warning_for_nameless_color
-    assert_no_warning {assert_equal <<CSS, render(<<SCSS)}
-foo-#abcdef {
-  a: b; }
-CSS
-foo-\#{#abcdef} {a: b}
-SCSS
-  end
-
-  def test_nested_mixin_def
-    assert_equal <<CSS, render(<<SCSS)
-foo {
-  a: b; }
-CSS
-foo {
-  @mixin bar {a: b}
-  @include bar; }
-SCSS
-  end
-
-  def test_nested_mixin_shadow
-    assert_equal <<CSS, render(<<SCSS)
-foo {
-  c: d; }
-
-baz {
-  a: b; }
-CSS
-@mixin bar {a: b}
-
-foo {
-  @mixin bar {c: d}
-  @include bar;
-}
-
-baz {@include bar}
-SCSS
-  end
-
-  def test_nested_function_def
-    assert_equal <<CSS, render(<<SCSS)
-foo {
-  a: 1; }
-
-bar {
-  b: foo(); }
-CSS
-foo {
-  @function foo() {@return 1}
-  a: foo(); }
-
-bar {b: foo()}
-SCSS
-  end
-
-  def test_nested_function_shadow
-    assert_equal <<CSS, render(<<SCSS)
-foo {
-  a: 2; }
-
-baz {
-  b: 1; }
-CSS
-@function foo() {@return 1}
-
-foo {
-  @function foo() {@return 2}
-  a: foo();
-}
-
-baz {b: foo()}
-SCSS
-  end
-
-  ## @at-root
-
-  def test_simple_at_root
-    assert_equal <<CSS, render(<<SCSS)
-.bar {
-  a: b; }
-CSS
-.foo {
-  @at-root {
-    .bar {a: b}
-  }
-}
-SCSS
-  end
-
-  def test_at_root_with_selector
-    assert_equal <<CSS, render(<<SCSS)
-.bar {
-  a: b; }
-CSS
-.foo {
-  @at-root .bar {a: b}
-}
-SCSS
-  end
-
-  def test_at_root_in_mixin
-    assert_equal <<CSS, render(<<SCSS)
-.bar {
-  a: b; }
-CSS
-@mixin bar {
-  @at-root .bar {a: b}
-}
-
-.foo {
-  @include bar;
-}
-SCSS
-  end
-
-  def test_at_root_in_media
-    assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  .bar {
-    a: b; } }
-CSS
-@media screen {
-  .foo {
-    @at-root .bar {a: b}
-  }
-}
-SCSS
-  end
-
-  def test_at_root_in_bubbled_media
-    assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  .bar {
-    a: b; } }
-CSS
-.foo {
-  @media screen {
-    @at-root .bar {a: b}
-  }
-}
-SCSS
-  end
-
-  def test_at_root_in_unknown_directive
-    assert_equal <<CSS, render(<<SCSS)
-@fblthp {
-  .bar {
-    a: b; } }
-CSS
-@fblthp {
-  .foo {
-    @at-root .bar {a: b}
-  }
-}
-SCSS
-  end
-
-  def test_comments_in_at_root
-    assert_equal <<CSS, render(<<SCSS)
-/* foo */
-.bar {
-  a: b; }
-
-/* baz */
-CSS
-.foo {
-  @at-root {
-    /* foo */
-    .bar {a: b}
-    /* baz */
-  }
-}
-SCSS
-  end
-
-  def test_comments_in_at_root_in_media
-    assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  /* foo */
-  .bar {
-    a: b; }
-
-  /* baz */ }
-CSS
-@media screen {
-  .foo {
-    @at-root {
-      /* foo */
-      .bar {a: b}
-      /* baz */
-    }
-  }
-}
-SCSS
-  end
-
-  def test_comments_in_at_root_in_unknown_directive
-    assert_equal <<CSS, render(<<SCSS)
-@fblthp {
-  /* foo */
-  .bar {
-    a: b; }
-
-  /* baz */ }
-CSS
-@fblthp {
-  .foo {
-    @at-root {
-      /* foo */
-      .bar {a: b}
-      /* baz */
-    }
-  }
-}
-SCSS
-  end
-
-  def test_media_directive_in_at_root
-    assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  .bar {
-    a: b; } }
-CSS
-.foo {
-  @at-root {
-    @media screen {.bar {a: b}}
-  }
-}
-SCSS
-  end
-
-  def test_bubbled_media_directive_in_at_root
-    assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  .bar .baz {
-    a: b; } }
-CSS
-.foo {
-  @at-root {
-    .bar {
-      @media screen {.baz {a: b}}
-    }
-  }
-}
-SCSS
-  end
-
-  def test_unknown_directive_in_at_root
-    assert_equal <<CSS, render(<<SCSS)
-@fblthp {
-  .bar {
-    a: b; } }
-CSS
-.foo {
-  @at-root {
-    @fblthp {.bar {a: b}}
-  }
-}
-SCSS
-  end
-
-  def test_at_root_in_at_root
-    assert_equal <<CSS, render(<<SCSS)
-.bar {
-  a: b; }
-CSS
-.foo {
-  @at-root {
-    @at-root .bar {a: b}
-  }
-}
-SCSS
-  end
-
-  def test_at_root_with_parent_ref
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  a: b; }
-CSS
-.foo {
-  @at-root & {
-    a: b;
-  }
-}
-SCSS
-  end
-
-  def test_multi_level_at_root_with_parent_ref
-    assert_equal <<CSS, render(<<SCSS)
-.foo .bar {
-  a: b; }
-CSS
-.foo {
-  @at-root & {
-    .bar {
-      @at-root & {
-        a: b;
-      }
-    }
-  }
-}
-SCSS
-  end
-
-  def test_multi_level_at_root_with_inner_parent_ref
-    assert_equal <<CSS, render(<<SCSS)
-.bar {
-  a: b; }
-CSS
-.foo {
-  @at-root .bar {
-    @at-root & {
-      a: b;
-    }
-  }
+  @return "a: \#{$a}, b: \#{$b}";
 }
+
+.foo {val: foo(1, $b: 2 3 4)}
 SCSS
   end
 
-  def test_at_root_beneath_comma_selector
-    assert_equal(<<CSS, render(<<SCSS))
-.baz {
-  a: b; }
-CSS
-.foo, .bar {
-  @at-root .baz {
-    a: b;
-  }
+  def test_function_keyword_for_unknown_arg_with_var_args
+    assert_raise_message(Sass::SyntaxError, "Function foo doesn't have an argument named $c.") {render <<SCSS}
+@function foo($a, $b...) {
+  @return "a: \#{$a}, b: \#{$b}";
 }
+
+.foo {val: foo(1, $c: 2 3 4)}
 SCSS
   end
 
-  def test_at_root_with_parent_ref_and_class
-    assert_equal(<<CSS, render(<<SCSS))
-.foo.bar {
-  a: b; }
-CSS
+  def test_function_var_args_passed_to_native
+    assert_equal <<CSS, render(<<SCSS)
 .foo {
-  @at-root &.bar {
-    a: b;
-  }
+  val: #102035; }
+CSS
+@function foo($args...) {
+  @return adjust-color($args...);
 }
+
+.foo {val: foo(#102030, $blue: 5)}
 SCSS
   end
 
-  def test_at_root_beneath_comma_selector_with_parent_ref
-    assert_equal(<<CSS, render(<<SCSS))
-.foo.baz, .bar.baz {
+  ## Interpolation
+
+  def test_basic_selector_interpolation
+    assert_equal <<CSS, render(<<SCSS)
+foo 3 baz {
   a: b; }
 CSS
-.foo, .bar {
-  @at-root &.baz {
-    a: b;
-  }
-}
+foo \#{1 + 2} baz {a: b}
 SCSS
-  end
-
-  ## @at-root (...)
-
-  def test_at_root_without_media
     assert_equal <<CSS, render(<<SCSS)
-.foo .bar {
+foo.bar baz {
   a: b; }
 CSS
-.foo {
-  @media screen {
-    @at-root (without: media) {
-      .bar {
-        a: b;
-      }
-    }
-  }
-}
+foo\#{".bar"} baz {a: b}
 SCSS
-  end
-
-  def test_at_root_without_supports
     assert_equal <<CSS, render(<<SCSS)
-.foo .bar {
+foo.bar baz {
   a: b; }
 CSS
-.foo {
-  @supports (foo: bar) {
-    @at-root (without: supports) {
-      .bar {
-        a: b;
-      }
-    }
-  }
-}
+\#{"foo"}.bar baz {a: b}
 SCSS
   end
 
-  def test_at_root_without_rule
+  def test_selector_only_interpolation
     assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  .bar {
-    a: b; } }
+foo bar {
+  a: b; }
 CSS
-.foo {
-  @media screen {
-    @at-root (without: rule) {
-      .bar {
-        a: b;
-      }
-    }
-  }
-}
+\#{"foo" + " bar"} {a: b}
 SCSS
   end
 
-  def test_at_root_without_unknown_directive
+  def test_selector_interpolation_before_element_name
     assert_equal <<CSS, render(<<SCSS)
-@fblthp {}
-.foo .bar {
+foo barbaz {
   a: b; }
 CSS
-.foo {
-  @fblthp {
-    @at-root (without: fblthp) {
-      .bar {
-        a: b;
-      }
-    }
-  }
-}
+\#{"foo" + " bar"}baz {a: b}
 SCSS
   end
 
-  def test_at_root_without_multiple
+  def test_selector_interpolation_in_string
     assert_equal <<CSS, render(<<SCSS)
-@supports (foo: bar) {
-  .bar {
-    a: b; } }
+foo[val="bar foo bar baz"] {
+  a: b; }
 CSS
-.foo {
-  @media screen {
-    @supports (foo: bar) {
-      @at-root (without: media rule) {
-        .bar {
-          a: b;
-        }
-      }
-    }
-  }
-}
+foo[val="bar \#{"foo" + " bar"} baz"] {a: b}
 SCSS
   end
 
-  def test_at_root_without_all
+  def test_selector_interpolation_in_pseudoclass
     assert_equal <<CSS, render(<<SCSS)
-@supports (foo: bar) {
-  @fblthp {} }
-.bar {
+foo:nth-child(5n) {
   a: b; }
 CSS
-.foo {
-  @supports (foo: bar) {
-    @fblthp {
-      @at-root (without: all) {
-        .bar {
-          a: b;
-        }
-      }
-    }
-  }
-}
+foo:nth-child(\#{5 + "n"}) {a: b}
 SCSS
   end
 
-  def test_at_root_with_media
+  def test_selector_interpolation_at_class_begininng
     assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  @fblthp {}
-  .bar {
-    a: b; } }
+.zzz {
+  a: b; }
 CSS
-.foo {
-  @media screen {
-    @fblthp {
-      @supports (foo: bar) {
-        @at-root (with: media) {
-          .bar {
-            a: b;
-          }
-        }
-      }
-    }
-  }
-}
+$zzz: zzz;
+.\#{$zzz} { a: b; }
 SCSS
   end
 
-  def test_at_root_with_rule
+  def test_selector_interpolation_at_id_begininng
     assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  @fblthp {} }
-.foo .bar {
+#zzz {
   a: b; }
 CSS
-.foo {
-  @media screen {
-    @fblthp {
-      @supports (foo: bar) {
-        @at-root (with: rule) {
-          .bar {
-            a: b;
-          }
-        }
-      }
-    }
-  }
-}
+$zzz: zzz;
+#\#{$zzz} { a: b; }
 SCSS
   end
 
-  def test_at_root_with_supports
+  def test_selector_interpolation_at_pseudo_begininng
     assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  @fblthp {} }
-@supports (foo: bar) {
-  .bar {
-    a: b; } }
+:zzz::zzz {
+  a: b; }
 CSS
-.foo {
-  @media screen {
-    @fblthp {
-      @supports (foo: bar) {
-        @at-root (with: supports) {
-          .bar {
-            a: b;
-          }
-        }
-      }
-    }
-  }
-}
+$zzz: zzz;
+:\#{$zzz}::\#{$zzz} { a: b; }
 SCSS
   end
 
-  def test_at_root_with_unknown_directive
+  def test_selector_interpolation_at_attr_beginning
     assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  @fblthp {} }
-@fblthp {
-  .bar {
-    a: b; } }
+[zzz=foo] {
+  a: b; }
 CSS
-.foo {
-  @media screen {
-    @fblthp {
-      @supports (foo: bar) {
-        @at-root (with: fblthp) {
-          .bar {
-            a: b;
-          }
-        }
-      }
-    }
-  }
-}
+$zzz: zzz;
+[\#{$zzz}=foo] { a: b; }
 SCSS
   end
 
-  def test_at_root_with_multiple
+  def test_selector_interpolation_at_attr_end
     assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  @fblthp {}
-  .foo .bar {
-    a: b; } }
+[foo=zzz] {
+  a: b; }
 CSS
-.foo {
-  @media screen {
-    @fblthp {
-      @supports (foo: bar) {
-        @at-root (with: media rule) {
-          .bar {
-            a: b;
-          }
-        }
-      }
-    }
-  }
-}
+$zzz: zzz;
+[foo=\#{$zzz}] { a: b; }
 SCSS
   end
 
-  def test_at_root_with_all
+  def test_selector_interpolation_at_dashes
     assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  @fblthp {
-    @supports (foo: bar) {
-      .foo .bar {
-        a: b; } } } }
+div {
+  -foo-a-b-foo: foo; }
 CSS
-.foo {
-  @media screen {
-    @fblthp {
-      @supports (foo: bar) {
-        @at-root (with: all) {
-          .bar {
-            a: b;
-          }
-        }
-      }
-    }
-  }
-}
+$a : a;
+$b : b;
+div { -foo-\#{$a}-\#{$b}-foo: foo }
 SCSS
   end
 
-  def test_at_root_dynamic_values
+  def test_selector_interpolation_in_reference_combinator
     assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  .bar {
-    a: b; } }
+.foo /a/ .bar /b|c/ .baz {
+  a: b; }
 CSS
-$key: with;
-$value: media;
-.foo {
-  @media screen {
-    @at-root ($key: $value) {
-      .bar {
-        a: b;
-      }
-    }
-  }
-}
+$a: a;
+$b: b;
+$c: c;
+.foo /\#{$a}/ .bar /\#{$b}|\#{$c}/ .baz {a: b}
 SCSS
   end
 
-  def test_at_root_interpolated_query
+  def test_parent_selector_with_parent_and_subject
     assert_equal <<CSS, render(<<SCSS)
-@media screen {
-  .bar {
-    a: b; } }
+bar foo.baz! .bip {
+  c: d; }
 CSS
-.foo {
-  @media screen {
-    @at-root (\#{"with: media"}) {
-      .bar {
-        a: b;
-      }
-    }
-  }
-}
+$subject: "!";
+foo {
+  bar &.baz\#{$subject} .bip {c: d}}
 SCSS
   end
 
-  def test_at_root_plus_extend
+  def test_basic_prop_name_interpolation
     assert_equal <<CSS, render(<<SCSS)
-.foo .bar {
-  a: b; }
+foo {
+  barbazbang: blip; }
 CSS
-%base {
-  a: b;
-}
-
-.foo {
-  @media screen {
-    @at-root (without: media) {
-      .bar {
-        @extend %base;
-      }
-    }
-  }
-}
+foo {bar\#{"baz" + "bang"}: blip}
 SCSS
-  end
-
-  def test_at_root_without_keyframes_in_keyframe_rule
     assert_equal <<CSS, render(<<SCSS)
-.foo {
-  a: b; }
+foo {
+  bar3: blip; }
 CSS
-@keyframes identifier {
-  0% {
-    @at-root (without: keyframes) {
-      .foo {a: b}
-    }
-  }
-}
+foo {bar\#{1 + 2}: blip}
 SCSS
   end
 
-  def test_at_root_without_rule_in_keyframe_rule
+  def test_prop_name_only_interpolation
     assert_equal <<CSS, render(<<SCSS)
-@keyframes identifier {
-  0% {
-    a: b; } }
+foo {
+  bazbang: blip; }
 CSS
-@keyframes identifier {
-  0% {
-    @at-root (without: rule) {a: b}
-  }
-}
+foo {\#{"baz" + "bang"}: blip}
 SCSS
   end
 
-  ## Selector Script
-
-  def test_selector_script
-    assert_equal(<<CSS, render(<<SCSS))
-.foo .bar {
-  content: ".foo .bar"; }
+  def test_directive_interpolation
+    assert_equal <<CSS, render(<<SCSS)
+@foo bar12 qux {
+  a: b; }
 CSS
-.foo .bar {
-  content: "\#{&}";
-}
+$baz: 12;
+@foo bar\#{$baz} qux {a: b}
 SCSS
   end
 
-  def test_nested_selector_script
-    assert_equal(<<CSS, render(<<SCSS))
-.foo .bar {
-  content: ".foo .bar"; }
+  def test_media_interpolation
+    assert_equal <<CSS, render(<<SCSS)
+@media bar12 {
+  a: b; }
 CSS
-.foo {
-  .bar {
-    content: "\#{&}";
-  }
-}
+$baz: 12;
+@media bar\#{$baz} {a: b}
 SCSS
   end
 
-  def test_nested_selector_script_with_outer_comma_selector
-    assert_equal(<<CSS, render(<<SCSS))
-.foo .baz, .bar .baz {
-  content: ".foo .baz, .bar .baz"; }
+  def test_script_in_media
+    assert_equal <<CSS, render(<<SCSS)
+@media screen and (-webkit-min-device-pixel-ratio: 20), only print {
+  a: b; }
 CSS
-.foo, .bar {
-  .baz {
-    content: "\#{&}";
-  }
-}
+$media1: screen;
+$media2: print;
+$var: -webkit-min-device-pixel-ratio;
+$val: 20;
+@media \#{$media1} and ($var: $val), only \#{$media2} {a: b}
 SCSS
-  end
 
-  def test_nested_selector_script_with_inner_comma_selector
-    assert_equal(<<CSS, render(<<SCSS))
-.foo .bar, .foo .baz {
-  content: ".foo .bar, .foo .baz"; }
+    assert_equal <<CSS, render(<<SCSS)
+@media screen and (-webkit-min-device-pixel-ratio: 13) {
+  a: b; }
 CSS
-.foo {
-  .bar, .baz {
-    content: "\#{&}";
-  }
-}
+$vals: 1 2 3;
+@media screen and (-webkit-min-device-pixel-ratio: 5 + 6 + nth($vals, 2)) {a: b}
 SCSS
   end
 
-  def test_selector_script_through_mixin
-    assert_equal(<<CSS, render(<<SCSS))
-.foo {
-  content: ".foo"; }
+  def test_media_interpolation_with_reparse
+    assert_equal <<CSS, render(<<SCSS)
+@media screen and (max-width: 300px) {
+  a: b; }
+@media screen and (max-width: 300px) {
+  a: b; }
+@media screen and (max-width: 300px) {
+  a: b; }
+@media screen and (max-width: 300px), print and (max-width: 300px) {
+  a: b; }
 CSS
-@mixin mixin {
-  content: "\#{&}";
+$constraint: "(max-width: 300px)";
+$fragment: "nd \#{$constraint}";
+$comma: "een, pri";
+@media screen and \#{$constraint} {a: b}
+@media screen {
+  @media \#{$constraint} {a: b}
 }
-
-.foo {
-  @include mixin;
+@media screen a\#{$fragment} {a: b}
+@media scr\#{$comma}nt {
+  @media \#{$constraint} {a: b}
 }
 SCSS
   end
 
-  def test_selector_script_through_content
-    assert_equal(<<CSS, render(<<SCSS))
-.foo {
-  content: ".foo"; }
+  def test_moz_document_interpolation
+    assert_equal <<CSS, render(<<SCSS)
+@-moz-document url(http://sass-lang.com/),
+               url-prefix(http://sass-lang.com/docs),
+               domain(sass-lang.com),
+               domain("sass-lang.com") {
+  .foo {
+    a: b; } }
 CSS
-@mixin mixin {
-  @content;
-}
-
-.foo {
-  @include mixin {
-    content: "\#{&}";
-  }
+$domain: "sass-lang.com";
+@-moz-document url(http://\#{$domain}/),
+               url-prefix(http://\#{$domain}/docs),
+               domain(\#{$domain}),
+               \#{domain($domain)} {
+  .foo {a: b}
 }
 SCSS
   end
 
-  def test_selector_script_through_function
-    assert_equal(<<CSS, render(<<SCSS))
-.foo {
-  content: ".foo"; }
+  def test_supports_with_expressions
+    assert_equal <<CSS, render(<<SCSS)
+@supports (feature1: val) and (feature2: val) or (not (feature23: val4)) {
+  foo {
+    a: b; } }
 CSS
-@function fn() {
-  @return "\#{&}";
-}
-
-.foo {
-  content: fn();
+$query: "(feature1: val)";
+$feature: feature2;
+$val: val;
+@supports \#{$query} and ($feature: $val) or (not ($feature + 3: $val + 4)) {
+  foo {a: b}
 }
 SCSS
   end
 
-  def test_selector_script_through_media
-    assert_equal(<<CSS, render(<<SCSS))
-.foo {
-  content: "outer"; }
-  @media screen {
-    .foo .bar {
-      content: ".foo .bar"; } }
+  def test_supports_bubbling
+    assert_equal <<CSS, render(<<SCSS)
+@supports (foo: bar) {
+  a {
+    b: c; }
+    @supports (baz: bang) {
+      a {
+        d: e; } } }
 CSS
-.foo {
-  content: "outer";
-  @media screen {
-    .bar {
-      content: "\#{&}";
+a {
+  @supports (foo: bar) {
+    b: c;
+    @supports (baz: bang) {
+      d: e;
     }
   }
 }
 SCSS
   end
 
-  def test_selector_script_save_and_reuse
-    assert_equal(<<CSS, render(<<SCSS))
-.bar {
-  content: ".foo"; }
+  def test_random_directive_interpolation
+    assert_equal <<CSS, render(<<SCSS)
+@foo url(http://sass-lang.com/),
+     domain("sass-lang.com"),
+     "foobarbaz",
+     foobarbaz {
+  .foo {
+    a: b; } }
 CSS
-$var: null;
-.foo {
-  $var: & !global;
-}
-
-.bar {
-  content: "\#{$var}";
+$domain: "sass-lang.com";
+@foo url(http://\#{$domain}/),
+     \#{domain($domain)},
+     "foo\#{'ba' + 'r'}baz",
+     foo\#{'ba' + 'r'}baz {
+  .foo {a: b}
 }
 SCSS
   end
 
-  def test_selector_script_with_at_root
-    assert_equal(<<CSS, render(<<SCSS))
-.foo-bar {
+  def test_nested_mixin_def
+    assert_equal <<CSS, render(<<SCSS)
+foo {
   a: b; }
 CSS
-.foo {
-  @at-root \#{&}-bar {
-    a: b;
-  }
-}
+foo {
+  @mixin bar {a: b}
+  @include bar; }
 SCSS
   end
 
-  def test_multi_level_at_root_with_inner_selector_script
+  def test_nested_mixin_shadow
     assert_equal <<CSS, render(<<SCSS)
-.bar {
-  a: b; }
-CSS
-.foo {
-  @at-root .bar {
-    @at-root \#{&} {
-      a: b;
-    }
-  }
-}
-SCSS
-  end
+foo {
+  c: d; }
 
-  def test_at_root_with_at_root_through_mixin
-    assert_equal(<<CSS, render(<<SCSS))
-.bar-baz {
+baz {
   a: b; }
 CSS
-@mixin foo {
-  .bar {
-    @at-root \#{&}-baz {
-      a: b;
-    }
-  }
+@mixin bar {a: b}
+
+foo {
+  @mixin bar {c: d}
+  @include bar;
 }
 
-@include foo;
+baz {@include bar}
 SCSS
   end
 
-  # See https://github.com/sass/sass/issues/1294
-  def test_extend_top_leveled_by_at_root
-    render(<<SCSS)
-.span-10 {
-  @at-root (without: all) {
-    @extend %column;
-  }
-}
-SCSS
+  def test_nested_function_def
+    assert_equal <<CSS, render(<<SCSS)
+foo {
+  a: 1; }
 
-    assert(false, "Expected syntax error")
-  rescue Sass::SyntaxError => e
-    assert_equal "Extend directives may only be used within rules.", e.message
-    assert_equal 3, e.sass_line
+bar {
+  b: foo(); }
+CSS
+foo {
+  @function foo() {@return 1}
+  a: foo(); }
+
+bar {b: foo()}
+SCSS
   end
 
-  def test_at_root_doesnt_always_break_blocks
+  def test_nested_function_shadow
     assert_equal <<CSS, render(<<SCSS)
-.foo {
-  a: b; }
+foo {
+  a: 2; }
 
-@media screen {
-  .foo {
-    c: d; }
-  .bar {
-    e: f; } }
+baz {
+  b: 1; }
 CSS
-%base {
-  a: b;
-}
-
-@media screen {
-  .foo {
-    c: d;
-    @at-root (without: media) {
-      @extend %base;
-    }
-  }
+@function foo() {@return 1}
 
-  .bar {e: f}
+foo {
+  @function foo() {@return 2}
+  a: foo();
 }
-SCSS
-  end
 
-  ## Errors
-
-  def test_keyframes_rule_outside_of_keyframes
-    render <<SCSS
-0% {
-  top: 0; }
+baz {b: foo()}
 SCSS
-    assert(false, "Expected syntax error")
-  rescue Sass::SyntaxError => e
-    assert_equal 'Invalid CSS after "": expected selector, was "0%"', e.message
-    assert_equal 1, e.sass_line
   end
 
-  def test_selector_rule_in_keyframes
-    render <<SCSS
-@keyframes identifier {
-  .foo {
-    top: 0; } }
-SCSS
-    assert(false, "Expected syntax error")
-  rescue Sass::SyntaxError => e
-    assert_equal 'Invalid CSS after "": expected keyframes selector (e.g. 10%), was ".foo"', e.message
-    assert_equal 2, e.sass_line
-  end
+  ## Errors
 
   def test_nested_mixin_def_is_scoped
     render <<SCSS
@@ -3292,7 +1609,7 @@ foo {
 SCSS
     assert(false, "Expected syntax error")
   rescue Sass::SyntaxError => e
-    assert_equal 'Invalid CSS after "  .bar:baz <fail>": expected expression (e.g. 1px, bold), was "; }"', e.message
+    assert_equal 'Invalid CSS after "  .bar:baz ": expected "{", was "<fail>; }"', e.message
     assert_equal 2, e.sass_line
   end
 
@@ -3402,7 +1719,7 @@ SCSS
 
   def test_parent_in_mid_selector_error
     assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render <<SCSS}
-Invalid CSS after ".foo": expected "{", was "&.bar"
+Invalid CSS after "  .foo": expected "{", was "&.bar {a: b}"
 
 "&.bar" may only be used at the beginning of a compound selector.
 MESSAGE
@@ -3414,7 +1731,7 @@ SCSS
 
   def test_parent_after_selector_error
     assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render <<SCSS}
-Invalid CSS after ".foo.bar": expected "{", was "&"
+Invalid CSS after "  .foo.bar": expected "{", was "& {a: b}"
 
 "&" may only be used at the beginning of a compound selector.
 MESSAGE
@@ -3426,7 +1743,7 @@ SCSS
 
   def test_double_parent_selector_error
     assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render <<SCSS}
-Invalid CSS after "&": expected "{", was "&"
+Invalid CSS after "  &": expected "{", was "& {a: b}"
 
 "&" may only be used at the beginning of a compound selector.
 MESSAGE
@@ -3444,101 +1761,8 @@ MESSAGE
 SCSS
   end
 
-  def test_failed_parent_selector_with_suffix
-    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
-Invalid parent selector for "&-bar": "*"
-MESSAGE
-* {
-  &-bar {a: b}
-}
-SCSS
-
-    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
-Invalid parent selector for "&-bar": "[foo=bar]"
-MESSAGE
-[foo=bar] {
-  &-bar {a: b}
-}
-SCSS
-
-    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
-Invalid parent selector for "&-bar": "::nth-child(2n+1)"
-MESSAGE
-::nth-child(2n+1) {
-  &-bar {a: b}
-}
-SCSS
-
-    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
-Invalid parent selector for "&-bar": ":not(.foo)"
-MESSAGE
-:not(.foo) {
-  &-bar {a: b}
-}
-SCSS
-
-    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
-Invalid parent selector for "&-bar": ".foo +"
-MESSAGE
-.foo + {
-  &-bar {a: b}
-}
-SCSS
-  end
-
-  def test_empty_media_query_error
-    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
-Invalid CSS after "": expected media query list, was ""
-MESSAGE
-@media \#{""} {
-  foo {a: b}
-}
-SCSS
-  end
-
-  def test_newline_in_property_value
-    assert_equal(<<CSS, render(<<SCSS))
-.foo {
-  bar: "bazbang"; }
-CSS
-.foo {
-  $var: "baz\\
-bang";
-  bar: $var;
-}
-SCSS
-  end
-
-  def test_raw_newline_warning
-    assert_warning(<<MESSAGE.rstrip) {assert_equal(<<CSS, render(<<SCSS))}
-DEPRECATION WARNING on line 2, column 9 of #{filename_for_test :scss}:
-Unescaped multiline strings are deprecated and will be removed in a future version of Sass.
-To include a newline in a string, use "\\a" or "\\a " as in CSS.
-MESSAGE
-.foo {
-  bar: "baz\\a bang"; }
-CSS
-.foo {
-  $var: "baz
-bang";
-  bar: $var;
-}
-SCSS
-  end
-
   # Regression
-
-  def test_top_level_unknown_directive_in_at_root
-    assert_equal(<<CSS, render(<<SCSS))
-@fblthp {
-  a: b; }
-CSS
-@at-root {
-  @fblthp {a: b}
-}
-SCSS
-  end
-
+ 
   def test_parent_ref_with_newline
     assert_equal(<<CSS, render(<<SCSS))
 a.c
@@ -3550,24 +1774,6 @@ a
 SCSS
   end
 
-  def test_parent_ref_in_nested_at_root
-    assert_equal(<<CSS, render(<<SCSS))
-#test {
-  border: 0; }
-  #test:hover {
-    display: none; }
-CSS
-a {
-  @at-root #test {
-    border: 0;
-    &:hover{
-      display: none;
-    }
-  }
-}
-SCSS
-  end
-
   def test_loud_comment_in_compressed_mode
     assert_equal(<<CSS, render(<<SCSS))
 /*! foo */
@@ -3861,10 +2067,10 @@ SCSS
 }
 .aaa .aaa .aaa {
   background-color: black;
-}
+}   
 .bbb {
   @extend .aaa;
-}
+} 
 .xxx {
   @extend .bbb;
 }
@@ -3875,7 +2081,7 @@ SCSS
   @extend .bbb;
 }
 SCSS
-    Sass::SCSS::Parser.new(template, "test.scss", nil).parse
+    Sass::SCSS::Parser.new(template, "test.scss").parse
   end
 
   def test_extend_in_media_in_rule