color 1.7.1 → 2.0.0.pre.0

data/test/test_color.rb

@@ -1,128 +1,80 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'color'
-require 'minitest_helper'
+require "color"
+require "minitest_helper"
 
 module TestColor
   class TestColor < Minitest::Test
     def setup
-      Kernel.module_eval do
-        alias old_warn warn
-
-        def warn(message)
-          $last_warn = message
-        end
-      end
-    end
-
-    def teardown
-      Kernel.module_eval do
-        undef warn
-        alias warn old_warn
-        undef old_warn
-      end
+      @subject = Object.new.extend(Color)
     end
 
-    def test_const
-      $last_warn = nil
-      assert_equal(Color::RGB::AliceBlue, Color::AliceBlue)
-      assert_equal("Color::AliceBlue has been deprecated. Use Color::RGB::AliceBlue instead.", $last_warn)
-
-      $last_warn = nil # Do this twice to make sure it always happens...
-      assert(Color::AliceBlue)
-      assert_equal("Color::AliceBlue has been deprecated. Use Color::RGB::AliceBlue instead.", $last_warn)
-
-      $last_warn = nil
-      assert_equal(Color::COLOR_VERSION, Color::VERSION)
-      assert_equal("Color::VERSION has been deprecated. Use Color::COLOR_VERSION instead.", $last_warn)
-
-      $last_warn = nil
-      assert_equal(Color::COLOR_VERSION, Color::COLOR_TOOLS_VERSION)
-      assert_equal("Color::COLOR_TOOLS_VERSION has been deprecated. Use Color::COLOR_VERSION instead.", $last_warn)
-
-      $last_warn = nil
-      assert(Color::COLOR_VERSION)
-      assert_nil($last_warn)
-      assert(Color::COLOR_EPSILON)
-      assert_nil($last_warn)
-
-      assert_raises(NameError) { assert(Color::MISSING_VALUE) }
-    end
+    # def test_equivalent
+    #   assert Color.equivalent?(Color::RGB::Red, Color::HSL.from_values(0, 100, 50))
+    #   refute Color.equivalent?(Color::RGB::Red, nil)
+    #   refute Color.equivalent?(nil, Color::RGB::Red)
+    # end
 
     def test_normalize
+      normalize = @subject.method(:normalize)
+
       (1..10).each do |i|
-        assert_equal(0.0, Color.normalize(-7 * i))
-        assert_equal(0.0, Color.normalize(-7 / i))
-        assert_equal(0.0, Color.normalize(0 - i))
-        assert_equal(1.0, Color.normalize(255 + i))
-        assert_equal(1.0, Color.normalize(256 * i))
-        assert_equal(1.0, Color.normalize(65536 / i))
+        assert_equal(0.0, normalize.call(-7 * i))
+        assert_equal(0.0, normalize.call(-7 / i))
+        assert_equal(0.0, normalize.call(0 - i))
+        assert_equal(1.0, normalize.call(255 + i))
+        assert_equal(1.0, normalize.call(256 * i))
+        assert_equal(1.0, normalize.call(65536 / i))
       end
+
       (0..255).each do |i|
-        assert_in_delta(i / 255.0, Color.normalize(i / 255.0),
-                        1e-2)
+        assert_in_delta(i / 255.0, normalize.call(i / 255.0), 1e-2)
       end
     end
 
-    def test_normalize_range
-      assert_equal(0, Color.normalize_8bit(-1))
-      assert_equal(0, Color.normalize_8bit(0))
-      assert_equal(127, Color.normalize_8bit(127))
-      assert_equal(172, Color.normalize_8bit(172))
-      assert_equal(255, Color.normalize_8bit(255))
-      assert_equal(255, Color.normalize_8bit(256))
-
-      assert_equal(0, Color.normalize_16bit(-1))
-      assert_equal(0, Color.normalize_16bit(0))
-      assert_equal(127, Color.normalize_16bit(127))
-      assert_equal(172, Color.normalize_16bit(172))
-      assert_equal(255, Color.normalize_16bit(255))
-      assert_equal(256, Color.normalize_16bit(256))
-      assert_equal(65535, Color.normalize_16bit(65535))
-      assert_equal(65535, Color.normalize_16bit(66536))
+    def test_normalize_byte
+      normalize_byte = @subject.method(:normalize_byte)
 
-      assert_equal(-100, Color.normalize_to_range(-101, -100..100))
-      assert_equal(-100, Color.normalize_to_range(-100.5, -100..100))
-      assert_equal(-100, Color.normalize_to_range(-100, -100..100))
-      assert_equal(-100, Color.normalize_to_range(-100.0, -100..100))
-      assert_equal(-99.5, Color.normalize_to_range(-99.5, -100..100))
-      assert_equal(-50, Color.normalize_to_range(-50, -100..100))
-      assert_equal(-50.5, Color.normalize_to_range(-50.5, -100..100))
-      assert_equal(0, Color.normalize_to_range(0, -100..100))
-      assert_equal(50, Color.normalize_to_range(50, -100..100))
-      assert_equal(50.5, Color.normalize_to_range(50.5, -100..100))
-      assert_equal(99, Color.normalize_to_range(99, -100..100))
-      assert_equal(99.5, Color.normalize_to_range(99.5, -100..100))
-      assert_equal(100, Color.normalize_to_range(100, -100..100))
-      assert_equal(100, Color.normalize_to_range(100.0, -100..100))
-      assert_equal(100, Color.normalize_to_range(100.5, -100..100))
-      assert_equal(100, Color.normalize_to_range(101, -100..100))
+      assert_equal(0, normalize_byte.call(-1))
+      assert_equal(0, normalize_byte.call(0))
+      assert_equal(127, normalize_byte.call(127))
+      assert_equal(172, normalize_byte.call(172))
+      assert_equal(255, normalize_byte.call(255))
+      assert_equal(255, normalize_byte.call(256))
     end
 
-    def test_new
-      $last_warn = nil
-      c = Color.new("#fff")
-      assert_kind_of(Color::HSL, c)
-      assert_equal(Color::RGB::White.to_hsl, c)
-      assert_equal("Color.new has been deprecated. Use Color::RGB.new instead.", $last_warn)
-
-      $last_warn = nil
-      c = Color.new([0, 0, 0])
-      assert_kind_of(Color::HSL, c)
-      assert_equal(Color::RGB::Black.to_hsl, c)
-      assert_equal("Color.new has been deprecated. Use Color::RGB.new instead.", $last_warn)
-
-      $last_warn = nil
-      c = Color.new([10, 20, 30], :hsl)
-      assert_kind_of(Color::HSL, c)
-      assert_equal(Color::HSL.new(10, 20, 30), c)
-      assert_equal("Color.new has been deprecated. Use Color::HSL.new instead.", $last_warn)
+    def test_normalize_word
+      normalize_word = @subject.method(:normalize_word)
+
+      assert_equal(0, normalize_word.call(-1))
+      assert_equal(0, normalize_word.call(0))
+      assert_equal(127, normalize_word.call(127))
+      assert_equal(172, normalize_word.call(172))
+      assert_equal(255, normalize_word.call(255))
+      assert_equal(256, normalize_word.call(256))
+      assert_equal(65535, normalize_word.call(65535))
+      assert_equal(65535, normalize_word.call(66536))
+    end
 
-      $last_warn = nil
-      c = Color.new([10, 20, 30, 40], :cmyk)
-      assert_kind_of(Color::HSL, c)
-      assert_equal(Color::CMYK.new(10, 20, 30, 40).to_hsl, c)
-      assert_equal("Color.new has been deprecated. Use Color::CMYK.new instead.", $last_warn)
+    def test_normalize_range
+      normalize_to_range = @subject.method(:normalize_to_range)
+
+      assert_equal(-100, normalize_to_range.call(-101, -100..100))
+      assert_equal(-100, normalize_to_range.call(-100.5, -100..100))
+      assert_equal(-100, normalize_to_range.call(-100, -100..100))
+      assert_equal(-100, normalize_to_range.call(-100.0, -100..100))
+      assert_equal(-99.5, normalize_to_range.call(-99.5, -100..100))
+      assert_equal(-50, normalize_to_range.call(-50, -100..100))
+      assert_equal(-50.5, normalize_to_range.call(-50.5, -100..100))
+      assert_equal(0, normalize_to_range.call(0, -100..100))
+      assert_equal(50, normalize_to_range.call(50, -100..100))
+      assert_equal(50.5, normalize_to_range.call(50.5, -100..100))
+      assert_equal(99, normalize_to_range.call(99, -100..100))
+      assert_equal(99.5, normalize_to_range.call(99.5, -100..100))
+      assert_equal(100, normalize_to_range.call(100, -100..100))
+      assert_equal(100, normalize_to_range.call(100.0, -100..100))
+      assert_equal(100, normalize_to_range.call(100.5, -100..100))
+      assert_equal(100, normalize_to_range.call(101, -100..100))
     end
   end
 end

data/test/test_grayscale.rb

@@ -1,105 +1,84 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'color'
-require 'minitest_helper'
+require "color"
+require "minitest_helper"
 
 module TestColor
-  class TestGrayScale < Minitest::Test
+  class TestGrayscale < Minitest::Test
     def setup
-      @gs = Color::GrayScale.from_percent(33)
+      @gs = Color::Grayscale.from_percentage(33)
     end
 
     def test_brightness
-      assert_in_delta(0.33, @gs.brightness, Color::COLOR_TOLERANCE)
+      assert_in_tolerance(0.33, @gs.brightness)
     end
 
     def test_darken_by
-      assert_in_delta(29.7, @gs.darken_by(10).gray, Color::COLOR_TOLERANCE)
+      assert_in_tolerance(29.7, @gs.darken_by(10).gray)
     end
 
     def test_g
-      assert_in_delta(0.33, @gs.g, Color::COLOR_TOLERANCE)
-      assert_in_delta(33, @gs.grey, Color::COLOR_TOLERANCE)
-      @gs.gray = 40
-      assert_in_delta(0.4, @gs.g, Color::COLOR_TOLERANCE)
-      @gs.g = 2.0
-      assert_in_delta(100, @gs.gray, Color::COLOR_TOLERANCE)
-      @gs.grey = -2.0
-      assert_in_delta(0.0, @gs.g, Color::COLOR_TOLERANCE)
+      assert_in_tolerance(0.33, @gs.g)
+      assert_in_tolerance(33, @gs.gray)
+      # @gs.gray = 40
+      # assert_in_tolerance(0.4, @gs.g)
+      # @gs.g = 2.0
+      # assert_in_tolerance(100, @gs.gray)
+      # @gs.gray = -2.0
+      # assert_in_tolerance(0.0, @gs.g)
     end
 
-    def test_html_css
+    def test_css
       assert_equal("#545454", @gs.html)
-      assert_equal("rgb(33.00%, 33.00%, 33.00%)", @gs.css_rgb)
-      assert_equal("rgba(33.00%, 33.00%, 33.00%, 1.00)", @gs.css_rgba)
+      assert_equal("rgb(33.00% 33.00% 33.00%)", @gs.css)
+      assert_equal("rgb(33.00% 33.00% 33.00% / 1.00)", @gs.css(alpha: 1))
+      assert_equal("rgb(33.00% 33.00% 33.00% / 0.20)", @gs.css(alpha: 0.2))
     end
 
     def test_lighten_by
-      assert_in_delta(0.363, @gs.lighten_by(10).g, Color::COLOR_TOLERANCE)
-    end
-
-    def test_pdf_fill
-      assert_equal("0.330 g", @gs.pdf_fill)
-      assert_equal("0.330 G", @gs.pdf_stroke)
+      assert_in_tolerance(0.363, @gs.lighten_by(10).g)
     end
 
     def test_to_cmyk
       cmyk = @gs.to_cmyk
       assert_kind_of(Color::CMYK, cmyk)
-      assert_in_delta(0.0, cmyk.c, Color::COLOR_TOLERANCE)
-      assert_in_delta(0.0, cmyk.m, Color::COLOR_TOLERANCE)
-      assert_in_delta(0.0, cmyk.y, Color::COLOR_TOLERANCE)
-      assert_in_delta(0.67, cmyk.k, Color::COLOR_TOLERANCE)
+      assert_in_tolerance(0.0, cmyk.c)
+      assert_in_tolerance(0.0, cmyk.m)
+      assert_in_tolerance(0.0, cmyk.y)
+      assert_in_tolerance(0.67, cmyk.k)
     end
 
     def test_to_grayscale
       assert_equal(@gs, @gs.to_grayscale)
-      assert_equal(@gs, @gs.to_greyscale)
+      assert_equal(@gs, @gs.to_grayscale)
     end
 
     def test_to_hsl
       hsl = @gs.to_hsl
       assert_kind_of(Color::HSL, hsl)
-      assert_in_delta(0.0, hsl.h, Color::COLOR_TOLERANCE)
-      assert_in_delta(0.0, hsl.s, Color::COLOR_TOLERANCE)
-      assert_in_delta(0.33, hsl.l, Color::COLOR_TOLERANCE)
-      assert_equal("hsl(0.00, 0.00%, 33.00%)", @gs.css_hsl)
-      assert_equal("hsla(0.00, 0.00%, 33.00%, 1.00)", @gs.css_hsla)
+      assert_in_tolerance(0.0, hsl.h)
+      assert_in_tolerance(0.0, hsl.s)
+      assert_in_tolerance(0.33, hsl.l)
     end
 
     def test_to_rgb
       rgb = @gs.to_rgb
       assert_kind_of(Color::RGB, rgb)
-      assert_in_delta(0.33, rgb.r, Color::COLOR_TOLERANCE)
-      assert_in_delta(0.33, rgb.g, Color::COLOR_TOLERANCE)
-      assert_in_delta(0.33, rgb.b, Color::COLOR_TOLERANCE)
+      assert_in_tolerance(0.33, rgb.r)
+      assert_in_tolerance(0.33, rgb.g)
+      assert_in_tolerance(0.33, rgb.b)
     end
 
     def test_to_yiq
       yiq = @gs.to_yiq
       assert_kind_of(Color::YIQ, yiq)
-      assert_in_delta(0.33, yiq.y, Color::COLOR_TOLERANCE)
-      assert_in_delta(0.0, yiq.i, Color::COLOR_TOLERANCE)
-      assert_in_delta(0.0, yiq.q, Color::COLOR_TOLERANCE)
-    end
-
-    def test_add
-      delta = @gs + Color::GrayScale.new(20)
-      max   = @gs + Color::GrayScale.new(80)
-
-      assert_in_delta(1.0, max.g, Color::COLOR_TOLERANCE)
-      assert_in_delta(0.53, delta.g, Color::COLOR_TOLERANCE)
-    end
-
-    def test_subtract
-      delta = @gs - Color::GrayScale.new(20)
-      max   = @gs - Color::GrayScale.new(80)
-      assert_in_delta(0.0, max.g, Color::COLOR_TOLERANCE)
-      assert_in_delta(0.13, delta.g, Color::COLOR_TOLERANCE)
+      assert_in_tolerance(0.33, yiq.y)
+      assert_in_tolerance(0.0, yiq.i)
+      assert_in_tolerance(0.0, yiq.q)
     end
 
     def test_inspect
-      assert_equal("Gray [33.00%]", @gs.inspect)
+      assert_equal("Grayscale [33.00%]", @gs.inspect)
     end
   end
 end

data/test/test_hsl.rb

@@ -1,135 +1,131 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'color'
-require 'minitest_helper'
+require "color"
+require "minitest_helper"
 
 module TestColor
   class TestHSL < Minitest::Test
     def setup
-#     @hsl = Color::HSL.new(262, 67, 42)
-      @hsl = Color::HSL.new(145, 20, 30)
-#     @rgb = Color::RGB.new(88, 35, 179)
+      @hsl = Color::HSL.from_values(145, 20, 30)
     end
 
     def test_rgb_roundtrip_conversion
-      hsl = Color::HSL.new(262, 67, 42)
+      hsl = Color::HSL.from_values(262, 67, 42)
       c = hsl.to_rgb.to_hsl
-      assert_in_delta hsl.h, c.h, Color::COLOR_TOLERANCE, "Hue"
-      assert_in_delta hsl.s, c.s, Color::COLOR_TOLERANCE, "Saturation"
-      assert_in_delta hsl.l, c.l, Color::COLOR_TOLERANCE, "Luminance"
+      assert_in_tolerance hsl.h, c.h, "Hue"
+      assert_in_tolerance hsl.s, c.s, "Saturation"
+      assert_in_tolerance hsl.l, c.l, "Luminance"
     end
 
     def test_brightness
-      assert_in_delta 0.3, @hsl.brightness, Color::COLOR_TOLERANCE
+      assert_in_tolerance 0.3, @hsl.brightness
     end
 
     def test_hue
-      assert_in_delta 0.4027, @hsl.h, Color::COLOR_TOLERANCE
-      assert_in_delta 145, @hsl.hue, Color::COLOR_TOLERANCE
-      @hsl.hue = 33
-      assert_in_delta 0.09167, @hsl.h, Color::COLOR_TOLERANCE
-      @hsl.hue = -33
-      assert_in_delta 0.90833, @hsl.h, Color::COLOR_TOLERANCE
-      @hsl.h = 3.3
-      assert_in_delta 360, @hsl.hue, Color::COLOR_TOLERANCE
-      @hsl.h = -3.3
-      assert_in_delta 0.0, @hsl.h, Color::COLOR_TOLERANCE
-      @hsl.hue = 0
-      @hsl.hue -= 20
-      assert_in_delta 340, @hsl.hue, Color::COLOR_TOLERANCE
-      @hsl.hue += 45
-      assert_in_delta 25, @hsl.hue, Color::COLOR_TOLERANCE
+      assert_in_tolerance 0.4027, @hsl.h
+      assert_in_tolerance 145, @hsl.hue
+      # @hsl.hue = 33
+      # assert_in_tolerance 0.09167, @hsl.h
+      # @hsl.hue = -33
+      # assert_in_tolerance 0.90833, @hsl.h
+      # @hsl.h = 3.3
+      # assert_in_tolerance 360, @hsl.hue
+      # @hsl.h = -3.3
+      # assert_in_tolerance 0.0, @hsl.h
+      # @hsl.hue = 0
+      # @hsl.hue -= 20
+      # assert_in_tolerance 340, @hsl.hue
+      # @hsl.hue += 45
+      # assert_in_tolerance 25, @hsl.hue
     end
 
     def test_saturation
-      assert_in_delta 0.2, @hsl.s, Color::COLOR_TOLERANCE
-      assert_in_delta 20, @hsl.saturation, Color::COLOR_TOLERANCE
-      @hsl.saturation = 33
-      assert_in_delta 0.33, @hsl.s, Color::COLOR_TOLERANCE
-      @hsl.s = 3.3
-      assert_in_delta 100, @hsl.saturation, Color::COLOR_TOLERANCE
-      @hsl.s = -3.3
-      assert_in_delta 0.0, @hsl.s, Color::COLOR_TOLERANCE
+      assert_in_tolerance 0.2, @hsl.s
+      assert_in_tolerance 20, @hsl.saturation
+      # @hsl.saturation = 33
+      # assert_in_tolerance 0.33, @hsl.s
+      # @hsl.s = 3.3
+      # assert_in_tolerance 100, @hsl.saturation
+      # @hsl.s = -3.3
+      # assert_in_tolerance 0.0, @hsl.s
     end
 
     def test_luminance
-      assert_in_delta 0.3, @hsl.l, Color::COLOR_TOLERANCE
-      assert_in_delta 30, @hsl.luminosity, Color::COLOR_TOLERANCE
-      @hsl.luminosity = 33
-      assert_in_delta 0.33, @hsl.l, Color::COLOR_TOLERANCE
-      @hsl.l = 3.3
-      assert_in_delta 100, @hsl.lightness, Color::COLOR_TOLERANCE
-      @hsl.l = -3.3
-      assert_in_delta 0.0, @hsl.l, Color::COLOR_TOLERANCE
+      assert_in_tolerance 0.3, @hsl.l
+      assert_in_tolerance 30, @hsl.luminosity
+      # @hsl.luminosity = 33
+      # assert_in_tolerance 0.33, @hsl.l
+      # @hsl.l = 3.3
+      # assert_in_tolerance 100, @hsl.lightness
+      # @hsl.l = -3.3
+      # assert_in_tolerance 0.0, @hsl.l
     end
 
-    def test_html_css
-      assert_equal "hsl(145.00, 20.00%, 30.00%)", @hsl.css_hsl
-      assert_equal "hsla(145.00, 20.00%, 30.00%, 1.00)", @hsl.css_hsla
+    def test_css
+      assert_equal "hsl(145.00deg 20.00% 30.00%)", @hsl.css
+      assert_equal "hsl(145.00deg 20.00% 30.00% / 1.00)", @hsl.css(alpha: 1)
     end
 
     def test_to_cmyk
       cmyk = @hsl.to_cmyk
       assert_kind_of Color::CMYK, cmyk
-      assert_in_delta 0.3223, cmyk.c, Color::COLOR_TOLERANCE
-      assert_in_delta 0.2023, cmyk.m, Color::COLOR_TOLERANCE
-      assert_in_delta 0.2723, cmyk.y, Color::COLOR_TOLERANCE
-      assert_in_delta 0.4377, cmyk.k, Color::COLOR_TOLERANCE
+      assert_in_tolerance 0.3223, cmyk.c
+      assert_in_tolerance 0.2023, cmyk.m
+      assert_in_tolerance 0.2723, cmyk.y
+      assert_in_tolerance 0.4377, cmyk.k
     end
 
     def test_to_grayscale
       gs = @hsl.to_grayscale
-      assert_kind_of Color::GreyScale, gs
-      assert_in_delta 30, gs.gray, Color::COLOR_TOLERANCE
+      assert_kind_of Color::Grayscale, gs
+      assert_in_tolerance 30, gs.gray
     end
 
     def test_to_rgb
       rgb = @hsl.to_rgb
       assert_kind_of Color::RGB, rgb
-      assert_in_delta 0.24, rgb.r, Color::COLOR_TOLERANCE
-      assert_in_delta 0.36, rgb.g, Color::COLOR_TOLERANCE
-      assert_in_delta 0.29, rgb.b, Color::COLOR_TOLERANCE
-      assert_equal "#3d5c4a", @hsl.html
-      assert_equal "rgb(24.00%, 36.00%, 29.00%)", @hsl.css_rgb
-      assert_equal "rgba(24.00%, 36.00%, 29.00%, 1.00)", @hsl.css_rgba
+      assert_in_tolerance 0.24, rgb.r
+      assert_in_tolerance 0.36, rgb.g
+      assert_in_tolerance 0.29, rgb.b
+
       # The following tests address a bug reported by Jean Krohn on June 6,
-      # 2006 and excercise some previously unexercised code in to_rgb.
-      assert_equal Color::RGB::Black, Color::HSL.new(75, 75, 0)
-      assert_equal Color::RGB::White, Color::HSL.new(75, 75, 100)
-      assert_equal Color::RGB::Gray80, Color::HSL.new(75, 0, 80)
+      # 2006 and exercise some previously unexercised code in to_rgb.
+      assert_equal Color::RGB::Black, Color::HSL.from_values(75, 75, 0)
+      assert_equal Color::RGB::White, Color::HSL.from_values(75, 75, 100)
+      assert_equal Color::RGB::Gray80, Color::HSL.from_values(75, 0, 80)
 
       # The following tests a bug reported by Adam Johnson on 29 October
       # 2010.
       rgb = Color::RGB.from_fraction(0.34496, 0.1386, 0.701399)
-      c = Color::HSL.new(262, 67, 42).to_rgb
-      assert_in_delta rgb.r, c.r, Color::COLOR_TOLERANCE, "Red"
-      assert_in_delta rgb.g, c.g, Color::COLOR_TOLERANCE, "Green"
-      assert_in_delta rgb.b, c.b, Color::COLOR_TOLERANCE, "Blue"
+      c = Color::HSL.from_values(262, 67, 42).to_rgb
+      assert_in_tolerance rgb.r, c.r, "Red"
+      assert_in_tolerance rgb.g, c.g, "Green"
+      assert_in_tolerance rgb.b, c.b, "Blue"
     end
 
     def test_to_yiq
       yiq = @hsl.to_yiq
       assert_kind_of Color::YIQ, yiq
-      assert_in_delta 0.3161, yiq.y, Color::COLOR_TOLERANCE
-      assert_in_delta 0.0, yiq.i, Color::COLOR_TOLERANCE
-      assert_in_delta 0.0, yiq.q, Color::COLOR_TOLERANCE
+      assert_in_tolerance 0.3161, yiq.y
+      assert_in_tolerance 0.0, yiq.i
+      assert_in_tolerance 0.0, yiq.q
     end
 
     def test_mix_with
-      red     = Color::RGB::Red.to_hsl
-      yellow  = Color::RGB::Yellow.to_hsl
-      assert_in_delta 0, red.hue, Color::COLOR_TOLERANCE
-      assert_in_delta 60, yellow.hue, Color::COLOR_TOLERANCE
+      red = Color::RGB::Red.to_hsl
+      yellow = Color::RGB::Yellow.to_hsl
+      assert_in_tolerance 0, red.hue
+      assert_in_tolerance 60, yellow.hue
       ry25 = red.mix_with yellow, 0.25
-      assert_in_delta 15, ry25.hue, Color::COLOR_TOLERANCE
+      assert_in_tolerance 15, ry25.hue
       ry50 = red.mix_with yellow, 0.50
-      assert_in_delta 30, ry50.hue, Color::COLOR_TOLERANCE
+      assert_in_tolerance 30, ry50.hue
       ry75 = red.mix_with yellow, 0.75
-      assert_in_delta 45, ry75.hue, Color::COLOR_TOLERANCE
+      assert_in_tolerance 45, ry75.hue
     end
 
     def test_inspect
-      assert_equal "HSL [145.00 deg, 20.00%, 30.00%]", @hsl.inspect
+      assert_equal "HSL [145.00deg 20.00% 30.00%]", @hsl.inspect
     end
   end
 end