hexapdf 0.1.0

data/test/hexapdf/content/test_color_space.rb

@@ -0,0 +1,97 @@
+# -*- 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 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 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
+
+end
+
+describe HexaPDF::Content::ColorSpace::Universal do
+  include CommonColorSpaceTests
+
+  before do
+    @color_space = HexaPDF::Content::ColorSpace::Universal.new([:test])
+    @color_space_family = :test
+    @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])
+    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 = :DeviceRGB
+    @color = @color_space.default_color
+    @other_color = @color_space.color(128, 0, 0)
+    @components = [0.5, 0.2, 0.3]
+  end
+end
+
+describe HexaPDF::Content::ColorSpace::DeviceCMYK do
+  include CommonColorSpaceTests
+
+  before do
+    @color_space = HexaPDF::Content::ColorSpace::DeviceCMYK.new
+    @color_space_family = :DeviceCMYK
+    @color = @color_space.default_color
+    @other_color = @color_space.color(128, 0, 0, 128)
+    @components = [0.1, 0.2, 0.3, 0.4]
+  end
+end
+
+describe HexaPDF::Content::ColorSpace::DeviceGray do
+  include CommonColorSpaceTests
+
+  before do
+    @color_space = HexaPDF::Content::ColorSpace::DeviceGray.new
+    @color_space_family = :DeviceGray
+    @color = @color_space.default_color
+    @other_color = @color_space.color(128)
+    @components = [0.1]
+  end
+end

data/test/hexapdf/content/test_graphics_state.rb

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