sass 3.3.0 → 3.4.0

data/test/sass/source_map_test.rb

@@ -3,12 +3,12 @@
 require File.dirname(__FILE__) + '/../test_helper'
 require File.dirname(__FILE__) + '/test_helper'
 
-class SourcemapTest < Test::Unit::TestCase
+class SourcemapTest < MiniTest::Test
   def test_to_json_requires_args
     _, sourcemap = render_with_sourcemap('')
-    assert_raise(ArgumentError) {sourcemap.to_json({})}
-    assert_raise(ArgumentError) {sourcemap.to_json({:css_path => 'foo'})}
-    assert_raise(ArgumentError) {sourcemap.to_json({:sourcemap_path => 'foo'})}
+    assert_raises(ArgumentError) {sourcemap.to_json({})}
+    assert_raises(ArgumentError) {sourcemap.to_json({:css_path => 'foo'})}
+    assert_raises(ArgumentError) {sourcemap.to_json({:sourcemap_path => 'foo'})}
   end
 
   def test_simple_mapping_scss
@@ -60,6 +60,32 @@ CSS
 JSON
   end
 
+  def test_simple_mapping_with_file_uris
+    uri = Sass::Util.file_uri_from_path(Sass::Util.absolute_path(filename_for_test(:scss)))
+    assert_parses_with_sourcemap <<SCSS, <<CSS, <<JSON, :sourcemap => :file
+a {
+  foo: bar;
+/* SOME COMMENT */
+  font-size: 12px;
+}
+SCSS
+a {
+  foo: bar;
+  /* SOME COMMENT */
+  font-size: 12px; }
+
+/*# sourceMappingURL=test.css.map */
+CSS
+{
+"version": 3,
+"mappings": "AAAA,CAAE;EACA,GAAG,EAAE,GAAG;;EAER,SAAS,EAAE,IAAI",
+"sources": ["#{uri}"],
+"names": [],
+"file": "test.css"
+}
+JSON
+  end
+
   def test_mapping_with_directory_scss
     options = {:filename => "scss/style.scss", :output => "css/style.css"}
     assert_parses_with_sourcemap <<SCSS, <<CSS, <<JSON, options
@@ -156,15 +182,15 @@ JSON
     end
 
     def test_different_charset_than_encoding_scss
-      assert_parses_with_sourcemap(<<SCSS.force_encoding("IBM866"), <<CSS.force_encoding("IBM866"), <<JSON)
+      assert_parses_with_sourcemap(<<SCSS.force_encoding("IBM866"), <<CSS, <<JSON)
 @charset "IBM866";
 f\x86\x86 {
   \x86: b;
 }
 SCSS
-@charset "IBM866";
-f\x86\x86 {
-  \x86: b; }
+@charset "UTF-8";
+fЖЖ {
+  Ж: b; }
 
 /*# sourceMappingURL=test.css.map */
 CSS
@@ -179,14 +205,14 @@ JSON
     end
 
     def test_different_charset_than_encoding_sass
-      assert_parses_with_sourcemap(<<SASS.force_encoding("IBM866"), <<CSS.force_encoding("IBM866"), <<JSON, :syntax => :sass)
+      assert_parses_with_sourcemap(<<SASS.force_encoding("IBM866"), <<CSS, <<JSON, :syntax => :sass)
 @charset "IBM866"
 f\x86\x86
   \x86: b
 SASS
-@charset "IBM866";
-f\x86\x86 {
-  \x86: b; }
+@charset "UTF-8";
+fЖЖ {
+  Ж: b; }
 
 /*# sourceMappingURL=test.css.map */
 CSS
@@ -443,8 +469,8 @@ CSS
   {{7}}border-width{{/7}}: {{8}}3px{{/8}}
 SASS
 {{1}}.error, .seriousError{{/1}} {
-  {{2}}border{{/2}}: {{3}}1px red{{/3}};
-  {{4}}background-color{{/4}}: {{5}}#ffdddd{{/5}}; }
+  {{2}}border{{/2}}: {{3}}1px #f00{{/3}};
+  {{4}}background-color{{/4}}: {{5}}#fdd{{/5}}; }
 
 {{6}}.seriousError{{/6}} {
   {{7}}border-width{{/7}}: {{8}}3px{{/8}}; }
@@ -632,9 +658,9 @@ SCSS
   {{22}}border-style{{/22}}: {{23}}dashed{{/23}}; }
 
 {{24}}.shadows{{/24}} {
-  {{25}}-moz-box-shadow{{/25}}: {{26}}0px 4px 5px #666666, 2px 6px 10px #999999{{/26}};
-  {{27}}-webkit-box-shadow{{/27}}: {{28}}0px 4px 5px #666666, 2px 6px 10px #999999{{/28}};
-  {{29}}box-shadow{{/29}}: {{30}}0px 4px 5px #666666, 2px 6px 10px #999999{{/30}}; }
+  {{25}}-moz-box-shadow{{/25}}: {{26}}0px 4px 5px #666, 2px 6px 10px #999{{/26}};
+  {{27}}-webkit-box-shadow{{/27}}: {{28}}0px 4px 5px #666, 2px 6px 10px #999{{/28}};
+  {{29}}box-shadow{{/29}}: {{30}}0px 4px 5px #666, 2px 6px 10px #999{{/30}}; }
 
 /*# sourceMappingURL=test.css.map */
 CSS
@@ -675,7 +701,7 @@ SASS
 {{1}}.page-title{{/1}} {
   {{2}}font-size{{/2}}: {{3}}20px{{/3}};
   {{4}}font-weight{{/4}}: {{5}}bold{{/5}};
-  {{6}}color{{/6}}: {{7}}red{{/7}};
+  {{6}}color{{/6}}: {{7}}#ff0000{{/7}};
   {{8}}padding{{/8}}: {{9}}4px{{/9}}; }
 
 {{10}}p{{/10}} {
@@ -689,9 +715,9 @@ SASS
   {{22}}border-style{{/22}}: {{23}}dashed{{/23}}; }
 
 {{24}}.shadows{{/24}} {
-  {{25}}-moz-box-shadow{{/25}}: {{26}}0px 4px 5px #666666, 2px 6px 10px #999999{{/26}};
-  {{27}}-webkit-box-shadow{{/27}}: {{28}}0px 4px 5px #666666, 2px 6px 10px #999999{{/28}};
-  {{29}}box-shadow{{/29}}: {{30}}0px 4px 5px #666666, 2px 6px 10px #999999{{/30}}; }
+  {{25}}-moz-box-shadow{{/25}}: {{26}}0px 4px 5px #666, 2px 6px 10px #999{{/26}};
+  {{27}}-webkit-box-shadow{{/27}}: {{28}}0px 4px 5px #666, 2px 6px 10px #999{{/28}};
+  {{29}}box-shadow{{/29}}: {{30}}0px 4px 5px #666, 2px 6px 10px #999{{/30}}; }
 
 /*# sourceMappingURL=test.css.map */
 CSS
@@ -752,6 +778,63 @@ SASS
 CSS
   end
 
+  def test_multiline_script_scss
+    assert_parses_with_mapping <<SCSS, <<CSS, :syntax => :scss
+$var: {{3}}foo +
+    bar{{/3}}; {{1}}x {{/1}}{ {{2}}y{{/2}}: $var }
+SCSS
+{{1}}x{{/1}} {
+  {{2}}y{{/2}}: {{3}}foobar{{/3}}; }
+
+/*# sourceMappingURL=test.css.map */
+CSS
+  end
+
+  def test_multiline_interpolation_source_range
+    engine = Sass::Engine.new(<<-SCSS, :cache => false, :syntax => :scss)
+p {
+  filter: progid:DXImageTransform(
+          '\#{123}');
+}
+SCSS
+
+    interpolated = engine.to_tree.children.
+      first.children.
+      first.value.children[1]
+    assert_equal interpolated.to_sass, "\#{123}"
+    range = interpolated.source_range
+    assert_equal 3, range.start_pos.line
+    assert_equal 12, range.start_pos.offset
+    assert_equal 3, range.end_pos.line
+    assert_equal 18, range.end_pos.offset
+  end
+
+  def test_sources_array_is_uri_escaped
+    map = Sass::Source::Map.new
+    importer = Sass::Importers::Filesystem.new('.')
+    map.add(
+      Sass::Source::Range.new(
+        Sass::Source::Position.new(0, 0),
+        Sass::Source::Position.new(0, 10),
+        'source file.scss',
+        importer),
+      Sass::Source::Range.new(
+        Sass::Source::Position.new(0, 0),
+        Sass::Source::Position.new(0, 10),
+        nil, nil))
+
+    json = map.to_json(:css_path => 'output file.css', :sourcemap_path => 'output file.css.map')
+    assert_equal json, <<JSON.rstrip
+{
+"version": 3,
+"mappings": "DADD,UAAU",
+"sources": ["source%20file.scss"],
+"names": [],
+"file": "output%20file.css"
+}
+JSON
+  end
+
   private
 
   ANNOTATION_REGEX = /\{\{(\/?)([^}]+)\}\}/
@@ -810,11 +893,18 @@ CSS
 
   def assert_positions_equal(expected, actual, lines, message = nil)
     prefix = message ? message + ": " : ""
+    expected_location = lines[expected.line - 1] + "\n" + ("-" * (expected.offset - 1)) + "^"
+    actual_location = lines[actual.line - 1] + "\n" + ("-" * (actual.offset - 1)) + "^"
     assert_equal(expected.line, actual.line, prefix +
-      "Expected #{expected.inspect} but was #{actual.inspect}")
+      "Expected #{expected.inspect}\n" +
+      expected_location + "\n\n" +
+      "But was #{actual.inspect}\n" +
+      actual_location)
     assert_equal(expected.offset, actual.offset, prefix +
-      "Expected #{expected.inspect} but was #{actual.inspect}\n" +
-      lines[actual.line - 1] + "\n" + ("-" * (actual.offset - 1)) + "^")
+      "Expected #{expected.inspect}\n" +
+      expected_location + "\n\n" +
+      "But was #{actual.inspect}\n" +
+      actual_location)
   end
 
   def assert_ranges_equal(expected, actual, lines, prefix)
@@ -843,7 +933,7 @@ MESSAGE
     rendered, sourcemap = render_with_sourcemap(source, options)
     css_path = options[:output] || "test.css"
     sourcemap_path = Sass::Util.sourcemap_name(css_path)
-    rendered_json = sourcemap.to_json(:css_path => css_path, :sourcemap_path => sourcemap_path)
+    rendered_json = sourcemap.to_json(:css_path => css_path, :sourcemap_path => sourcemap_path, :type => options[:sourcemap])
 
     assert_equal css.rstrip, rendered.rstrip
     assert_equal sourcemap_json.rstrip, rendered_json

data/test/sass/superselector_test.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+
+class SuperselectorTest < MiniTest::Test
+  def test_superselector_reflexivity
+    assert_superselector 'h1', 'h1'
+    assert_superselector '.foo', '.foo'
+    assert_superselector '#foo > .bar, baz', '#foo > .bar, baz'
+  end
+
+  def test_smaller_compound_superselector
+    assert_strict_superselector '.foo', '.foo.bar'
+    assert_strict_superselector '.bar', '.foo.bar'
+    assert_strict_superselector 'a', 'a#b'
+    assert_strict_superselector '#b', 'a#b'
+  end
+
+  def test_smaller_complex_superselector
+    assert_strict_superselector '.bar', '.foo .bar'
+    assert_strict_superselector '.bar', '.foo > .bar'
+    assert_strict_superselector '.bar', '.foo + .bar'
+    assert_strict_superselector '.bar', '.foo ~ .bar'
+  end
+
+  def test_selector_list_subset_superselector
+    assert_strict_superselector '.foo, .bar', '.foo'
+    assert_strict_superselector '.foo, .bar, .baz', '.foo, .baz'
+    assert_strict_superselector '.foo, .baz, .qux', '.foo.bar, .baz.bang'
+  end
+
+  def test_leading_combinator_superselector
+    refute_superselector '+ .foo', '.foo'
+    refute_superselector '+ .foo', '.bar + .foo'
+  end
+
+  def test_trailing_combinator_superselector
+    refute_superselector '.foo +', '.foo'
+    refute_superselector '.foo +', '.foo + .bar'
+  end
+
+  def test_matching_combinator_superselector
+    assert_strict_superselector '.foo + .bar', '.foo + .bar.baz'
+    assert_strict_superselector '.foo + .bar', '.foo.baz + .bar'
+    assert_strict_superselector '.foo > .bar', '.foo > .bar.baz'
+    assert_strict_superselector '.foo > .bar', '.foo.baz > .bar'
+    assert_strict_superselector '.foo ~ .bar', '.foo ~ .bar.baz'
+    assert_strict_superselector '.foo ~ .bar', '.foo.baz ~ .bar'
+  end
+
+  def test_following_sibling_is_superselector_of_next_sibling
+    assert_strict_superselector '.foo ~ .bar', '.foo + .bar.baz'
+    assert_strict_superselector '.foo ~ .bar', '.foo.baz + .bar'
+  end
+
+  def test_descendant_is_superselector_of_child
+    assert_strict_superselector '.foo .bar', '.foo > .bar.baz'
+    assert_strict_superselector '.foo .bar', '.foo.baz > .bar'
+  end
+
+  def test_matches_is_superselector_of_constituent_selectors
+    %w[matches -moz-any].each do |name|
+      assert_strict_superselector ":#{name}(.foo, .bar)", '.foo.baz'
+      assert_strict_superselector ":#{name}(.foo, .bar)", '.bar.baz'
+      assert_strict_superselector ":#{name}(.foo .bar, .baz)", '.x .foo .bar'
+    end
+  end
+
+  def test_matches_is_superselector_of_subset_matches
+    assert_strict_superselector ':matches(.foo, .bar, .baz)', '#x:matches(.foo.bip, .baz.bang)'
+    assert_strict_superselector ':-moz-any(.foo, .bar, .baz)', '#x:-moz-any(.foo.bip, .baz.bang)'
+  end
+
+  def test_matches_is_not_superselector_of_any
+    refute_superselector ':matches(.foo, .bar)', ':-moz-any(.foo, .bar)'
+    refute_superselector ':-moz-any(.foo, .bar)', ':matches(.foo, .bar)'
+  end
+
+  def test_matches_can_be_subselector
+    %w[matches -moz-any].each do |name|
+      assert_superselector '.foo', ":#{name}(.foo.bar)"
+      assert_superselector '.foo.bar', ":#{name}(.foo.bar.baz)"
+      assert_superselector '.foo', ":#{name}(.foo.bar, .foo.baz)"
+    end
+  end
+
+  def test_any_is_not_superselector_of_different_prefix
+    refute_superselector ':-moz-any(.foo, .bar)', ':-s-any(.foo, .bar)'
+  end
+
+  def test_not_is_superselector_of_less_complex_not
+    assert_strict_superselector ':not(.foo.bar)', ':not(.foo)'
+    assert_strict_superselector ':not(.foo .bar)', ':not(.bar)'
+  end
+
+  def test_not_is_superselector_of_superset
+    assert_strict_superselector ':not(.foo.bip, .baz.bang)', ':not(.foo, .bar, .baz)'
+    assert_strict_superselector ':not(.foo.bip, .baz.bang)', ':not(.foo):not(.bar):not(.baz)'
+  end
+
+  def test_not_is_superselector_of_unique_selectors
+    assert_strict_superselector ':not(h1.foo)', 'a'
+    assert_strict_superselector ':not(.baz #foo)', '#bar'
+  end
+
+  def test_not_is_not_superselector_of_non_unique_selectors
+    refute_superselector ':not(.foo)', '.bar'
+    refute_superselector ':not(:hover)', ':visited'
+  end
+
+  def test_current_is_superselector_with_identical_innards
+    assert_superselector ':current(.foo)', ':current(.foo)'
+  end
+
+  def test_current_is_superselector_with_subselector_innards
+    refute_superselector ':current(.foo)', ':current(.foo.bar)'
+    refute_superselector ':current(.foo.bar)', ':current(.foo)'
+  end
+
+  def test_nth_match_is_superselector_of_subset_nth_match
+    assert_strict_superselector(
+      ':nth-child(2n of .foo, .bar, .baz)', '#x:nth-child(2n of .foo.bip, .baz.bang)')
+    assert_strict_superselector(
+      ':nth-last-child(2n of .foo, .bar, .baz)', '#x:nth-last-child(2n of .foo.bip, .baz.bang)')
+  end
+
+  def test_nth_match_is_not_superselector_of_nth_match_with_different_arg
+    refute_superselector(
+      ':nth-child(2n of .foo, .bar, .baz)', '#x:nth-child(2n + 1 of .foo.bip, .baz.bang)')
+    refute_superselector(
+      ':nth-last-child(2n of .foo, .bar, .baz)', '#x:nth-last-child(2n + 1 of .foo.bip, .baz.bang)')
+  end
+
+  def test_nth_match_is_not_superselector_of_nth_last_match
+    refute_superselector ':nth-child(2n of .foo, .bar)', ':nth-last-child(2n of .foo, .bar)'
+    refute_superselector ':nth-last-child(2n of .foo, .bar)', ':nth-child(2n of .foo, .bar)'
+  end
+
+  def test_nth_match_can_be_subselector
+    %w[nth-child nth-last-child].each do |name|
+      assert_superselector '.foo', ":#{name}(2n of .foo.bar)"
+      assert_superselector '.foo.bar', ":#{name}(2n of .foo.bar.baz)"
+      assert_superselector '.foo', ":#{name}(2n of .foo.bar, .foo.baz)"
+    end
+  end
+
+  def has_is_superselector_of_subset_host
+    assert_strict_superselector ':has(.foo, .bar, .baz)', ':has(.foo.bip, .baz.bang)'
+  end
+
+  def has_isnt_superselector_of_contained_selector
+    assert_strict_superselector ':has(.foo, .bar, .baz)', '.foo'
+  end
+
+  def host_is_superselector_of_subset_host
+    assert_strict_superselector ':host(.foo, .bar, .baz)', ':host(.foo.bip, .baz.bang)'
+  end
+
+  def host_isnt_superselector_of_contained_selector
+    assert_strict_superselector ':host(.foo, .bar, .baz)', '.foo'
+  end
+
+  def host_context_is_superselector_of_subset_host
+    assert_strict_superselector(
+      ':host-context(.foo, .bar, .baz)', ':host-context(.foo.bip, .baz.bang)')
+  end
+
+  def host_context_isnt_superselector_of_contained_selector
+    assert_strict_superselector ':host-context(.foo, .bar, .baz)', '.foo'
+  end
+
+  private
+
+  def assert_superselector(superselector, subselector)
+    assert(parse_selector(superselector).superselector?(parse_selector(subselector)),
+      "Expected #{superselector} to be a superselector of #{subselector}.")
+  end
+
+  def refute_superselector(superselector, subselector)
+    assert(!parse_selector(superselector).superselector?(parse_selector(subselector)),
+      "Expected #{superselector} not to be a superselector of #{subselector}.")
+  end
+
+  def assert_strict_superselector(superselector, subselector)
+    assert_superselector(superselector, subselector)
+    refute_superselector(subselector, superselector)
+  end
+
+  def parse_selector(selector)
+    Sass::SCSS::CssParser.new(selector, filename_for_test, nil).parse_selector
+  end
+end

data/test/sass/templates/scss_import.scss

@@ -3,7 +3,8 @@ $preconst: hello;
 @mixin premixin {pre-mixin: here}
 
 @import "importee.sass", "scss_importee", "basic.sass", "basic.css", "../results/complex.css";
-@import "partial.sass";
+@import "part\
+ial.sass";
 
 nonimported {
   myconst: $preconst;

data/test/sass/test_helper.rb

@@ -1,7 +1,7 @@
 test_dir = File.dirname(__FILE__)
 $:.unshift test_dir unless $:.include?(test_dir)
 
-class Test::Unit::TestCase
+class MiniTest::Test
   def absolutize(file)
     File.expand_path("#{File.dirname(__FILE__)}/#{file}")
   end

data/test/sass/util/multibyte_string_scanner_test.rb

@@ -3,7 +3,7 @@
 require File.dirname(__FILE__) + '/../../test_helper'
 
 unless Sass::Util.ruby1_8?
-  class MultibyteStringScannerTest < Test::Unit::TestCase
+  class MultibyteStringScannerTest < MiniTest::Test
     def setup
       @scanner = Sass::Util::MultibyteStringScanner.new("cölorfül")
     end

data/test/sass/util/normalized_map_test.rb

@@ -2,7 +2,7 @@
 require File.dirname(__FILE__) + '/../../test_helper'
 require 'sass/util/normalized_map'
 
-class NormalizedMapTest < Test::Unit::TestCase
+class NormalizedMapTest < MiniTest::Test
   extend PublicApiLinter
 
   lint_api Hash, Sass::Util::NormalizedMap

data/test/sass/util/subset_map_test.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../../test_helper'
 
-class SubsetMapTest < Test::Unit::TestCase
+class SubsetMapTest < MiniTest::Test
   def setup
     @ssm = Sass::Util::SubsetMap.new
     @ssm[Set[1, 2]] = "Foo"
@@ -44,7 +44,7 @@ class SubsetMapTest < Test::Unit::TestCase
   end
 
   def test_empty_key_set
-    assert_raise(ArgumentError) {@ssm[Set[]] = "Fail"}
+    assert_raises(ArgumentError) {@ssm[Set[]] = "Fail"}
   end
 
   def test_empty_key_get

data/test/sass/util_test.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/../test_helper'
 require 'pathname'
 require 'tmpdir'
 
-class UtilTest < Test::Unit::TestCase
+class UtilTest < MiniTest::Test
   include Sass::Util
 
   def test_scope
@@ -79,6 +79,15 @@ class UtilTest < Test::Unit::TestCase
       merge_adjacent_strings([str, " ", str, " ", str, :bang, str, " ", str, 12]))
   end
 
+  def test_replace_subseq
+    assert_equal([1, 2, :a, :b, 5],
+      replace_subseq([1, 2, 3, 4, 5], [3, 4], [:a, :b]))
+    assert_equal([1, 2, 3, 4, 5],
+      replace_subseq([1, 2, 3, 4, 5], [3, 4, 6], [:a, :b]))
+    assert_equal([1, 2, 3, 4, 5],
+      replace_subseq([1, 2, 3, 4, 5], [4, 5, 6], [:a, :b]))
+  end
+
   def test_intersperse
     assert_equal(["foo", " ", "bar", " ", "baz"],
       intersperse(%w[foo bar baz], " "))
@@ -419,6 +428,27 @@ WARNING
     end
   end
 
+  def test_atomic_write_permissions
+    atomic_filename = File.join(Dir.tmpdir, "test_atomic_perms.atomic")
+    normal_filename = File.join(Dir.tmpdir, "test_atomic_perms.normal")
+    atomic_create_and_write_file(atomic_filename) {|f| f.write("whatever\n") }
+    open(normal_filename, "wb") {|f| f.write("whatever\n") }
+    assert_equal File.stat(normal_filename).mode.to_s(8), File.stat(atomic_filename).mode.to_s(8)
+  ensure
+    File.unlink(atomic_filename) rescue nil
+    File.unlink(normal_filename) rescue nil
+  end
+
+  def test_atomic_writes_respect_umask
+    atomic_filename = File.join(Dir.tmpdir, "test_atomic_perms.atomic")
+    atomic_create_and_write_file(atomic_filename) do |f|
+      f.write("whatever\n")
+    end
+    assert_equal 0, File.stat(atomic_filename).mode & File.umask
+  ensure
+    File.unlink(atomic_filename)
+  end
+
   class FakeError < RuntimeError; end
 
   def test_atomic_writes_handles_exceptions

data/test/sass/value_helpers_test.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../test_helper'
 
-class ValueHelpersTest < Test::Unit::TestCase
+class ValueHelpersTest < MiniTest::Test
   include Sass::Script
   include Sass::Script::Value::Helpers
 
@@ -51,10 +51,8 @@ class ValueHelpersTest < Test::Unit::TestCase
     assert_equal 0.5, color_with_alpha.alpha
   end
 
-  def test_hex_color_alpha_enforces_0_to_1
-    assert_raises ArgumentError do
-      hex_color("FF007F", 50)
-    end
+  def test_hex_color_alpha_clamps_0_to_1
+    assert_equal 1, hex_color("FF007F", 50).alpha
   end
 
   def test_hsl_color_without_alpha
@@ -132,14 +130,14 @@ class ValueHelpersTest < Test::Unit::TestCase
     l = list(number(1, "px"), hex_color("#f71"), :space)
     l.options = {}
     assert_kind_of Sass::Script::Value::List, l
-    assert_equal "1px #ff7711", l.to_sass
+    assert_equal "1px #f71", l.to_sass
   end
 
   def test_comma_list
     l = list(number(1, "px"), hex_color("#f71"), :comma)
     l.options = {}
     assert_kind_of Sass::Script::Value::List, l
-    assert_equal "1px, #ff7711", l.to_sass
+    assert_equal "1px, #f71", l.to_sass
   end
 
   def test_missing_list_type

data/test/test_helper.rb

@@ -1,6 +1,6 @@
 lib_dir = File.dirname(__FILE__) + '/../lib'
 
-require 'test/unit'
+require 'minitest/autorun'
 require 'fileutils'
 $:.unshift lib_dir unless $:.include?(lib_dir)
 require 'sass'
@@ -22,7 +22,7 @@ module Sass::Script::Functions
   end
 end
 
-class Test::Unit::TestCase
+class MiniTest::Test
   def munge_filename(opts = {})
     opts[:filename] ||= filename_for_test(opts[:syntax] || :sass)
     opts[:sourcemap_filename] ||= sourcemap_filename_for_test