cairo 1.14.0-x64-mingw32

data/test/test_quartz_image_surface.rb

@@ -0,0 +1,13 @@
+class QuartzImageSurfaceTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def setup
+    only_surface("QuartzImage")
+  end
+
+  def test_quartz_image_surface
+    surface = Cairo::ImageSurface.new(100, 100)
+    quartz_surface = Cairo::QuartzImageSurface.new(surface)
+    assert_kind_of(Cairo::QuartzImageSurface, quartz_surface)
+  end
+end

data/test/test_raster_source_pattern.rb

@@ -0,0 +1,162 @@
+require "cairo"
+require "tempfile"
+
+class RasterSourcePatternTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def setup
+    only_pattern("RasterSource")
+  end
+
+  def test_acquire_and_release
+    Cairo::ImageSurface.new(100, 100) do |surface|
+      Cairo::Context.new(surface) do |context|
+        context.set_source(1, 1, 1)
+        context.paint
+
+        called = []
+        red_pattern = Cairo::RasterSourcePattern.new(100, 100)
+        red_pattern.acquire do |pattern, target, extents|
+          called << :acquire
+          red_image = target.create_similar_image(extents.width, extents.height)
+          red_image.set_device_offset(extents.x, extents.y)
+          Cairo::Context.new(red_image) do |red_image_context|
+            red_image_context.set_source(1, 0, 0)
+            red_image_context.paint
+          end
+          red_image
+        end
+        red_pattern.release do |pattern, surface|
+          called << :release
+          surface.finish
+        end
+        context.set_source(red_pattern)
+        context.rectangle(40, 40, 20, 20)
+        context.fill
+        assert_equal([:acquire, :release], called)
+      end
+      show_result(surface)
+    end
+  end
+
+  class SnapshotTest < self
+    def setup
+      super
+      only_surface("Recording")
+    end
+
+    def test_success
+      Cairo::RecordingSurface.new(0, 0, 100, 100) do |surface|
+        Cairo::Context.new(surface) do |context|
+          called = []
+          raster_source = Cairo::RasterSourcePattern.new(100, 100)
+          raster_source.snapshot do |pattern|
+            called << :snapshot
+          end
+          context.set_source(raster_source)
+          context.rectangle(40, 40, 20, 20)
+          context.fill
+          assert_equal([:snapshot], called)
+        end
+        show_result(surface)
+      end
+    end
+
+    def test_error
+      Cairo::RecordingSurface.new(0, 0, 100, 100) do |surface|
+        Cairo::Context.new(surface) do |context|
+          called = []
+          raster_source = Cairo::RasterSourcePattern.new(100, 100)
+          raster_source.snapshot do |pattern|
+            called << :snapshot
+            raise NoMemoryError
+          end
+          context.set_source(raster_source)
+          context.rectangle(40, 40, 20, 20)
+          assert_raise(NoMemoryError) do
+            context.fill
+          end
+          assert_equal([:snapshot], called)
+        end
+        show_result(surface)
+      end
+    end
+  end
+
+  class CopyTest < self
+    def setup
+      super
+      only_surface("Script")
+    end
+
+    def test_success
+      output = StringIO.new
+      device = Cairo::ScriptDevice.new(output)
+      Cairo::ScriptSurface.new(device, 100, 200) do |surface|
+        Cairo::Context.new(surface) do |context|
+          called = []
+
+          raster_source = Cairo::RasterSourcePattern.new(100, 100)
+          raster_source.acquire do |pattern, target, extents|
+            called << :acquire
+            red_image = target.create_similar_image(extents.width,
+                                                    extents.height)
+            red_image.set_device_offset(extents.x, extents.y)
+            Cairo::Context.new(red_image) do |red_image_context|
+              red_image_context.set_source(1, 0, 0)
+              red_image_context.paint
+            end
+            red_image
+          end
+          raster_source.release do |pattern, surface|
+            called << :release
+            surface.finish
+          end
+          raster_source.copy do |pattern|
+            called << :copy
+          end
+
+          context.set_source(raster_source)
+          context.rectangle(40, 40, 20, 20)
+          context.fill
+
+          assert_equal([:copy, :acquire, :release], called)
+        end
+        show_result(surface)
+      end
+    end
+
+    def test_error
+      output = StringIO.new
+      device = Cairo::ScriptDevice.new(output)
+      Cairo::ScriptSurface.new(device, 100, 200) do |surface|
+        Cairo::Context.new(surface) do |context|
+          called = []
+
+          raster_source = Cairo::RasterSourcePattern.new(100, 100)
+          raster_source.copy do |pattern|
+            called << :copy
+            raise NoMemoryError
+          end
+
+          context.set_source(raster_source)
+          context.rectangle(40, 40, 20, 20)
+          assert_raise(NoMemoryError) do
+            context.fill
+          end
+
+          assert_equal([:copy], called)
+        end
+        show_result(surface)
+      end
+    end
+  end
+
+  private
+  def show_result(image_surface)
+    return if ENV["RCAIRO_TEST_SHOW_RESULT"] != "yes"
+    result = Tempfile.new("result")
+    image_surface.write_to_png(result.path)
+    system("display", result.path)
+  end
+end

data/test/test_recording_surface.rb

@@ -0,0 +1,19 @@
+class RecordingSurfaceTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def setup
+    only_surface("Recording")
+  end
+
+  def test_new
+    only_cairo_version(1, 12, 0)
+    surface = Cairo::RecordingSurface.new(10, 20, 300, 400)
+    assert_equal([0.0, 0.0, 0.0, 0.0], surface.ink_extents)
+    Cairo::Context.new(surface) do |context|
+      context.move_to(15, 30)
+      context.line_to(80, 100)
+      context.stroke
+    end
+    assert_equal([10.0, 20.0, 61.0, 61.0], surface.ink_extents)
+  end
+end

data/test/test_region.rb

@@ -0,0 +1,102 @@
+class RegionTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def setup
+    only_cairo_version(1, 10, 0)
+  end
+
+  def test_new_empty
+    region = Cairo::Region.new
+    assert_predicate(region, :empty?)
+  end
+
+  def test_new_rectangle
+    region = Cairo::Region.new([0, 0, 10, 10])
+    assert_not_predicate(region, :empty?)
+  end
+
+  def test_num_rectangles
+    region = Cairo::Region.new
+    assert_equal(0, region.num_rectangles)
+  end
+
+  def test_get_rectangle
+    region = Cairo::Region.new([0, 0, 10, 10])
+    assert_equal([0, 0, 10, 10], region[0])
+  end
+
+  def test_dup
+    region = Cairo::Region.new([0, 0, 10, 10])
+    region.dup.subtract!([5, 5, 5, 5])
+    assert_equal([0, 0, 10, 10], region.extents)
+  end
+
+  def test_equal
+    assert_equal(Cairo::Region.new([0, 0, 10, 10]),
+                 Cairo::Region.new([0, 0, 10, 10]))
+    assert_not_equal(Cairo::Region.new([0, 0, 10, 10]),
+                     Cairo::Region.new([0, 0, 100, 100]))
+  end
+
+  def test_extents
+    region = Cairo::Region.new
+    assert_equal([0, 0, 0, 0], region.extents)
+    region.union!([0, 0, 10, 10])
+    assert_equal([0, 0, 10, 10], region.extents)
+  end
+
+  def test_contains_rectangle
+    region = Cairo::Region.new([0, 0, 10, 10])
+    assert_equal(Cairo::RegionOverlap::IN,
+                 region.contains_rectangle([2, 2, 2, 2]))
+    assert_equal(Cairo::RegionOverlap::OUT,
+                 region.contains_rectangle([10, 10, 1, 1]))
+    assert_equal(Cairo::RegionOverlap::PART,
+                 region.contains_rectangle([2, 2, 10, 10]))
+  end
+
+  def test_contains_point
+    region = Cairo::Region.new([0, 0, 10, 10])
+    assert_equal(true, region.contains_point?(5, 5))
+    assert_equal(false, region.contains_point?(10, 10))
+  end
+
+  def test_translate
+    region = Cairo::Region.new([0, 0, 10, 10])
+    assert_equal(true, region.contains_point?(5, 5))
+    region.translate!(6, 6)
+    assert_equal(false, region.contains_point?(5, 5))
+  end
+
+  def test_subtract
+    region = Cairo::Region.new([0, 0, 10, 10])
+    assert_equal(true, region.contains_point?(5, 5))
+    region.subtract!([5, 5, 2, 2])
+    assert_equal(false, region.contains_point?(5, 5))
+  end
+
+  def test_intersect
+    region = Cairo::Region.new([0, 0, 10, 10])
+    assert_equal(true, region.contains_point?(5, 5))
+    assert_equal(true, region.contains_point?(7, 7))
+    region.intersect!([5, 5, 2, 2])
+    assert_equal(true, region.contains_point?(5, 5))
+    assert_equal(false, region.contains_point?(7, 7))
+  end
+
+  def test_union
+    region = Cairo::Region.new([0, 0, 4, 4])
+    assert_equal(false, region.contains_point?(5, 5))
+    region.union!([5, 5, 5, 5])
+    assert_equal(true, region.contains_point?(5, 5))
+  end
+
+  def test_xor
+    region = Cairo::Region.new([0, 0, 5, 5])
+    assert_equal(true, region.contains_point?(4, 4))
+    assert_equal(false, region.contains_point?(7, 7))
+    region.xor!([3, 3, 5, 5])
+    assert_equal(false, region.contains_point?(4, 4))
+    assert_equal(true, region.contains_point?(7, 7))
+  end
+end

data/test/test_scaled_font.rb

@@ -0,0 +1,34 @@
+require 'cairo'
+require 'stringio'
+
+class ScaledFontTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def test_scale_matrix
+    only_cairo_version(1, 7, 2)
+
+    surface = Cairo::ImageSurface.new(100, 100)
+    context = Cairo::Context.new(surface)
+    scaled_font = context.scaled_font
+
+    assert_equal(Cairo::Matrix.new(10.0, 0.0, 0.0,
+                                   10.0, 0.0, 0.0),
+                 scaled_font.scale_matrix)
+  end
+
+  def test_text_to_glyphs
+    only_cairo_version(1, 7, 6)
+
+    surface = Cairo::PDFSurface.new(StringIO.new, 10, 10)
+    context = Cairo::Context.new(surface)
+    scaled_font = Cairo::ScaledFont.new(context.font_face,
+                                        Cairo::Matrix.identity,
+                                        Cairo::Matrix.identity,
+                                        Cairo::FontOptions.new)
+    expected_glyphs = []
+    expected_clusters = []
+    expected_cluster_flags = 0
+    assert_equal([expected_glyphs, expected_clusters, expected_cluster_flags],
+                 scaled_font.text_to_glyphs(0, 0, "text"))
+  end
+end

data/test/test_script_device.rb

@@ -0,0 +1,46 @@
+require 'cairo'
+require 'stringio'
+
+class ScriptDeviceTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def setup
+    only_device("Script")
+  end
+
+  def test_new
+    output = StringIO.new
+    device = Cairo::ScriptDevice.new(output)
+    assert_equal("%!CairoScript\n", output.string)
+    device.finish
+    assert_equal("%!CairoScript\n", output.string)
+  end
+
+  def test_new_with_block
+    output = StringIO.new
+    string = nil
+    Cairo::ScriptDevice.new(output) do |device|
+      string = output.string
+    end
+    assert_equal("%!CairoScript\n", string)
+  end
+
+  def test_write_comment
+    output = StringIO.new
+    Cairo::ScriptDevice.new(output) do |device|
+      device.write_comment("Hello!")
+    end
+    assert_equal("%!CairoScript\n" +
+                 "% Hello!\n",
+                 output.string)
+  end
+
+  def test_mode
+    output = StringIO.new
+    Cairo::ScriptDevice.new(output) do |device|
+      assert_equal(Cairo::ScriptMode::ASCII, device.mode)
+      device.mode = Cairo::ScriptMode::BINARY
+      assert_equal(Cairo::ScriptMode::BINARY, device.mode)
+    end
+  end
+end

data/test/test_script_surface.rb

@@ -0,0 +1,13 @@
+class ScriptSurfaceTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def setup
+    only_surface("Script")
+  end
+
+  def test_device
+    device = Cairo::ScriptDevice.new(StringIO.new)
+    surface = Cairo::ScriptSurface.new(device, 100, 100)
+    assert_equal(Cairo::ScriptDevice, surface.device.class)
+  end
+end

data/test/test_surface.rb

@@ -0,0 +1,61 @@
+require 'cairo'
+require 'stringio'
+
+class SurfaceTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def test_new
+    output = StringIO.new
+    surface = Cairo::PDFSurface.new(output, 10, 10)
+    assert_not_equal("%%EOF\n", output.string[-6..-1])
+    surface.finish
+    assert_equal("%%EOF\n", output.string[-6..-1])
+  end
+
+  def test_new_with_block
+    output = StringIO.new
+    Cairo::PDFSurface.new(output, 10, 10) do |surface|
+      assert_not_equal("%%EOF\n", output.string[-6..-1])
+    end
+    assert_equal("%%EOF\n", output.string[-6..-1])
+  end
+
+  def test_new_with_block_and_finish
+    assert_nothing_raised do
+      Cairo::PDFSurface.new(StringIO.new, 10, 10) do |surface|
+        surface.finish
+      end
+    end
+  end
+
+  def test_device_scale
+    only_cairo_version(1, 14, 0)
+    surface = Cairo::ImageSurface.new(100, 100)
+
+    assert_equal([1.0, 1.0], surface.device_scale)
+
+    surface.set_device_scale(3.0, 4.0)
+    assert_equal([3.0, 4.0], surface.device_scale)
+  end
+
+  def test_fallback_resolution
+    only_cairo_version(1, 7, 2)
+
+    surface = Cairo::ImageSurface.new(100, 100)
+
+    assert_equal([300.0, 300.0], surface.fallback_resolution)
+
+    surface.set_fallback_resolution(95, 95)
+    assert_equal([95.0, 95.0], surface.fallback_resolution)
+  end
+
+  def test_mime_data
+    only_cairo_version(1, 10, 0)
+
+    output = StringIO.new
+    surface = Cairo::PDFSurface.new(output, 100, 100)
+    surface.set_mime_data(Cairo::MimeType::URI, "http://cairo.rubyforge.org/")
+    assert_equal("http://cairo.rubyforge.org/",
+                 surface.get_mime_data(Cairo::MimeType::URI))
+  end
+end