cairo 1.14.0-x64-mingw32

data/test/test_exception.rb

@@ -0,0 +1,36 @@
+require 'cairo'
+
+class ExceptionTest < Test::Unit::TestCase
+  def test_new_symbols_since_1_7_2
+    if Cairo.satisfied_version?(1, 7, 2)
+      assertion = :assert_defined
+    else
+      assertion = :assert_not_defined
+    end
+    send(assertion, "FontTypeMismatch")
+    send(assertion, "UserFontImmutable")
+    send(assertion, "UserFontError")
+    send(assertion, "NegativeCount")
+    send(assertion, "InvalidClusters")
+    send(assertion, "InvalidSlant")
+    send(assertion, "InvalidWeight")
+  end
+
+  def test_new_symbols_since_1_14_0
+    if Cairo.satisfied_version?(1, 14, 0)
+      assertion = :assert_defined
+    else
+      assertion = :assert_not_defined
+    end
+    send(assertion, "JBIG2GlobalMissing")
+  end
+
+  private
+  def assert_defined(name)
+    assert_true(Cairo.const_defined?(name))
+  end
+
+  def assert_not_defined(name)
+    assert_false(Cairo.const_defined?(name))
+  end
+end

data/test/test_font_extents.rb

@@ -0,0 +1,36 @@
+require 'cairo'
+
+class FontExtentsTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def test_new
+    extents = Cairo::FontExtents.new
+    assert_equal([1.0, 0.0, 1.0, 1.0, 0.0],
+                 [extents.ascent, extents.descent, extents.height,
+                  extents.max_x_advance, extents.max_y_advance])
+  end
+
+  def test_accessor
+    extents = Cairo::FontExtents.new
+    extents.ascent = 0.1
+    extents.descent = 0.2
+    extents.height = 0.3
+    extents.max_x_advance = 0.4
+    extents.max_y_advance = 0.5
+    assert_equal([0.1, 0.2, 0.3, 0.4, 0.5],
+                 [extents.ascent, extents.descent, extents.height,
+                  extents.max_x_advance, extents.max_y_advance])
+  end
+
+  def test_to_s
+    extents = Cairo::FontExtents.new
+    extents.ascent = 0.1
+    extents.descent = 0.2
+    extents.height = 0.3
+    extents.max_x_advance = 0.4
+    extents.max_y_advance = 0.5
+    assert_equal("#<Cairo::FontExtents: ascent=0.1, descent=0.2, " +
+                 "height=0.3, max_x_advance=0.4, max_y_advance=0.5>",
+                 extents.to_s)
+  end
+end

data/test/test_font_face.rb

@@ -0,0 +1,257 @@
+require 'cairo'
+
+class FontFaceTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def test_toy_font_face_new
+    only_cairo_version(1, 7, 2)
+
+    face = Cairo::ToyFontFace.new
+    default_font_family = ""
+    default_font_family = "Helvetica" if quartz?
+    default_font_family = "Arial" if win32?
+    assert_equal([default_font_family,
+                  Cairo::FONT_SLANT_NORMAL,
+                  Cairo::FONT_WEIGHT_NORMAL],
+                 [face.family, face.slant, face.weight])
+
+    face = Cairo::ToyFontFace.new("serif")
+    assert_equal(["serif", Cairo::FONT_SLANT_NORMAL, Cairo::FONT_WEIGHT_NORMAL],
+                 [face.family, face.slant, face.weight])
+
+    face = Cairo::ToyFontFace.new(:serif)
+    assert_equal(["serif", Cairo::FONT_SLANT_NORMAL, Cairo::FONT_WEIGHT_NORMAL],
+                 [face.family, face.slant, face.weight])
+
+    face = Cairo::ToyFontFace.new("serif", :oblique)
+    assert_equal(["serif", Cairo::FONT_SLANT_OBLIQUE, Cairo::FONT_WEIGHT_NORMAL],
+                 [face.family, face.slant, face.weight])
+
+    face = Cairo::ToyFontFace.new("serif", nil, :bold)
+    assert_equal(["serif", Cairo::FONT_SLANT_NORMAL, Cairo::FONT_WEIGHT_BOLD],
+                 [face.family, face.slant, face.weight])
+
+    face = Cairo::ToyFontFace.new("serif", :italic, :bold)
+    assert_equal(["serif", Cairo::FONT_SLANT_ITALIC, Cairo::FONT_WEIGHT_BOLD],
+                 [face.family, face.slant, face.weight])
+  end
+
+  def test_toy_font_face_new_with_invalid_family_name
+    only_cairo_version(1, 7, 2)
+
+    exception = assert_raise(ArgumentError) do
+      Cairo::ToyFontFace.new(999)
+    end
+    assert_equal("family name should be nil, String or Symbol: 999",
+                 exception.message)
+  end
+
+  def test_user_font_face_empty
+    only_cairo_version(1, 7, 2)
+
+    face = Cairo::UserFontFace.new
+    scaled_font = Cairo::ScaledFont.new(face,
+                                        Cairo::Matrix.identity,
+                                        Cairo::Matrix.identity,
+                                        Cairo::FontOptions.new)
+    assert_equal([[], [], 0],
+                 scaled_font.text_to_glyphs(0, 0, "text"))
+  end
+
+  def test_user_font_face_callback
+    only_cairo_version(1, 7, 2)
+
+    face = Cairo::UserFontFace.new
+
+    init_args = []
+    face.on_init do |*args|
+      init_args << args
+    end
+
+    render_glyph_args = []
+    face.on_render_glyph do |*args|
+      render_glyph_args << args
+    end
+
+    text_to_glyphs_args = []
+    face.on_text_to_glyphs do |*args|
+      text_to_glyphs_args << args
+      scaled_font, utf8, data = args
+      data.cluster_flags = :backward
+    end
+
+    unicode_to_glyph_args = []
+    face.on_unicode_to_glyph do |*args|
+      unicode_to_glyph_args << args
+      scaled_font, unicode = args
+      unicode
+    end
+
+    scaled_font = Cairo::ScaledFont.new(face,
+                                        Cairo::Matrix.identity,
+                                        Cairo::Matrix.identity,
+                                        Cairo::FontOptions.new)
+    result = scaled_font.text_to_glyphs(0, 0, "text")
+    assert_equal([[[Cairo::ScaledFont, Cairo::Context, Cairo::FontExtents]],
+                  [[Cairo::ScaledFont, codepoint("t"),
+                    Cairo::Context, Cairo::TextExtents],
+                   [Cairo::ScaledFont, codepoint("e"),
+                    Cairo::Context, Cairo::TextExtents],
+                   [Cairo::ScaledFont, codepoint("x"),
+                    Cairo::Context, Cairo::TextExtents]],
+                  [[Cairo::ScaledFont, "text",
+                    Cairo::UserFontFace::TextToGlyphsData]],
+                  [[Cairo::ScaledFont, codepoint("t")],
+                   [Cairo::ScaledFont, codepoint("e")],
+                   [Cairo::ScaledFont, codepoint("x")],
+                   [Cairo::ScaledFont, codepoint("t")]],
+                  [[], [], Cairo::TextClusterFlag::BACKWARD]],
+                 [classify_cairo_object(init_args),
+                  classify_cairo_object(render_glyph_args),
+                  classify_cairo_object(text_to_glyphs_args),
+                  classify_cairo_object(unicode_to_glyph_args),
+                  result])
+  end
+
+  if Cairo.satisfied_version?(1, 7, 2)
+    class CustomUserFontFace < Cairo::UserFontFace
+      attr_reader :init_args, :render_glyph_args
+      attr_reader :text_to_glyphs_args, :unicode_to_glyph_args
+      def initialize
+        super
+        @init_args = []
+        @render_glyph_args = []
+        @text_to_glyphs_args = []
+        @unicode_to_glyph_args = []
+      end
+
+      def init(*args)
+        @init_args << args
+      end
+
+      def render_glyph(*args)
+        @render_glyph_args << args
+      end
+
+      def text_to_glyphs(*args)
+        @text_to_glyphs_args << args
+        scaled_font, utf8, data = args
+        data.cluster_flags = :backward
+      end
+
+      def unicode_to_glyph(*args)
+        @unicode_to_glyph_args << args
+        scaled_font, unicode = args
+        unicode
+      end
+    end
+  end
+
+  def test_user_font_face_class
+    only_cairo_version(1, 7, 2)
+
+    face = CustomUserFontFace.new
+
+    scaled_font = Cairo::ScaledFont.new(face,
+                                        Cairo::Matrix.identity,
+                                        Cairo::Matrix.identity,
+                                        Cairo::FontOptions.new)
+    result = scaled_font.text_to_glyphs(0, 0, "text")
+    assert_equal([[[Cairo::ScaledFont, Cairo::Context, Cairo::FontExtents]],
+                  [[Cairo::ScaledFont, codepoint("t"),
+                    Cairo::Context, Cairo::TextExtents],
+                   [Cairo::ScaledFont, codepoint("e"),
+                    Cairo::Context, Cairo::TextExtents],
+                   [Cairo::ScaledFont, codepoint("x"),
+                    Cairo::Context, Cairo::TextExtents]],
+                  [[Cairo::ScaledFont, "text",
+                    Cairo::UserFontFace::TextToGlyphsData]],
+                  [[Cairo::ScaledFont, codepoint("t")],
+                   [Cairo::ScaledFont, codepoint("e")],
+                   [Cairo::ScaledFont, codepoint("x")],
+                   [Cairo::ScaledFont, codepoint("t")]],
+                  [[], [], Cairo::TextClusterFlag::BACKWARD]],
+                 [classify_cairo_object(face.init_args),
+                  classify_cairo_object(face.render_glyph_args),
+                  classify_cairo_object(face.text_to_glyphs_args),
+                  classify_cairo_object(face.unicode_to_glyph_args),
+                  result])
+  end
+
+  def test_user_font_face_class_and_callback
+    only_cairo_version(1, 7, 2)
+
+    face = CustomUserFontFace.new
+
+    init_args = []
+    face.on_init do |*args|
+      init_args << args
+    end
+
+    render_glyph_args = []
+    face.on_render_glyph do |*args|
+      render_glyph_args << args
+    end
+
+    text_to_glyphs_args = []
+    face.on_text_to_glyphs do |*args|
+      text_to_glyphs_args << args
+      scaled_font, utf8, data = args
+      data.cluster_flags = :backward
+    end
+
+    unicode_to_glyph_args = []
+    face.on_unicode_to_glyph do |*args|
+      unicode_to_glyph_args << args
+      scaled_font, unicode = args
+      unicode
+    end
+
+    scaled_font = Cairo::ScaledFont.new(face,
+                                        Cairo::Matrix.identity,
+                                        Cairo::Matrix.identity,
+                                        Cairo::FontOptions.new)
+    result = scaled_font.text_to_glyphs(0, 0, "text")
+    assert_equal([[[Cairo::ScaledFont, Cairo::Context, Cairo::FontExtents]],
+                  [[Cairo::ScaledFont, codepoint("t"),
+                    Cairo::Context, Cairo::TextExtents],
+                   [Cairo::ScaledFont, codepoint("e"),
+                    Cairo::Context, Cairo::TextExtents],
+                   [Cairo::ScaledFont, codepoint("x"),
+                    Cairo::Context, Cairo::TextExtents]],
+                  [[Cairo::ScaledFont, "text",
+                    Cairo::UserFontFace::TextToGlyphsData]],
+                  [[Cairo::ScaledFont, codepoint("t")],
+                   [Cairo::ScaledFont, codepoint("e")],
+                   [Cairo::ScaledFont, codepoint("x")],
+                   [Cairo::ScaledFont, codepoint("t")]],
+                  [],
+                  [],
+                  [],
+                  [],
+                  [[], [], Cairo::TextClusterFlag::BACKWARD]],
+                 [classify_cairo_object(init_args),
+                  classify_cairo_object(render_glyph_args),
+                  classify_cairo_object(text_to_glyphs_args),
+                  classify_cairo_object(unicode_to_glyph_args),
+                  classify_cairo_object(face.init_args),
+                  classify_cairo_object(face.render_glyph_args),
+                  classify_cairo_object(face.text_to_glyphs_args),
+                  classify_cairo_object(face.unicode_to_glyph_args),
+                  result])
+  end
+
+  def classify_cairo_object(object)
+    if object.is_a?(Array)
+      object.collect {|obj| classify_cairo_object(obj)}
+    elsif /\ACairo::/ =~ object.class.name
+      object.class
+    else
+      object
+    end
+  end
+
+  def codepoint(character)
+    character.unpack("U")[0]
+  end
+end

data/test/test_font_options.rb

@@ -0,0 +1,13 @@
+require 'cairo'
+
+class FontOptionsTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def setup
+    @options = Cairo::FontOptions.new
+  end
+
+  def test_something
+    # WRITE ME!
+  end
+end

data/test/test_image_surface.rb

@@ -0,0 +1,28 @@
+require 'cairo'
+
+class ImageSurfaceTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def test_cloned_data
+    width = 10
+    height = 10
+    original_surface = Cairo::ImageSurface.new(:a1, width, height)
+
+    original_data = original_surface.data
+    cloned_data = original_data.clone
+
+    cloned_surface = Cairo::ImageSurface.new(cloned_data,
+                                             :a1, width, height,
+                                             original_surface.stride)
+
+    Cairo::Context.new(cloned_surface) do |context|
+      context.set_source_rgb(255, 255, 255)
+      context.scale(width, height)
+      context.move_to(0, 0)
+      context.line_to(1, 1)
+      context.stroke
+    end
+
+    assert_not_equal(original_data, cloned_data)
+  end
+end

data/test/test_paper.rb

@@ -0,0 +1,81 @@
+require 'cairo'
+
+class PaperTest < Test::Unit::TestCase
+  def test_parse_paper
+    a4 = Cairo::Paper::A4
+    assert_parse(a4, a4)
+  end
+
+  def test_parse_name
+    assert_parse(:A4, "A4")
+    assert_parse(:A4_LANDSCAPE, "A4 landscape")
+    assert_parse(:A4, :A4)
+    assert_parse(:A4, :a4)
+
+    assert_parse(:JAPANESE_POSTCARD, :japanese_postcard)
+    assert_parse(:JAPANESE_POSTCARD, "japanese-postcard")
+    assert_parse(:JAPANESE_POSTCARD, "Japanese postcard")
+
+    exception = assert_raise(Cairo::Paper::UnknownPaperName) do
+      Cairo::Paper.parse(:nonexistence)
+    end
+    assert_equal(:nonexistence, exception.name)
+  end
+
+  def test_parse_size
+    assert_parse(paper(100, 200), "100x200")
+    assert_parse(paper(283.46456664, 566.929134), "100mmx200mm")
+    assert_parse(paper(284.88188952, 200.9), "100.5mmx200.9")
+    assert_parse(paper(72, 612.0), "1inx8.5inch")
+    assert_parse(paper(28.346456664, 24094.488168), "1cmx8.5m")
+    assert_parse(paper(100, 200), [100, 200])
+
+    exception = assert_raise(Cairo::Paper::UnknownUnit) do
+      Cairo::Paper.parse("100kmx100")
+    end
+    assert_equal("km", exception.unit)
+  end
+
+  def test_parse_size_with_name
+    assert_parse(paper(28.346456664, 24094.488168, nil, "Name"),
+                 "1cmx8.5m#Name")
+  end
+
+  def test_unrecognized_input
+    assert_nothing_raised do
+      Cairo::Paper.parse({})
+    end
+
+    exception = assert_raise(Cairo::Paper::UnrecognizedPaperDescription) do
+      Cairo::Paper.parse({}, true)
+    end
+    assert_equal({}, exception.description)
+  end
+
+  def test_unit
+    paper = parse("1cmx8.5m")
+    assert_nil(paper.unit)
+    assert_in_delta(28.346456664, 0.01, paper.width)
+    assert_in_delta(24094.488168, 0.01, paper.height)
+
+    paper.unit = "inch"
+    assert_equal("inch", paper.unit)
+    assert_in_delta(0.393700787, 0.01, paper.width)
+    assert_in_delta(334.645669, 0.01, paper.height)
+  end
+
+  private
+  def paper(width, height, *rest)
+    Cairo::Paper.new(width, height, *rest)
+  end
+
+  def parse(paper_description)
+    Cairo::Paper.parse(paper_description)
+  end
+
+  def assert_parse(expected, paper_description, message=nil)
+    expected = Cairo::Paper.const_get(expected) if expected.is_a?(Symbol)
+    actual_paper = parse(paper_description)
+    assert_equal(expected, actual_paper, message)
+  end
+end