sass 3.3.0 → 3.4.25

data/test/sass/script_test.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
 require File.dirname(__FILE__) + '/../test_helper'
 require 'sass/engine'
 
@@ -17,35 +18,67 @@ module Sass::Script::Functions
   include Sass::Script::Functions::UserFunctions
 end
 
-class SassScriptTest < Test::Unit::TestCase
+class SassScriptTest < MiniTest::Test
   include Sass::Script
 
-  def test_color_checks_input
-    assert_raise_message(ArgumentError, "Blue value -1 must be between 0 and 255") {Sass::Script::Value::Color.new([1, 2, -1])}
-    assert_raise_message(ArgumentError, "Red value 256 must be between 0 and 255") {Sass::Script::Value::Color.new([256, 2, 3])}
+  def test_color_clamps_input
+    assert_equal 0, Sass::Script::Value::Color.new([1, 2, -1]).blue
+    assert_equal 255, Sass::Script::Value::Color.new([256, 2, 3]).red
   end
 
-  def test_color_checks_rgba_input
-    assert_raise_message(ArgumentError, "Alpha channel 1.1 must be between 0 and 1") {Sass::Script::Value::Color.new([1, 2, 3, 1.1])}
-    assert_raise_message(ArgumentError, "Alpha channel -0.1 must be between 0 and 1") {Sass::Script::Value::Color.new([1, 2, 3, -0.1])}
+  def test_color_clamps_rgba_input
+    assert_equal 1, Sass::Script::Value::Color.new([1, 2, 3, 1.1]).alpha
+    assert_equal 0, Sass::Script::Value::Color.new([1, 2, 3, -0.1]).alpha
+  end
+
+  def test_color_from_hex
+    assert_equal Sass::Script::Value::Color.new([0,0,0]), Sass::Script::Value::Color.from_hex('000000')
+    assert_equal Sass::Script::Value::Color.new([0,0,0]), Sass::Script::Value::Color.from_hex('#000000')
   end
 
   def test_string_escapes
     assert_equal "'", resolve("\"'\"")
     assert_equal '"', resolve("\"\\\"\"")
-    assert_equal "\\\\", resolve("\"\\\\\"")
-    assert_equal "\\02fa", resolve("\"\\02fa\"")
-
-    assert_equal "'", resolve("'\\''")
-    assert_equal '"', resolve("'\"'")
-    assert_equal "\\\\", resolve("'\\\\'")
-    assert_equal "\\02fa", resolve("'\\02fa'")
+    assert_equal "\\", resolve("\"\\\\\"")
+    assert_equal "☃", resolve("\"\\2603\"")
+    assert_equal "☃f", resolve("\"\\2603 f\"")
+    assert_equal "☃x", resolve("\"\\2603x\"")
+    assert_equal "\\2603", resolve("\"\\\\2603\"")
+    assert_equal "\#{foo}", resolve("\"\\\#{foo}\"")
+
+    # U+FFFD is the replacement character, "�".
+    assert_equal [0xFFFD].pack("U"), resolve("\"\\0\"")
+    assert_equal [0xFFFD].pack("U"), resolve("\"\\FFFFFF\"")
+    assert_equal [0xFFFD].pack("U"), resolve("\"\\D800\"")
+    assert_equal [0xD7FF].pack("U"), resolve("\"\\D7FF\"")
+    assert_equal [0xFFFD].pack("U"), resolve("\"\\DFFF\"")
+    assert_equal [0xE000].pack("U"), resolve("\"\\E000\"")
+  end
+
+  def test_string_escapes_are_resolved_before_operators
+    assert_equal "true", resolve('"abc" == "\61\62\63"')
+  end
+
+  def test_string_quote
+    assert_equal '"foo"', resolve_quoted('"foo"')
+    assert_equal "'f\"oo'", resolve_quoted('"f\"oo"')
+    assert_equal "\"f'oo\"", resolve_quoted("'f\\'oo'")
+    assert_equal "\"f'o\\\"o\"", resolve_quoted("'f\\'o\"o'")
+    assert_equal '"foo bar"', resolve_quoted('"foo\20 bar"')
+    assert_equal '"foo\a bar"', resolve_quoted('"foo\a bar"')
+    assert_equal '"x\ay"', resolve_quoted('"x\a y"')
+    assert_equal '"\a  "', resolve_quoted('"\a\20"')
+    assert_equal '"\a abcdef"', resolve_quoted('"\a abcdef"')
+    assert_equal '"☃abcdef"', resolve_quoted('"\2603 abcdef"')
+    assert_equal '"\\\\"', resolve_quoted('"\\\\"')
+    assert_equal '"foobar"', resolve_quoted("\"foo\\\nbar\"")
+    assert_equal '"#{foo}"', resolve_quoted("\"\\\#{foo}\"")
   end
 
   def test_color_names
     assert_equal "white", resolve("white")
-    assert_equal "white", resolve("#ffffff")
-    assert_equal "#fffffe", resolve("white - #000001")
+    assert_equal "#ffffff", resolve("#ffffff")
+    silence_warnings {assert_equal "#fffffe", resolve("white - #000001")}
     assert_equal "transparent", resolve("transparent")
     assert_equal "transparent", resolve("rgba(0, 0, 0, 0)")
   end
@@ -64,36 +97,63 @@ class SassScriptTest < Test::Unit::TestCase
   end
 
   def test_rgba_color_math
-    assert_equal "rgba(50, 50, 100, 0.35)", resolve("rgba(1, 1, 2, 0.35) * rgba(50, 50, 50, 0.35)")
-    assert_equal "rgba(52, 52, 52, 0.25)", resolve("rgba(2, 2, 2, 0.25) + rgba(50, 50, 50, 0.25)")
+    silence_warnings {assert_equal "rgba(50, 50, 100, 0.35)", resolve("rgba(1, 1, 2, 0.35) * rgba(50, 50, 50, 0.35)")}
+    silence_warnings {assert_equal "rgba(52, 52, 52, 0.25)", resolve("rgba(2, 2, 2, 0.25) + rgba(50, 50, 50, 0.25)")}
 
     assert_raise_message(Sass::SyntaxError, "Alpha channels must be equal: rgba(1, 2, 3, 0.15) + rgba(50, 50, 50, 0.75)") do
-      resolve("rgba(1, 2, 3, 0.15) + rgba(50, 50, 50, 0.75)")
+      silence_warnings {resolve("rgba(1, 2, 3, 0.15) + rgba(50, 50, 50, 0.75)")}
     end
     assert_raise_message(Sass::SyntaxError, "Alpha channels must be equal: #123456 * rgba(50, 50, 50, 0.75)") do
-      resolve("#123456 * rgba(50, 50, 50, 0.75)")
+      silence_warnings {resolve("#123456 * rgba(50, 50, 50, 0.75)")}
     end
     assert_raise_message(Sass::SyntaxError, "Alpha channels must be equal: rgba(50, 50, 50, 0.75) / #123456") do
-      resolve("rgba(50, 50, 50, 0.75) / #123456")
+      silence_warnings {resolve("rgba(50, 50, 50, 0.75) / #123456")}
     end
   end
 
   def test_rgba_number_math
-    assert_equal "rgba(49, 49, 49, 0.75)", resolve("rgba(50, 50, 50, 0.75) - 1")
-    assert_equal "rgba(100, 100, 100, 0.75)", resolve("rgba(50, 50, 50, 0.75) * 2")
+    silence_warnings {assert_equal "rgba(49, 49, 49, 0.75)", resolve("rgba(50, 50, 50, 0.75) - 1")}
+    silence_warnings {assert_equal "rgba(100, 100, 100, 0.75)", resolve("rgba(50, 50, 50, 0.75) * 2")}
   end
 
   def test_rgba_rounding
     assert_equal "rgba(10, 1, 0, 0.12346)", resolve("rgba(10.0, 1.23456789, 0.0, 0.1234567)")
   end
 
+  def test_rgb_calc
+    assert_equal "rgb(calc(255 - 5), 0, 0)", resolve("rgb(calc(255 - 5), 0, 0)")
+  end
+
+  def test_rgba_calc
+    assert_equal "rgba(calc(255 - 5), 0, 0, 0.1)",
+      resolve("rgba(calc(255 - 5), 0, 0, 0.1)")
+    assert_equal "rgba(127, 0, 0, calc(0.1 + 0.5))",
+      resolve("rgba(127, 0, 0, calc(0.1 + 0.5))")
+  end
+
+  def test_rgba_shorthand_calc
+    assert_equal "rgba(255, 0, 0, calc(0.1 + 0.5))",
+      resolve("rgba(red, calc(0.1 + 0.5))")
+  end
+
+  def test_hsl_calc
+    assert_equal "hsl(calc(360 * 5 / 6), 50%, 50%)", resolve("hsl(calc(360 * 5 / 6), 50%, 50%)")
+  end
+
+  def test_hsla_calc
+    assert_equal "hsla(calc(360 * 5 / 6), 50%, 50%, 0.1)",
+      resolve("hsla(calc(360 * 5 / 6), 50%, 50%, 0.1)")
+    assert_equal "hsla(270, 50%, 50%, calc(0.1 + 0.1))",
+      resolve("hsla(270, 50%, 50%, calc(0.1 + 0.1))")
+  end
+
   def test_compressed_colors
     assert_equal "#123456", resolve("#123456", :style => :compressed)
     assert_equal "rgba(1,2,3,0.5)", resolve("rgba(1, 2, 3, 0.5)", :style => :compressed)
     assert_equal "#123", resolve("#112233", :style => :compressed)
     assert_equal "#000", resolve("black", :style => :compressed)
     assert_equal "red", resolve("#f00", :style => :compressed)
-    assert_equal "blue", resolve("#00f", :style => :compressed)
+    assert_equal "blue", resolve("blue", :style => :compressed)
     assert_equal "navy", resolve("#000080", :style => :compressed)
     assert_equal "navy #fff", resolve("#000080 white", :style => :compressed)
     assert_equal "This color is #fff", resolve('"This color is #{ white }"', :style => :compressed)
@@ -131,43 +191,45 @@ class SassScriptTest < Test::Unit::TestCase
   end
 
   def test_interpolation_near_operators
-    assert_equal '3 , 7', resolve('#{1 + 2} , #{3 + 4}')
-    assert_equal '3, 7', resolve('#{1 + 2}, #{3 + 4}')
-    assert_equal '3 ,7', resolve('#{1 + 2} ,#{3 + 4}')
-    assert_equal '3,7', resolve('#{1 + 2},#{3 + 4}')
-    assert_equal '3, 7, 11', resolve('#{1 + 2}, #{3 + 4}, #{5 + 6}')
-    assert_equal '3, 7, 11', resolve('3, #{3 + 4}, 11')
-    assert_equal '3, 7, 11', resolve('3, 7, #{5 + 6}')
-
-    assert_equal '3 / 7', resolve('3 / #{3 + 4}')
-    assert_equal '3 /7', resolve('3 /#{3 + 4}')
-    assert_equal '3/ 7', resolve('3/ #{3 + 4}')
-    assert_equal '3/7', resolve('3/#{3 + 4}')
-
-    assert_equal '3 * 7', resolve('#{1 + 2} * 7')
-    assert_equal '3* 7', resolve('#{1 + 2}* 7')
-    assert_equal '3 *7', resolve('#{1 + 2} *7')
-    assert_equal '3*7', resolve('#{1 + 2}*7')
-
-    assert_equal '-3', resolve('-#{1 + 2}')
-    assert_equal '- 3', resolve('- #{1 + 2}')
-
-    assert_equal '5 + 3 * 7', resolve('5 + #{1 + 2} * #{3 + 4}')
-    assert_equal '5 +3 * 7', resolve('5 +#{1 + 2} * #{3 + 4}')
-    assert_equal '5+3 * 7', resolve('5+#{1 + 2} * #{3 + 4}')
-    assert_equal '3 * 7 + 5', resolve('#{1 + 2} * #{3 + 4} + 5')
-    assert_equal '3 * 7+ 5', resolve('#{1 + 2} * #{3 + 4}+ 5')
-    assert_equal '3 * 7+5', resolve('#{1 + 2} * #{3 + 4}+5')
-
-    assert_equal '5/3 + 7', resolve('5 / (#{1 + 2} + #{3 + 4})')
-    assert_equal '5/3 + 7', resolve('5 /(#{1 + 2} + #{3 + 4})')
-    assert_equal '5/3 + 7', resolve('5 /( #{1 + 2} + #{3 + 4} )')
-    assert_equal '3 + 7/5', resolve('(#{1 + 2} + #{3 + 4}) / 5')
-    assert_equal '3 + 7/5', resolve('(#{1 + 2} + #{3 + 4})/ 5')
-    assert_equal '3 + 7/5', resolve('( #{1 + 2} + #{3 + 4} )/ 5')
-
-    assert_equal '3 + 5', resolve('#{1 + 2} + 2 + 3')
-    assert_equal '3 +5', resolve('#{1 + 2} +2 + 3')
+    silence_warnings do
+      assert_equal '3 , 7', resolve('#{1 + 2} , #{3 + 4}')
+      assert_equal '3, 7', resolve('#{1 + 2}, #{3 + 4}')
+      assert_equal '3 ,7', resolve('#{1 + 2} ,#{3 + 4}')
+      assert_equal '3,7', resolve('#{1 + 2},#{3 + 4}')
+      assert_equal '3, 7, 11', resolve('#{1 + 2}, #{3 + 4}, #{5 + 6}')
+      assert_equal '3, 7, 11', resolve('3, #{3 + 4}, 11')
+      assert_equal '3, 7, 11', resolve('3, 7, #{5 + 6}')
+
+      assert_equal '3 / 7', resolve('3 / #{3 + 4}')
+      assert_equal '3 /7', resolve('3 /#{3 + 4}')
+      assert_equal '3/ 7', resolve('3/ #{3 + 4}')
+      assert_equal '3/7', resolve('3/#{3 + 4}')
+
+      assert_equal '3 * 7', resolve('#{1 + 2} * 7')
+      assert_equal '3* 7', resolve('#{1 + 2}* 7')
+      assert_equal '3 *7', resolve('#{1 + 2} *7')
+      assert_equal '3*7', resolve('#{1 + 2}*7')
+
+      assert_equal '-3', resolve('-#{1 + 2}')
+      assert_equal '- 3', resolve('- #{1 + 2}')
+
+      assert_equal '5 + 3 * 7', resolve('5 + #{1 + 2} * #{3 + 4}')
+      assert_equal '5 +3 * 7', resolve('5 +#{1 + 2} * #{3 + 4}')
+      assert_equal '5+3 * 7', resolve('5+#{1 + 2} * #{3 + 4}')
+      assert_equal '3 * 7 + 5', resolve('#{1 + 2} * #{3 + 4} + 5')
+      assert_equal '3 * 7+ 5', resolve('#{1 + 2} * #{3 + 4}+ 5')
+      assert_equal '3 * 7+5', resolve('#{1 + 2} * #{3 + 4}+5')
+
+      assert_equal '5/3 + 7', resolve('5 / (#{1 + 2} + #{3 + 4})')
+      assert_equal '5/3 + 7', resolve('5 /(#{1 + 2} + #{3 + 4})')
+      assert_equal '5/3 + 7', resolve('5 /( #{1 + 2} + #{3 + 4} )')
+      assert_equal '3 + 7/5', resolve('(#{1 + 2} + #{3 + 4}) / 5')
+      assert_equal '3 + 7/5', resolve('(#{1 + 2} + #{3 + 4})/ 5')
+      assert_equal '3 + 7/5', resolve('( #{1 + 2} + #{3 + 4} )/ 5')
+
+      assert_equal '3 + 5', resolve('#{1 + 2} + 2 + 3')
+      assert_equal '3 +5', resolve('#{1 + 2} +2 + 3')
+    end
   end
 
   def test_string_interpolation
@@ -180,6 +242,18 @@ class SassScriptTest < Test::Unit::TestCase
     assert_equal "foo1bar5baz4bang", resolve('\'foo#{1 + "bar#{2 + 3}baz" + 4}bang\'')
   end
 
+  def test_interpolation_in_interpolation
+    assert_equal 'foo', resolve('#{#{foo}}')
+    assert_equal 'foo', resolve('"#{#{foo}}"')
+    assert_equal 'foo', resolve('#{"#{foo}"}')
+    assert_equal 'foo', resolve('"#{"#{foo}"}"')
+  end
+
+  def test_interpolation_with_newline
+    assert_equal "\nbang", resolve('"#{"\a "}bang"')
+    assert_equal "\n\nbang", resolve('"#{"\a "}\a bang"')
+  end
+
   def test_rule_interpolation
     assert_equal(<<CSS, render(<<SASS))
 foo bar baz bang {
@@ -255,8 +329,8 @@ SASS
     assert_equal eval('1 2 3.0'), eval('1 2 3')
     assert_equal eval('1, 2, 3.0'), eval('1, 2, 3')
     assert_equal eval('(1 2), (3, 4), (5 6)'), eval('(1 2), (3, 4), (5 6)')
-    assert_not_equal eval('1, 2, 3'), eval('1 2 3')
-    assert_not_equal eval('1'), eval('"1"')
+    refute_equal eval('1, 2, 3'), eval('1 2 3')
+    refute_equal eval('1'), eval('"1"')
   end
 
   def test_booleans
@@ -310,12 +384,24 @@ SASS
     assert_equal "-1", resolve("-1")
   end
 
+  def test_subtraction_vs_minus_vs_identifier
+    assert_equal "0.25em", resolve("1em-.75")
+    assert_equal "0.25em", resolve("1em-0.75")
+    assert_equal "1em -0.75", resolve("1em -.75")
+    assert_equal "1em -0.75", resolve("1em -0.75")
+    assert_equal "1em- 0.75", resolve("1em- .75")
+    assert_equal "1em- 0.75", resolve("1em- 0.75")
+    assert_equal "0.25em", resolve("1em - .75")
+    assert_equal "0.25em", resolve("1em - 0.75")
+  end
+
   def test_string_ops
     assert_equal '"foo" "bar"', resolve('"foo" "bar"')
     assert_equal "true 1", resolve('true 1')
     assert_equal '"foo", "bar"', resolve("'foo' , 'bar'")
     assert_equal "true, 1", resolve('true , 1')
     assert_equal "foobar", resolve('"foo" + "bar"')
+    assert_equal "\nfoo\nxyz", resolve('"\a foo" + "\axyz"')
     assert_equal "true1", resolve('true + 1')
     assert_equal '"foo"-"bar"', resolve("'foo' - 'bar'")
     assert_equal "true-1", resolve('true - 1')
@@ -418,16 +504,65 @@ SASS
 
   def test_functions
     assert_equal "#80ff80", resolve("hsl(120, 100%, 75%)")
-    assert_equal "#81ff81", resolve("hsl(120, 100%, 75%) + #010001")
+    silence_warnings {assert_equal "#81ff81", resolve("hsl(120, 100%, 75%) + #010001")}
   end
 
   def test_operator_unit_conversion
     assert_equal "1.1cm", resolve("1cm + 1mm")
+    assert_equal "8q", resolve("4q + 1mm")
+    assert_equal "40.025cm", resolve("40cm + 1q")
     assert_equal "2in", resolve("1in + 96px")
     assert_equal "true", resolve("2mm < 1cm")
     assert_equal "true", resolve("10mm == 1cm")
-    assert_equal "true", resolve("1 == 1cm")
     assert_equal "true", resolve("1.1cm == 11mm")
+    assert_equal "true", resolve("2mm == 8q")
+    assert_equal "false", resolve("2px > 3q")
+
+    Sass::Deprecation.allow_double_warnings do
+      assert_warning(<<WARNING) {assert_equal "true", resolve("1 == 1cm")}
+DEPRECATION WARNING on line 1 of test_operator_unit_conversion_inline.sass:
+The result of `1 == 1cm` will be `false` in future releases of Sass.
+Unitless numbers will no longer be equal to the same numbers with units.
+WARNING
+
+      assert_warning(<<WARNING) {assert_equal "false", resolve("1 != 1cm")}
+DEPRECATION WARNING on line 1 of test_operator_unit_conversion_inline.sass:
+The result of `1 != 1cm` will be `true` in future releases of Sass.
+Unitless numbers will no longer be equal to the same numbers with units.
+WARNING
+    end
+  end
+
+  def test_length_units
+    assert_equal "2.54", resolve("(1in/1cm)")
+    assert_equal "2.3622", resolve("(1cm/1pc)")
+    assert_equal "4.23333", resolve("(1pc/1mm)")
+    assert_equal "2.83465", resolve("(1mm/1pt)")
+    assert_equal "1.33333", resolve("(1pt/1px)")
+    assert_equal "0.01042", resolve("(1px/1in)")
+    assert_equal "1.05833", resolve("(1px/1q)")
+    assert_equal "0.05906", resolve("(1q/1pc)")
+  end
+
+  def test_angle_units
+    assert_equal "1.11111", resolve("(1deg/1grad)")
+    assert_equal "0.01571", resolve("(1grad/1rad)")
+    assert_equal "0.15915", resolve("(1rad/1turn)")
+    assert_equal "360", resolve("(1turn/1deg)")
+  end
+
+  def test_time_units
+    assert_equal "1000", resolve("(1s/1ms)")
+  end
+
+  def test_frequency_units
+    assert_equal "0.001", resolve("(1Hz/1kHz)")
+  end
+
+  def test_resolution_units
+    assert_equal "0.3937", resolve("(1dpi/1dpcm)")
+    assert_equal "0.02646", resolve("(1dpcm/1dppx)")
+    assert_equal "96", resolve("(1dppx/1dpi)")
   end
 
   def test_operations_have_options
@@ -462,23 +597,30 @@ SASS
     assert_equal "0.5", resolve("$var", {}, env("var" => eval("1px/2px")))
   end
 
-  def test_colors_with_wrong_number_of_digits
-    assert_raise_message(Sass::SyntaxError,
-      "Colors must have either three or six digits: '#0'") {eval("#0")}
+  # Regression test for issue 1786.
+  def test_slash_division_within_list
+    assert_equal "1 1/2 1/2", resolve("(1 1/2 1/2)")
+    assert_equal "1/2 1/2", resolve("(1/2 1/2)")
+    assert_equal "1/2", resolve("(1/2,)")
+  end
+
+  def test_non_ident_colors_with_wrong_number_of_digits
     assert_raise_message(Sass::SyntaxError,
-      "Colors must have either three or six digits: '#12'") {eval("#12")}
+      'Invalid CSS after "": expected expression (e.g. 1px, bold), was "#1"') {eval("#1")}
     assert_raise_message(Sass::SyntaxError,
-      "Colors must have either three or six digits: '#abcd'") {eval("#abcd")}
+      'Invalid CSS after "": expected expression (e.g. 1px, bold), was "#12"') {eval("#12")}
     assert_raise_message(Sass::SyntaxError,
-      "Colors must have either three or six digits: '#abcdE'") {eval("#abcdE")}
+      'Invalid CSS after "": expected expression (e.g. 1px, bold), was "#1234"') {eval("#1234")}
     assert_raise_message(Sass::SyntaxError,
-      "Colors must have either three or six digits: '#abcdEFA'") {eval("#abcdEFA")}
+      'Invalid CSS after "": expected expression (e.g. 1px, bold), was "#12345"') {eval("#12345")}
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "": expected expression (e.g. ' \
+      '1px, bold), was "#1234567"') {eval("#1234567")}
   end
 
   def test_case_insensitive_color_names
-    assert_equal "blue", resolve("BLUE")
-    assert_equal "red", resolve("rEd")
-    assert_equal "#7f4000", resolve("mix(GrEeN, ReD)")
+    assert_equal "BLUE", resolve("BLUE")
+    assert_equal "rEd", resolve("rEd")
+    assert_equal "#804000", resolve("mix(GrEeN, ReD)")
   end
 
   def test_empty_list
@@ -523,7 +665,7 @@ SASS
     assert_raise_message(Sass::SyntaxError, 'Duplicate key 2px in map (2px: bar, 1px + 1px: baz).') do
       eval("(2px: bar, 1px + 1px: baz)")
     end
-    assert_raise_message(Sass::SyntaxError, 'Duplicate key #0000ff in map (blue: bar, blue: baz).') do
+    assert_raise_message(Sass::SyntaxError, 'Duplicate key #0000ff in map (blue: bar, #00f: baz).') do
       eval("(blue: bar, #00f: baz)")
     end
   end
@@ -558,7 +700,7 @@ SASS
     return if RUBY_PLATFORM =~ /java/
 
     # Don't validate the message; it's different on Rubinius.
-    assert_raise(ArgumentError) {resolve("arg-error()")}
+    assert_raises(ArgumentError) {resolve("arg-error()")}
   end
 
   def test_shallow_argument_error_unwrapped
@@ -570,49 +712,37 @@ SASS
     assert_equal "true", resolve("$ie or $undef", {}, env('ie' => Sass::Script::Value::Bool.new(true)))
   end
 
-  def test_setting_global_variable_locally_warns
-    assert_warning(<<WARNING) {assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))}
-DEPRECATION WARNING on line 4 of test_setting_global_variable_locally_warns_inline.scss:
-Assigning to global variable "$var" by default is deprecated.
-In future versions of Sass, this will create a new local variable.
-If you want to assign to the global variable, use "$var: x !global" instead.
-Note that this will be incompatible with Sass 3.2.
-WARNING
-.foo {
-  a: x; }
-
-.bar {
-  b: x; }
-CSS
-$var: 1;
-
-.foo {
-  $var: x;
-  a: $var;
-}
-
-.bar {
-  b: $var;
-}
-SCSS
-  end
-
-  def test_setting_global_variable_locally_warns_only_once
-    assert_warning(<<WARNING) {assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))}
-DEPRECATION WARNING on line 3 of test_setting_global_variable_locally_warns_only_once_inline.scss:
-Assigning to global variable "$var" by default is deprecated.
-In future versions of Sass, this will create a new local variable.
-If you want to assign to the global variable, use "$var: x !global" instead.
-Note that this will be incompatible with Sass 3.2.
-WARNING
-CSS
-$var: 1;
-
-@mixin foo {$var: x}
-@include foo;
-@include foo;
-@include foo;
-SCSS
+  def test_selector
+    env = Sass::Environment.new
+    assert_equal "true", resolve("& == null", {}, env)
+
+    env.selector = selector('.foo.bar .baz.bang, .bip.bop')
+    assert_equal ".foo.bar .baz.bang, .bip.bop", resolve("&", {}, env)
+    assert_equal ".foo.bar .baz.bang", resolve("nth(&, 1)", {}, env)
+    assert_equal ".bip.bop", resolve("nth(&, 2)", {}, env)
+    assert_equal ".foo.bar", resolve("nth(nth(&, 1), 1)", {}, env)
+    assert_equal ".baz.bang", resolve("nth(nth(&, 1), 2)", {}, env)
+    assert_equal ".bip.bop", resolve("nth(nth(&, 2), 1)", {}, env)
+    assert_equal "string", resolve("type-of(nth(nth(&, 1), 1))", {}, env)
+
+    env.selector = selector('.foo > .bar')
+    assert_equal ".foo > .bar", resolve("&", {}, env)
+    assert_equal ".foo > .bar", resolve("nth(&, 1)", {}, env)
+    assert_equal ".foo", resolve("nth(nth(&, 1), 1)", {}, env)
+    assert_equal ">", resolve("nth(nth(&, 1), 2)", {}, env)
+    assert_equal ".bar", resolve("nth(nth(&, 1), 3)", {}, env)
+  end
+
+  def test_selector_with_newlines
+    env = Sass::Environment.new
+    env.selector = selector(".foo.bar\n.baz.bang,\n\n.bip.bop")
+    assert_equal ".foo.bar .baz.bang, .bip.bop", resolve("&", {}, env)
+    assert_equal ".foo.bar .baz.bang", resolve("nth(&, 1)", {}, env)
+    assert_equal ".bip.bop", resolve("nth(&, 2)", {}, env)
+    assert_equal ".foo.bar", resolve("nth(nth(&, 1), 1)", {}, env)
+    assert_equal ".baz.bang", resolve("nth(nth(&, 1), 2)", {}, env)
+    assert_equal ".bip.bop", resolve("nth(nth(&, 2), 1)", {}, env)
+    assert_equal "string", resolve("type-of(nth(nth(&, 1), 1))", {}, env)
   end
 
   def test_setting_global_variable_globally
@@ -637,7 +767,7 @@ $var: 2;
 SCSS
   end
 
-  def test_setting_global_variable_with_flag
+  def test_setting_global_variable_locally
     assert_no_warning {assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))}
 .bar {
   a: x;
@@ -663,7 +793,7 @@ $var3: 3;
 SCSS
   end
 
-  def test_setting_global_variable_with_flag_and_default
+  def test_setting_global_variable_locally_with_default
     assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))
 .bar {
   a: 1;
@@ -688,10 +818,267 @@ $var1: 1;
 SCSS
   end
 
+  def test_setting_local_variable
+    assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))
+.a {
+  value: inside; }
+
+.b {
+  value: outside; }
+CSS
+$var: outside;
+
+.a {
+  $var: inside;
+  value: $var;
+}
+
+.b {
+  value: $var;
+}
+SCSS
+  end
+
+  def test_setting_local_variable_from_inner_scope
+    assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))
+.a .b {
+  value: inside; }
+.a .c {
+  value: inside; }
+CSS
+.a {
+  $var: outside;
+
+  .b {
+    $var: inside;
+    value: $var;
+  }
+
+  .c {
+    value: $var;
+  }
+}
+SCSS
+  end
+
+  def test_if_can_assign_to_global_variables
+    assert_equal <<CSS, render(<<SCSS, :syntax => :scss)
+.a {
+  b: 2; }
+CSS
+$var: 1;
+@if true {$var: 2}
+.a {b: $var}
+SCSS
+  end
+
+  def test_else_can_assign_to_global_variables
+    assert_equal <<CSS, render(<<SCSS, :syntax => :scss)
+.a {
+  b: 2; }
+CSS
+$var: 1;
+@if false {}
+@else {$var: 2}
+.a {b: $var}
+SCSS
+  end
+
+  def test_for_can_assign_to_global_variables
+    assert_equal <<CSS, render(<<SCSS, :syntax => :scss)
+.a {
+  b: 2; }
+CSS
+$var: 1;
+@for $i from 1 to 2 {$var: 2}
+.a {b: $var}
+SCSS
+  end
+
+  def test_each_can_assign_to_global_variables
+    assert_equal <<CSS, render(<<SCSS, :syntax => :scss)
+.a {
+  b: 2; }
+CSS
+$var: 1;
+@each $a in 1 {$var: 2}
+.a {b: $var}
+SCSS
+  end
+
+  def test_while_can_assign_to_global_variables
+    assert_equal <<CSS, render(<<SCSS, :syntax => :scss)
+.a {
+  b: 2; }
+CSS
+$var: 1;
+@while $var != 2 {$var: 2}
+.a {b: $var}
+SCSS
+  end
+
+  def test_if_doesnt_leak_local_variables
+    assert_raise_message(Sass::SyntaxError, 'Undefined variable: "$var".') do
+      render(<<SCSS, :syntax => :scss)
+@if true {$var: 1}
+.a {b: $var}
+SCSS
+    end
+  end
+
+  def test_else_doesnt_leak_local_variables
+    assert_raise_message(Sass::SyntaxError, 'Undefined variable: "$var".') do
+      render(<<SCSS, :syntax => :scss)
+@if false {}
+@else {$var: 1}
+.a {b: $var}
+SCSS
+    end
+  end
+
+  def test_for_doesnt_leak_local_variables
+    assert_raise_message(Sass::SyntaxError, 'Undefined variable: "$var".') do
+      render(<<SCSS, :syntax => :scss)
+@for $i from 1 to 2 {$var: 1}
+.a {b: $var}
+SCSS
+    end
+  end
+
+  def test_each_doesnt_leak_local_variables
+    assert_raise_message(Sass::SyntaxError, 'Undefined variable: "$var".') do
+      render(<<SCSS, :syntax => :scss)
+@each $a in 1 {$var: 1}
+.a {b: $var}
+SCSS
+    end
+  end
+
+  def test_while_doesnt_leak_local_variables
+    assert_raise_message(Sass::SyntaxError, 'Undefined variable: "$var".') do
+      render(<<SCSS, :syntax => :scss)
+$iter: true;
+@while $iter {
+  $var: 1;
+  $iter: false;
+}
+.a {b: $var}
+SCSS
+    end
+  end
+
+  def test_color_format_is_preserved_by_default
+    assert_equal "blue", resolve("blue")
+    assert_equal "bLuE", resolve("bLuE")
+    assert_equal "#00f", resolve("#00f")
+    assert_equal "blue #00F", resolve("blue #00F")
+    assert_equal "blue", resolve("nth(blue #00F, 1)")
+    assert_equal "#00F", resolve("nth(blue #00F, 2)")
+  end
+
+  def test_color_format_isnt_always_preserved_in_compressed_style
+    assert_equal "red", resolve("red", :style => :compressed)
+    assert_equal "red", resolve("#f00", :style => :compressed)
+    assert_equal "red red", resolve("red #f00", :style => :compressed)
+    assert_equal "red", resolve("nth(red #f00, 2)", :style => :compressed)
+  end
+
+  def test_color_format_is_sometimes_preserved_in_compressed_style
+    assert_equal "ReD", resolve("ReD", :style => :compressed)
+    assert_equal "blue", resolve("blue", :style => :compressed)
+    assert_equal "#00f", resolve("#00f", :style => :compressed)
+  end
+
+  def test_color_format_isnt_preserved_when_modified
+    assert_equal "magenta", resolve("change-color(#f00, $blue: 255)")
+  end
+
+  def test_ids
+    assert_equal "#foo", resolve("#foo")
+    assert_equal "#abcd", resolve("#abcd")
+    assert_equal "#abc-def", resolve("#abc-def")
+    assert_equal "#abc_def", resolve("#abc_def")
+    assert_equal "#uvw-xyz", resolve("#uvw-xyz")
+    assert_equal "#uvw_xyz", resolve("#uvw_xyz")
+    assert_equal "#uvwxyz", resolve("#uvw + xyz")
+  end
+
+  def test_scientific_notation
+    assert_equal "2000", resolve("2e3")
+    assert_equal "2000", resolve("2E3")
+    assert_equal "2000", resolve("2e+3")
+    assert_equal "2000em", resolve("2e3em")
+    assert_equal "25000000000", resolve("2.5e10")
+    assert_equal "0.1234", resolve("1234e-4")
+    assert_equal "12.34", resolve("1.234e1")
+  end
+
+  def test_identifier_units
+    assert_equal "5-foo", resolve("2-foo + 3-foo")
+    assert_equal "5-foo-", resolve("2-foo- + 3-foo-")
+    assert_equal "5-\\u2603", resolve("2-\\u2603 + 3-\\u2603")
+  end
+
+  def test_backslash_newline_in_string
+    assert_equal 'foobar', resolve("\"foo\\\nbar\"")
+    assert_equal 'foobar', resolve("'foo\\\nbar'")
+  end
+
+  def test_unclosed_special_fun
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "calc(foo()": expected ")", was ""') do
+      resolve("calc(foo()")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "calc(#{\')\'}": expected ")", was ""') do
+      resolve("calc(\#{')'}")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "calc(#{foo": expected "}", was ""') do
+      resolve("calc(\#{foo")
+    end
+  end
+
+  def test_special_fun_with_interpolation
+    assert_equal "calc())", resolve("calc(\#{')'})")
+    assert_equal "calc(# {foo})", resolve("calc(# {foo})")
+  end
+
   # Regression Tests
 
+  def test_interpolation_after_string
+    assert_equal '"foobar" 2', resolve('"foobar" #{2}')
+    assert_equal "calc(1 + 2) 3", resolve('calc(1 + 2) #{3}')
+  end
+
+  def test_repeatedly_modified_color
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  link-color: #161C14;
+  link-color-hover: black;
+  link-color-tap: rgba(22, 28, 20, 0.3); }
+CSS
+$green: #161C14
+$link-color: $green
+$link-color-hover: darken($link-color, 10%)
+$link-color-tap: rgba($green, 0.3)
+
+a
+  link-color: $link-color
+  link-color-hover: $link-color-hover
+  link-color-tap: $link-color-tap
+SASS
+  end
+
+  def test_inspect_divided_numbers
+    assert_equal "1px/2px", resolve("inspect(1px/2px)")
+    assert_equal "0.5", resolve("inspect((1px/2px))")
+  end
+
   def test_minus_without_whitespace
     assert_equal "5px", resolve("15px-10px")
+    assert_equal "5px-", resolve("15px--10px-")
+  end
+
+  def test_minus_preceded_by_comment
+    assert_equal "15px -10px", resolve("15px/**/-10px")
   end
 
   def test_user_defined_function_forces_division
@@ -716,7 +1103,7 @@ CSS
 a
   b: foo() / 2
 SASS
-end
+  end
 
   def test_funcall_has_higher_precedence_than_color_name
     assert_equal "teal(12)", resolve("teal(12)")
@@ -732,6 +1119,17 @@ end
     assert_equal "teal\\+bang(12)", resolve("teal\\+bang(12)")
   end
 
+  def test_and_or_not_disallowed_as_function_names
+    %w[and or not].each do |name|
+      assert_raise_message(Sass::SyntaxError, "Invalid function name \"#{name}\".") do
+        render(<<SASS)
+@function #{name}()
+  @return null
+SASS
+      end
+    end
+  end
+
   def test_interpolation_after_hash
     assert_equal "#2", resolve('"##{1 + 1}"')
   end
@@ -787,15 +1185,208 @@ end
     assert_equal "NaN", resolve("(0.0/0.0)")
   end
 
+  def test_equality_uses_an_epsilon
+    # At least on my machine, this calculation introduces a floating point error:
+    # 29.0 / 7 * 7
+    # => 29.000000000000004
+    assert_equal "true", resolve("29 == (29 / 7 * 7)")
+  end
+
+  def test_compressed_output_of_numbers_with_leading_zeros
+    assert_equal "1.5", resolve("1.5", :style => :compressed)
+    assert_equal ".5", resolve("0.5", :style => :compressed)
+    assert_equal "-.5", resolve("-0.5", :style => :compressed)
+    assert_equal "0.5", resolve("0.5", :style => :compact)
+  end
+
+  def test_interpolation_without_deprecation_warning
+    assert_no_warning {assert_equal "a", resolve('#{a}')}
+    assert_no_warning {assert_equal "abc", resolve('a#{b}c')}
+    assert_no_warning {assert_equal "+ a", resolve('+ #{a}')}
+    assert_no_warning {assert_equal "/ a", resolve('/ #{a}')}
+    assert_no_warning {assert_equal "1 / a", resolve('1 / #{a}')}
+    assert_no_warning {assert_equal "a / b", resolve('#{a} / #{b}')}
+    assert_no_warning {assert_equal "foo(1 = a)", resolve('foo(1 = #{a})')}
+    assert_no_warning {assert_equal "foo(a = b)", resolve('foo(#{a} = #{b})')}
+    assert_no_warning {assert_equal "-a", resolve('-#{a}')}
+    assert_no_warning {assert_equal "1-a", resolve('1-#{a}')}
+    assert_no_warning {assert_equal "a- 1", resolve('#{a}- 1')}
+    assert_no_warning {assert_equal "a-1", resolve('#{a}-1')}
+    assert_no_warning {assert_equal "a-b", resolve('#{a}-#{b}')}
+    assert_no_warning {assert_equal "a1", resolve('#{a}1')}
+    assert_no_warning {assert_equal "ab", resolve('#{a}b')}
+    assert_no_warning {assert_equal "1a", resolve('1#{a}')}
+    assert_no_warning {assert_equal "ba", resolve('b#{a}')}
+  end
+
+  def test_leading_interpolation_with_deprecation_warning
+    assert_equal "ab == 1", resolve_with_interp_warning('#{a + b} == 1')
+    assert_equal "ab != 1", resolve_with_interp_warning('#{a + b} != 1')
+    assert_equal "ab > 1", resolve_with_interp_warning('#{a + b} > 1')
+    assert_equal "ab >= 1", resolve_with_interp_warning('#{a + b} >= 1')
+    assert_equal "ab < 1", resolve_with_interp_warning('#{a + b} < 1')
+    assert_equal "ab <= 1", resolve_with_interp_warning('#{a + b} <= 1')
+    assert_equal "ab + 1", resolve_with_interp_warning('#{a + b} + 1')
+    assert_equal "ab * 1", resolve_with_interp_warning('#{a + b} * 1')
+    assert_equal "ab - 1", resolve_with_interp_warning('#{a + b} - 1')
+    assert_equal "ab % 1", resolve_with_interp_warning('#{a + b} % 1')
+    assert_equal(
+      "abvar",
+      resolve_with_interp_warning(
+        '#{a + b}$var', '"#{a + b}#{$var}"',
+        env('var' => Sass::Script::Value::String.new("var"))))
+    assert_equal(
+      "varab",
+      resolve_with_interp_warning(
+        '$var#{a + b}', '"#{$var}#{a + b}"',
+        env('var' => Sass::Script::Value::String.new("var"))))
+    assert_equal "ab1", resolve_with_interp_warning('#{a + b}(1)', '"#{a + b}1"')
+    assert_equal "1ab", resolve_with_interp_warning('(1)#{a + b}', '"1#{a + b}"')
+  end
+
+  def test_trailing_interpolation_with_deprecation_warning
+    assert_equal "not ab", resolve_with_interp_warning('not #{a + b}')
+    assert_equal "1 and ab", resolve_with_interp_warning('1 and #{a + b}')
+    assert_equal "1 or ab", resolve_with_interp_warning('1 or #{a + b}')
+    assert_equal "1 == ab", resolve_with_interp_warning('1 == #{a + b}')
+    assert_equal "1 != ab", resolve_with_interp_warning('1 != #{a + b}')
+    assert_equal "1 > ab", resolve_with_interp_warning('1 > #{a + b}')
+    assert_equal "1 >= ab", resolve_with_interp_warning('1 >= #{a + b}')
+    assert_equal "1 < ab", resolve_with_interp_warning('1 < #{a + b}')
+    assert_equal "1 <= ab", resolve_with_interp_warning('1 <= #{a + b}')
+    assert_equal "1 + ab", resolve_with_interp_warning('1 + #{a + b}')
+    assert_equal "1 * ab", resolve_with_interp_warning('1 * #{a + b}')
+    assert_equal "1 - ab", resolve_with_interp_warning('1 - #{a + b}')
+    assert_equal "1 % ab", resolve_with_interp_warning('1 % #{a + b}')
+    assert_equal "- ab", resolve_with_interp_warning('- #{a + b}')
+    assert_equal "1- ab", resolve_with_interp_warning('1- #{a + b}')
+    assert_equal "- ab 2 3", resolve_with_interp_warning('- #{a + b} 2 3', '"- #{a + b} #{2 3}"')
+  end
+
+  def test_brackteing_interpolation_with_deprecation_warning
+    assert_equal "ab == cd", resolve_with_interp_warning('#{a + b} == #{c + d}')
+    assert_equal "ab != cd", resolve_with_interp_warning('#{a + b} != #{c + d}')
+    assert_equal "ab > cd", resolve_with_interp_warning('#{a + b} > #{c + d}')
+    assert_equal "ab >= cd", resolve_with_interp_warning('#{a + b} >= #{c + d}')
+    assert_equal "ab < cd", resolve_with_interp_warning('#{a + b} < #{c + d}')
+    assert_equal "ab <= cd", resolve_with_interp_warning('#{a + b} <= #{c + d}')
+    assert_equal "ab + cd", resolve_with_interp_warning('#{a + b} + #{c + d}')
+    assert_equal "ab * cd", resolve_with_interp_warning('#{a + b} * #{c + d}')
+    assert_equal "ab - cd", resolve_with_interp_warning('#{a + b} - #{c + d}')
+    assert_equal "ab % cd", resolve_with_interp_warning('#{a + b} % #{c + d}')
+  end
+
+  def test_interp_warning_formatting
+    resolve_with_interp_warning('#{1} + 1', '"1 + 1"')
+    resolve_with_interp_warning('#{1} + "foo"', '\'1 + "foo"\'')
+    resolve_with_interp_warning('#{1} + \'foo\'', '\'1 + "foo"\'')
+
+    resolve_with_interp_warning('#{1} + "#{a + b}"', '\'1 + "#{a + b}"\'')
+    resolve_with_interp_warning('"#{a + b}" + #{1}', '\'"#{a + b}" + 1\'')
+    resolve_with_interp_warning('"#{a + b}" + #{1} + "#{c + d}"', '\'"#{a + b}" + 1 + "#{c + d}"\'')
+
+    resolve_with_interp_warning('#{1} + "\'"', '"1 + \\"\'\\""')
+    resolve_with_interp_warning('#{1} + \'"\'', '"1 + \'\\"\'"')
+    resolve_with_interp_warning('#{1} + "\'\\""', '"1 + \\"\'\\\\\\"\\""')
+  end
+
+  def test_inactive_lazy_interpolation_deprecation_warning
+    assert_equal '1, 2, 3', assert_no_warning {resolve('1, #{2}, 3')}
+    assert_equal '1, 2, 3', assert_no_warning {resolve('1, 2, #{3}')}
+    assert_equal '1,2,3', assert_no_warning {resolve('1,#{2},3')}
+    assert_equal '1 2 3', assert_no_warning {resolve('#{1} 2 3')}
+    assert_equal '1 2 3', assert_no_warning {resolve('1 #{2} 3')}
+    assert_equal '1 2 3', assert_no_warning {resolve('1 2 #{3}')}
+
+    assert_equal '+1 2 3', assert_no_warning {resolve('+#{1} 2 3')}
+    assert_equal '-1 2 3', assert_no_warning {resolve('-#{1} 2 3')}
+    assert_equal '/1 2 3', assert_no_warning {resolve('/#{1} 2 3')}
+
+    assert_equal '1, 2, 31', assert_no_warning {resolve('(1, #{2}, 3) + 1')}
+    assert_equal '11, 2, 3', assert_no_warning {resolve('1 + (1, #{2}, 3)')}
+
+    assert_equal 'a, b, c', assert_no_warning {resolve('selector-parse((a, #{b}, c))')}
+  end
+
+  def test_active_lazy_interpolation_deprecation_warning
+    Sass::Deprecation.allow_double_warnings do
+      assert_equal "1, 2, 3", resolve_with_lazy_interp_warning('quote((1, #{2}, 3))', '"1, 2, 3"')
+      assert_equal "1", resolve_with_lazy_interp_warning('length((1, #{2}, 3))', '"1, 2, 3"')
+      assert_equal "1, 2, 3", resolve_with_lazy_interp_warning('inspect((1, #{2}, 3))', '"1, 2, 3"')
+      assert_equal "string", resolve_with_lazy_interp_warning('type-of((1, #{2}, 3))', '"1, 2, 3"')
+
+      assert_equal "+1 2 3", resolve_with_lazy_interp_warning('quote((+#{1} 2 3))', '"+1 #{2 3}"')
+      assert_equal "/1 2 3", resolve_with_lazy_interp_warning('quote((/#{1} 2 3))', '"/1 #{2 3}"')
+      assert_equal "-1 2 3", resolve_with_lazy_interp_warning('quote((-#{1} 2 3))', '"-1 #{2 3}"')
+    end
+  end
+
+  def test_comparison_of_complex_units
+    # Tests for issue #1960
+    Sass::Deprecation.allow_double_warnings do
+      assert_warning(<<WARNING) do
+DEPRECATION WARNING on line 1 of test_comparison_of_complex_units_inline.sass:
+The result of `10 == 10px` will be `false` in future releases of Sass.
+Unitless numbers will no longer be equal to the same numbers with units.
+WARNING
+        assert_equal "true", resolve("10 == 2 * 5px")
+      end
+      assert_warning(<<WARNING) do
+DEPRECATION WARNING on line 1 of test_comparison_of_complex_units_inline.sass:
+The result of `10 == 10px*px` will be `false` in future releases of Sass.
+Unitless numbers will no longer be equal to the same numbers with units.
+WARNING
+        assert_equal "true", resolve("10 == 2px * 5px")
+      end
+    end
+
+    assert_equal "true", resolve("10px * 1px == 2px * 5px")
+    assert_equal "true", resolve("5px * 1px < 2px * 5px")
+  end
+
   private
 
+  def resolve_with_lazy_interp_warning(str, contents = nil, environment = env)
+    contents ||= "\"#{str}\""
+    result = assert_warning(<<WARNING) {resolve(str, {}, environment)}
+DEPRECATION WARNING on line 1 of #{filename_for_test}:
+\#{} interpolation near operators will be simplified in a future version of Sass.
+To preserve the current behavior, use quotes:
+
+  unquote(#{contents})
+WARNING
+    $_sass_deprecated_interp_warnings = nil
+    result
+  end
+
+  def resolve_with_interp_warning(str, contents = nil, environment = env)
+    contents ||= "\"#{str}\""
+    assert_warning(<<WARNING) {resolve(str, {}, environment)}
+DEPRECATION WARNING on line 1 of #{filename_for_test}:
+\#{} interpolation near operators will be simplified in a future version of Sass.
+To preserve the current behavior, use quotes:
+
+  unquote(#{contents})
+
+You can use the sass-convert command to automatically fix most cases.
+WARNING
+  end
+
   def resolve(str, opts = {}, environment = env)
     munge_filename opts
     val = eval(str, opts, environment)
     assert_kind_of Sass::Script::Value::Base, val
+    val.options = opts
     val.is_a?(Sass::Script::Value::String) ? val.value : val.to_s
   end
 
+  def resolve_quoted(str, opts = {}, environment = env)
+    munge_filename opts
+    val = eval(str, opts, environment)
+    assert_kind_of Sass::Script::Value::Base, val
+    val.to_s
+  end
+
   def assert_unquoted(str, opts = {}, environment = env)
     munge_filename opts
     val = eval(str, opts, environment)