hexapdf 0.15.8 → 0.17.1

data/test/hexapdf/content/test_color_space.rb

@@ -1,164 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'hexapdf/content/color_space'
-
-module CommonColorSpaceTests
-  extend Minitest::Spec::DSL
-
-  it "the color object returns the correct color space" do
-    assert_equal(@color_space, @color.color_space)
-  end
-
-  it "the color space class accepts the color space definition as argument to ::new" do
-    assert_equal(1, @color_space.class.method(:new).arity.abs)
-  end
-
-  it "the color space responds to :default_color" do
-    assert(@color_space.respond_to?(:default_color))
-    assert_equal(0, @color_space.method(:default_color).arity)
-  end
-
-  it "the color space responds to :color" do
-    assert(@color_space.respond_to?(:color))
-  end
-
-  it "the color space returns the correct color space family" do
-    assert_equal(@color_space_family, @color_space.family)
-  end
-
-  it "the color space returns the correct color space definition" do
-    assert_equal(@color_space_definition, @color_space.definition)
-  end
-
-  it "the color responds to :components" do
-    assert(@color.respond_to?(:components))
-  end
-
-  it "the color responds to :color_space" do
-    assert(@color.respond_to?(:color_space))
-  end
-
-  it "the colors are comparable" do
-    refute_equal(@color, @other_color)
-  end
-
-  it "the components are returned in the correct order" do
-    assert_equal(@components, @color_space.color(*@components).components)
-  end
-
-  it "normalizes the colors when using the #color method" do
-    return unless defined?(@colors)
-    assert_equal(@components, @color_space.color(*@colors).components)
-  end
-
-  it "doesn't normalize the colors when using the #prenormalized_color method" do
-    return unless defined?(@colors)
-    assert_equal(@colors, @color_space.prenormalized_color(*@colors).components)
-  end
-
-end
-
-describe HexaPDF::Content::ColorSpace do
-  before do
-    @class = HexaPDF::Content::ColorSpace
-  end
-
-  describe "self.device_color_from_specification" do
-    it "works for gray values" do
-      assert_equal([0.2], @class.device_color_from_specification(51).components)
-    end
-
-    it "works for RGB values" do
-      assert_equal([0.2, 1, 0], @class.device_color_from_specification(51, 255, 0).components)
-    end
-
-    it "works for RGB values given as string" do
-      assert_equal([0.2, 1, 0], @class.device_color_from_specification("33FF00").components)
-    end
-
-    it "works for CMYK values" do
-      assert_equal([0.51, 0.9, 1, 0.5],
-                   @class.device_color_from_specification(51, 90, 100, 50).components)
-    end
-
-    it "works when an array is given" do
-      assert_equal([0.2], @class.device_color_from_specification([51]).components)
-    end
-  end
-
-  it "returns a device color object for prenormalized color values" do
-    assert_equal([5, 6, 7], @class.prenormalized_device_color([5, 6, 7]).components)
-  end
-
-  describe "self.for_components" do
-    it "returns the correct device color space name" do
-      assert_equal(:DeviceGray, @class.for_components([1]))
-      assert_equal(:DeviceRGB, @class.for_components([1, 2, 3]))
-      assert_equal(:DeviceCMYK, @class.for_components([1, 2, 3, 4]))
-    end
-
-    it "fails if an array with an invalid length is passed" do
-      assert_raises(ArgumentError) { @class.for_components([]) }
-    end
-  end
-end
-
-describe HexaPDF::Content::ColorSpace::Universal do
-  include CommonColorSpaceTests
-
-  before do
-    @color_space = HexaPDF::Content::ColorSpace::Universal.new([:test, :value])
-    @color_space_family = :test
-    @color_space_definition = [:test, :value]
-    @color = @color_space.default_color
-    @other_color = @color_space.color(128, 5, 6, 7, 8)
-    @components = [5, 6, 7, 8]
-  end
-
-  it "can be compared to another universal color space" do
-    other = HexaPDF::Content::ColorSpace::Universal.new([:other])
-    same = HexaPDF::Content::ColorSpace::Universal.new([:test, :value])
-    assert_equal(same, @color_space)
-    refute_equal(other, @color_space)
-  end
-end
-
-describe HexaPDF::Content::ColorSpace::DeviceRGB do
-  include CommonColorSpaceTests
-
-  before do
-    @color_space = HexaPDF::Content::ColorSpace::DeviceRGB.new
-    @color_space_family = @color_space_definition = :DeviceRGB
-    @color = @color_space.default_color
-    @other_color = @color_space.color(128, 0, 0)
-    @colors = [128, 0, 255]
-    @components = @colors.map {|c| c.to_f / 255 }
-  end
-end
-
-describe HexaPDF::Content::ColorSpace::DeviceCMYK do
-  include CommonColorSpaceTests
-
-  before do
-    @color_space = HexaPDF::Content::ColorSpace::DeviceCMYK.new
-    @color_space_family = @color_space_definition = :DeviceCMYK
-    @color = @color_space.default_color
-    @other_color = @color_space.color(128, 0, 0, 128)
-    @colors = [0, 20, 40, 80]
-    @components = [0.0, 0.2, 0.4, 0.8]
-  end
-end
-
-describe HexaPDF::Content::ColorSpace::DeviceGray do
-  include CommonColorSpaceTests
-
-  before do
-    @color_space = HexaPDF::Content::ColorSpace::DeviceGray.new
-    @color_space_family = @color_space_definition = :DeviceGray
-    @color = @color_space.default_color
-    @other_color = @color_space.color(128)
-    @colors = [128]
-    @components = [128.0 / 255]
-  end
-end

data/test/hexapdf/content/test_graphics_state.rb

@@ -1,151 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require 'hexapdf/content/graphics_state'
-
-# Dummy class used as wrapper so that constant lookup works correctly
-class GraphicsStateWrapper < Minitest::Spec
-
-  include HexaPDF::Content
-
-  describe NamedValue do
-    before do
-      @val = NamedValue.new(:round, 1)
-    end
-
-    it "freezes a new object on creation" do
-      assert(@val.frozen?)
-    end
-
-    it "can be compared to name, value or NamedValue objects" do
-      assert_equal(@val, :round)
-      assert_equal(@val, 1)
-      assert_equal(@val, @val)
-    end
-
-    it "returns the value when operands are requested" do
-      assert_equal(@val.value, @val.to_operands)
-    end
-  end
-
-  describe LineCapStyle do
-    it "can normalize a style argument" do
-      [[:BUTT_CAP, :butt, 0], [:ROUND_CAP, :round, 1],
-       [:PROJECTING_SQUARE_CAP, :projecting_square, 2]].each do |const_name, name, value|
-        const = LineCapStyle.const_get(const_name)
-        assert_equal(const, LineCapStyle.normalize(name))
-        assert_equal(const, LineCapStyle.normalize(value))
-        assert_equal(const, LineCapStyle.normalize(const))
-      end
-    end
-
-    it "fails when trying to normalize an invalid argument" do
-      assert_raises(ArgumentError) { LineCapStyle.normalize(:invalid) }
-    end
-  end
-
-  describe LineJoinStyle do
-    it "can normalize a style argument" do
-      [[:MITER_JOIN, :miter, 0], [:ROUND_JOIN, :round, 1],
-       [:BEVEL_JOIN, :bevel, 2]].each do |const_name, name, value|
-        const = LineJoinStyle.const_get(const_name)
-        assert_equal(const, LineJoinStyle.normalize(name))
-        assert_equal(const, LineJoinStyle.normalize(value))
-        assert_equal(const, LineJoinStyle.normalize(const))
-      end
-    end
-
-    it "fails when trying to normalize an invalid argument" do
-      assert_raises(ArgumentError) { LineJoinStyle.normalize(:invalid) }
-    end
-  end
-
-  describe RenderingIntent do
-    it "can normalize an intent argument" do
-      assert_equal(RenderingIntent::ABSOLUTE_COLORIMETRIC,
-                   RenderingIntent.normalize(:AbsoluteColorimetric))
-      assert_equal(RenderingIntent::RELATIVE_COLORIMETRIC,
-                   RenderingIntent.normalize(:RelativeColorimetric))
-      assert_equal(RenderingIntent::PERCEPTUAL,
-                   RenderingIntent.normalize(:Perceptual))
-      assert_equal(RenderingIntent::SATURATION,
-                   RenderingIntent.normalize(:Saturation))
-    end
-
-    it "fails when trying to normalize an invalid argument" do
-      assert_raises(ArgumentError) { RenderingIntent.normalize(:invalid) }
-    end
-  end
-
-  describe LineDashPattern do
-    it "returns a normalized line dash pattern from various values" do
-      assert_equal([[], 0], LineDashPattern.normalize(0).to_operands)
-      assert_equal([[5], 0], LineDashPattern.normalize(5).to_operands)
-      assert_equal([[5, 3], 2], LineDashPattern.normalize([5, 3], 2).to_operands)
-      assert_equal([[5], 1], LineDashPattern.normalize(LineDashPattern.normalize(5, 1)).to_operands)
-    end
-
-    it "fails on normalization if an invalid array argument is provided" do
-      assert_raises(ArgumentError) { LineDashPattern.normalize(:bla) }
-    end
-
-    it "fails on initialization if the phase is negative" do
-      assert_raises(ArgumentError) { LineDashPattern.new([], -1) }
-    end
-
-    it "fails on initialization if all the dash array values are zero " do
-      assert_raises(ArgumentError) { LineDashPattern.new([0, 0], 0) }
-    end
-
-    it "fails on initialization if a dash array value is negative" do
-      assert_raises(ArgumentError) { LineDashPattern.new([-2, 0], 0) }
-    end
-
-    it "can be compared to another line dash pattern object" do
-      assert_equal(LineDashPattern.new([2, 3], 0),
-                   LineDashPattern.new([2, 3], 0))
-      refute_equal(LineDashPattern.new([2, 3], 0),
-                   LineDashPattern.new([2, 3], 1))
-      refute_equal(LineDashPattern.new([2, 3], 0),
-                   LineDashPattern.new([2, 2], 0))
-    end
-
-    it "returns the operands needed for the line dash pattern operator" do
-      assert_equal([[2, 3], 0], LineDashPattern.new([2, 3], 0).to_operands)
-    end
-  end
-
-  describe TextRenderingMode do
-    it "can normalize a style argument" do
-      [[:FILL, 0], [:STROKE, 1], [:FILL_STROKE, 2], [:INVISIBLE, 3], [:FILL_CLIP, 4],
-       [:STROKE_CLIP, 5], [:FILL_STROKE_CLIP, 6], [:CLIP, 7]].each do |const_name, value|
-        const = TextRenderingMode.const_get(const_name)
-        assert_equal(const, TextRenderingMode.normalize(const_name.to_s.downcase.intern))
-        assert_equal(const, TextRenderingMode.normalize(value))
-        assert_equal(const, TextRenderingMode.normalize(const))
-      end
-    end
-
-    it "fails when trying to normalize an invalid argument" do
-      assert_raises(ArgumentError) { TextRenderingMode.normalize(:invalid) }
-    end
-  end
-
-  describe GraphicsState do
-    before do
-      @gs = GraphicsState.new
-    end
-
-    it "allows saving and restoring the graphics state" do
-      @gs.save
-      @gs.line_width = 10
-      @gs.restore
-      assert_equal(1, @gs.line_width)
-    end
-
-    it "fails when restoring the graphics state if the stack is empty" do
-      assert_raises(HexaPDF::Error) { @gs.restore }
-    end
-  end
-
-end