cairo 1.6.3 → 1.7.0

data/test/cairo-test-utils.rb

@@ -0,0 +1,18 @@
+require 'cairo'
+
+module CairoTestUtils
+  private
+  def only_cairo_version(major, minor, micro=nil)
+    unless Cairo.satisfied_version?(major, minor, micro)
+      omit("Require cairo >= #{major}.#{minor}.#{micro}")
+    end
+  end
+
+  def only_win32
+    omit("Only for Win32 platform") unless win32
+  end
+
+  def win32?
+    /cygwin|mingw|mswin32|bccwin32/.match(RUBY_PLATFORM) ? true : false
+  end
+end

data/test/run-test.rb

@@ -1,15 +1,28 @@
 #!/usr/bin/env ruby
 
 base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+test_unit_dir = File.join(base_dir, "test-unit", "lib")
 src_dir = File.join(base_dir, "src")
 lib_dir = File.join(src_dir, "lib")
+test_dir = File.join(base_dir, "test")
+
+if system("which make > /dev/null")
+  system("cd #{base_dir.dump} && make > /dev/null") or exit(1)
+end
+
+$LOAD_PATH.unshift(test_unit_dir)
+
+require 'test/unit'
 
 $LOAD_PATH.unshift(base_dir)
 $LOAD_PATH.unshift(src_dir)
 $LOAD_PATH.unshift(lib_dir)
 
-require 'test/unit'
+$LOAD_PATH.unshift(test_dir)
+require 'cairo-test-utils'
 
 Dir.glob("test/**/test_*.rb") do |file|
   require file.sub(/\.rb$/, '')
 end
+
+exit Test::Unit::AutoRunner.run(false)

data/test/test_constants.rb

@@ -0,0 +1,19 @@
+require 'cairo'
+
+class ConstantsTest < Test::Unit::TestCase
+  def test_lcd_filter
+    constant_name = "LCDFilter"
+    unless Cairo.satisfied_version?(1, 7, 2)
+      assert_false(Cairo.const_defined?(constant_name))
+      return
+    end
+
+    assert_true(Cairo.const_defined?(constant_name))
+    assert_equal((0..4).to_a,
+                 [Cairo::LCDFilter::DEFAULT,
+                  Cairo::LCDFilter::NONE,
+                  Cairo::LCDFilter::INTRA_PIXEL,
+                  Cairo::LCDFilter::FIR3,
+                  Cairo::LCDFilter::FIR5])
+  end
+end

data/test/test_context.rb

@@ -0,0 +1,117 @@
+require 'cairo'
+require 'stringio'
+
+class ContextTest < Test::Unit::TestCase
+  include CairoTestUtils
+
+  def setup
+    @output = StringIO.new
+    @surface = Cairo::PDFSurface.new(@output, 10, 10)
+  end
+
+  def test_new_and_destroy
+    context = Cairo::Context.new(@surface)
+    @surface.destroy
+    assert_no_match(/%%EOF\s*\z/m, @output.string)
+    context.destroy
+    assert_match(/%%EOF\s*\z/m, @output.string)
+  end
+
+  def test_new_with_block
+    Cairo::Context.new(@surface) do |context|
+      @surface.destroy
+      assert_no_match(/%%EOF\s*\z/m, @output.string)
+    end
+    assert_match(/%%EOF\s*\z/m, @output.string)
+  end
+
+  def test_new_with_block_and_destroy
+    assert_nothing_raised do
+      Cairo::Context.new(@surface) do |context|
+        context.destroy
+      end
+    end
+  end
+
+  def test_font_face
+    only_cairo_version(1, 7, 2)
+
+    context = Cairo::Context.new(@surface)
+
+    assert_kind_of(Cairo::FontFace, context.font_face)
+
+    face = Cairo::ToyFontFace.new("serif")
+    context.font_face = face
+    assert_equal("serif", context.font_face.family)
+
+    face = Cairo::ToyFontFace.new("sans")
+    context.font_face = face
+    assert_equal("sans", context.font_face.family)
+  end
+
+  def test_have_show_text_glyphs?
+    only_cairo_version(1, 7, 2)
+
+    pdf_surface = Cairo::PDFSurface.new(@output, 10, 10)
+    context = Cairo::Context.new(pdf_surface)
+    assert_true(context.have_show_text_glyphs?)
+
+    image_surface = Cairo::ImageSurface.new(10, 10)
+    context = Cairo::Context.new(image_surface)
+    assert_false(context.have_show_text_glyphs?)
+  end
+
+  def test_text_to_glyphs
+    only_cairo_version(1, 7, 2)
+
+    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)
+
+    utf8 = "text"
+    glyphs, clusters, backward = scaled_font.text_to_glyphs(0, 0, utf8)
+    assert_nothing_raised do
+      context.show_text_glyphs(utf8, glyphs, clusters, backward)
+    end
+  end
+
+  def test_select_font_face
+    only_cairo_version(1, 7, 2)
+
+    context = Cairo::Context.new(@surface)
+
+    face = context.font_face
+    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])
+
+    context.select_font_face
+    face = context.font_face
+    assert_equal([default_font_family,
+                  Cairo::FONT_SLANT_NORMAL,
+                  Cairo::FONT_WEIGHT_NORMAL],
+                 [face.family, face.slant, face.weight])
+
+    context.select_font_face(:serif, :italic, :bold)
+    face = context.font_face
+    assert_equal(["serif", Cairo::FONT_SLANT_ITALIC, Cairo::FONT_WEIGHT_BOLD],
+                 [face.family, face.slant, face.weight])
+  end
+
+  def test_select_font_face_with_invalid_family_name
+    context = Cairo::Context.new(@surface)
+
+    exception = assert_raise(ArgumentError) do
+      context.select_font_face([999])
+    end
+    assert_equal("family name should be nil, String or Symbol: [999]",
+                 exception.message)
+  end
+end

data/test/test_exception.rb

@@ -0,0 +1,27 @@
+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
+
+  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,244 @@
+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([[], [], false],
+                 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.backward = true
+    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, ?t, Cairo::Context, Cairo::TextExtents],
+                   [Cairo::ScaledFont, ?e, Cairo::Context, Cairo::TextExtents],
+                   [Cairo::ScaledFont, ?x, Cairo::Context, Cairo::TextExtents]],
+                  [[Cairo::ScaledFont, "text",
+                    Cairo::UserFontFace::TextToGlyphsData]],
+                  [[Cairo::ScaledFont, ?t],
+                   [Cairo::ScaledFont, ?e],
+                   [Cairo::ScaledFont, ?x],
+                   [Cairo::ScaledFont, ?t]],
+                  [[], [], true]],
+                 [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.backward = true
+      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, ?t, Cairo::Context, Cairo::TextExtents],
+                   [Cairo::ScaledFont, ?e, Cairo::Context, Cairo::TextExtents],
+                   [Cairo::ScaledFont, ?x, Cairo::Context, Cairo::TextExtents]],
+                  [[Cairo::ScaledFont, "text",
+                    Cairo::UserFontFace::TextToGlyphsData]],
+                  [[Cairo::ScaledFont, ?t],
+                   [Cairo::ScaledFont, ?e],
+                   [Cairo::ScaledFont, ?x],
+                   [Cairo::ScaledFont, ?t]],
+                  [[], [], true]],
+                 [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.backward = true
+    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, ?t, Cairo::Context, Cairo::TextExtents],
+                   [Cairo::ScaledFont, ?e, Cairo::Context, Cairo::TextExtents],
+                   [Cairo::ScaledFont, ?x, Cairo::Context, Cairo::TextExtents]],
+                  [[Cairo::ScaledFont, "text",
+                    Cairo::UserFontFace::TextToGlyphsData]],
+                  [[Cairo::ScaledFont, ?t],
+                   [Cairo::ScaledFont, ?e],
+                   [Cairo::ScaledFont, ?x],
+                   [Cairo::ScaledFont, ?t]],
+                  [],
+                  [],
+                  [],
+                  [],
+                  [[], [], true]],
+                 [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
+end