hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/content/test_color_space.rb

@@ -0,0 +1,176 @@
+# -*- 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 full hex string" do
+      assert_equal([0.2, 1, 0], @class.device_color_from_specification("33FF00").components)
+    end
+
+    it "works for RGB values given as half hex string" do
+      assert_equal([0.2, 1, 0], @class.device_color_from_specification("3F0").components)
+    end
+
+    it "works for RGB values given as color names" do
+      assert_equal([0, 0, 1], @class.device_color_from_specification("blue").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
+
+    it "raises an error if an invalid color string is given" do
+      assert_raises(ArgumentError) { @class.device_color_from_specification("unknown") }
+    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

@@ -0,0 +1,151 @@
+# -*- 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