hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/font/true_type/table/test_head.rb

@@ -0,0 +1,56 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'common'
+require 'hexapdf/font/true_type/table/head'
+
+describe HexaPDF::Font::TrueType::Table::Head do
+  before do
+    data = [1, 0, 2, 6554, 0, 42, 0x5f0f, 0x3CF5, 3, 64].pack('n*')
+    @time = Time.new(2016, 05, 01)
+    data << ([(@time - HexaPDF::Font::TrueType::Table::TIME_EPOCH).to_i] * 2).pack('q>*')
+    data << [-132, -152, 3423, 4231, 3, 9, -2, 0, 0].pack('s>4n2s>3')
+    set_up_stub_true_type_font(data)
+  end
+
+  describe "initialize" do
+    it "reads the data from the associated file" do
+      table = create_table(:Head)
+      assert_equal('1.0', sprintf('%1.1f', table.version))
+      assert_equal('2.1', sprintf('%1.1f', table.font_revision))
+      assert_equal(42, table.checksum_adjustment)
+      assert_equal(3, table.flags)
+      assert_equal(64, table.units_per_em)
+      assert_equal(@time, table.created)
+      assert_equal(@time, table.modified)
+      assert_equal([-132, -152, 3423, 4231], table.bbox)
+      assert_equal(3, table.mac_style)
+      assert_equal(9, table.smallest_readable_size)
+      assert_equal(-2, table.font_direction_hint)
+      assert_equal(0, table.index_to_loc_format)
+    end
+
+    it "raises an error if the magic number is false when reading from a file" do
+      @font.io.string[12, 1] = '\x5e'
+      assert_raises(HexaPDF::Error) { create_table(:Head) }
+    end
+
+    it "raises an error if an invalid glyph format is specified when reading from a file" do
+      @font.io.string[-1] = '\x5e'
+      assert_raises(HexaPDF::Error) { create_table(:Head) }
+    end
+  end
+
+  describe "checksum_valid?" do
+    it "checks whether an entry's checksum is valid" do
+      data = 254.chr * 12 + # fields before checksum field
+        [0x5F0F3CF5].pack('N') + # checksum field
+        254.chr * 4 +
+        0.chr * 4 + 254.chr * 4 + 0.chr * 4 + 254.chr * 4 + # date fields
+        254.chr * 16 + 0.chr * 4
+      @entry.checksum = (0xfefefefe * 9 + 0x5F0F3CF5) % 2**32
+      table = create_table(:Head, data)
+      assert(table.checksum_valid?)
+    end
+  end
+end

data/test/hexapdf/font/true_type/table/test_hhea.rb

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'common'
+require 'hexapdf/font/true_type/table/hhea'
+
+describe HexaPDF::Font::TrueType::Table::Hhea do
+  it "reads the data from the associated file" do
+    data = [1, 0, 10, 11, 12, 100, 101, 102, 115, 1, 0, 0, 0, 0, 0, 0, 0, 10].pack('n2s>3ns>11n')
+    set_up_stub_true_type_font(data)
+    table = create_table(:Hhea)
+
+    assert_equal(1, table.version)
+    assert_equal(10, table.ascent)
+    assert_equal(11, table.descent)
+    assert_equal(12, table.line_gap)
+    assert_equal(100, table.advance_width_max)
+    assert_equal(101, table.min_left_side_bearing)
+    assert_equal(102, table.min_right_side_bearing)
+    assert_equal(115, table.x_max_extent)
+    assert_equal(1, table.caret_slope_rise)
+    assert_equal(0, table.caret_slope_run)
+    assert_equal(0, table.caret_offset)
+    assert_equal(10, table.num_of_long_hor_metrics)
+  end
+end

data/test/hexapdf/font/true_type/table/test_hmtx.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'common'
+require 'hexapdf/font/true_type/table/hhea'
+require 'hexapdf/font/true_type/table/hmtx'
+
+describe HexaPDF::Font::TrueType::Table::Hmtx do
+  before do
+    data = [1, -2, 3, -4, 5, -6].pack('ns>ns>s>2')
+    set_up_stub_true_type_font(data)
+    hhea = Object.new
+    hhea.define_singleton_method(:num_of_long_hor_metrics) { 2 }
+    @font.define_singleton_method(:[]) {|_arg| hhea }
+  end
+
+  describe "initialize" do
+    it "reads the data from the associated file" do
+      table = create_table(:Hmtx)
+      assert_equal(3, table[2].advance_width)
+      assert_equal(5, table[2].left_side_bearing)
+      assert_equal(3, table[3].advance_width)
+      assert_equal(-6, table[3].left_side_bearing)
+      assert_equal(1, table[0].advance_width)
+      assert_equal(-2, table[0].left_side_bearing)
+      assert_equal(3, table[1].advance_width)
+      assert_equal(-4, table[1].left_side_bearing)
+    end
+  end
+end

data/test/hexapdf/font/true_type/table/test_kern.rb

@@ -0,0 +1,61 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'common'
+require 'hexapdf/font/true_type/table/kern'
+
+describe HexaPDF::Font::TrueType::Table::Kern do
+  describe "table format 0" do
+    before do
+      data = [0, 2].pack('n2')
+      data << [0, 6, 0x101].pack('n3')
+      data << [0, 6 + 8 + 24, 0x1].pack('n3')
+      data << [4, 0, 0, 0, 1, 2, 10, 2, 3, -30, 3, 4, 32767, 4, 5, -32768].pack('n4n2s>n2s>n2s>n2s>')
+      set_up_stub_true_type_font(data)
+    end
+
+    it "reads the data from the associated file" do
+      table = create_table(:Kern)
+      assert_equal(0, table.version)
+      assert_equal(1, table.subtables.length)
+
+      subtable = table.horizontal_kerning_subtable
+      assert(subtable.horizontal?)
+      refute(subtable.minimum_values?)
+      refute(subtable.cross_stream?)
+      assert_equal(10, subtable.kern(1, 2))
+      assert_equal(-30, subtable.kern(2, 3))
+      assert_equal(32767, subtable.kern(3, 4))
+      assert_equal(-32768, subtable.kern(4, 5))
+      assert_nil(subtable.kern(1, 3))
+      assert_nil(subtable.kern(6, 3))
+    end
+
+    it "raises an error for unknown formats if configured" do
+      @font.config['font.true_type.unknown_format'] = :raise
+      assert_raises(HexaPDF::Error) { create_table(:Kern) }
+    end
+  end
+
+  describe "table format 1" do
+    before do
+      data = [1, 0, 2].pack('n2N')
+      data << [8 + 8, 0xC001, 0, 0, 0, 0, 0].pack('Nn6')
+      data << [8 + 8 + 6, 0xC000, 0].pack('Nnn')
+      data << [1, 0, 0, 0, 1, 2, 10].pack('n4n2s>')
+      set_up_stub_true_type_font(data)
+    end
+
+    it "reads the data from the associated file" do
+      table = create_table(:Kern)
+      assert_equal(1, table.version)
+      assert_equal(1, table.subtables.length)
+
+      subtable = table.subtables.first
+      refute(subtable.horizontal?)
+      refute(subtable.minimum_values?)
+      assert(subtable.cross_stream?)
+      assert_equal(10, subtable.kern(1, 2))
+    end
+  end
+end

data/test/hexapdf/font/true_type/table/test_loca.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'common'
+require 'hexapdf/font/true_type/table/head'
+require 'hexapdf/font/true_type/table/loca'
+
+describe HexaPDF::Font::TrueType::Table::Loca do
+  before do
+    set_up_stub_true_type_font
+    head = Object.new
+    head.define_singleton_method(:index_to_loc_format) { 0 }
+    @font.define_singleton_method(:[]) {|_arg| head }
+  end
+
+  describe "initialize" do
+    it "reads the data in short format from the associated file" do
+      table = create_table(:Loca, [0, 10, 30, 50, 90].pack('n*'))
+      assert_equal([0, 20, 60, 100, 180], table.offsets)
+      assert_equal(0, table.offset(0))
+      assert_equal(100, table.offset(3))
+      assert_equal(20, table.length(0))
+      assert_equal(80, table.length(3))
+    end
+
+    it "reads the data in long format from the associated file" do
+      @font[:head].singleton_class.send(:remove_method, :index_to_loc_format)
+      @font[:head].define_singleton_method(:index_to_loc_format) { 1 }
+      table = create_table(:Loca, [0, 10, 30, 50, 90].pack('N*'))
+      assert_equal([0, 10, 30, 50, 90], table.offsets)
+    end
+  end
+end

data/test/hexapdf/font/true_type/table/test_maxp.rb

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'common'
+require 'hexapdf/font/true_type/table/maxp'
+
+describe HexaPDF::Font::TrueType::Table::Maxp do
+  before do
+    data = [1, 0, 10, 11, 12, 13, 14, 2, 15, 16, 17, 18, 19, 20, 21, 22].pack('n*')
+    set_up_stub_true_type_font(data)
+  end
+
+  describe "initialize" do
+    it "reads the version 1.0 data from the associated file" do
+      table = create_table(:Maxp)
+      assert_equal(1, table.version)
+      assert_equal(10, table.num_glyphs)
+      assert_equal(11, table.max_points)
+      assert_equal(12, table.max_contours)
+      assert_equal(13, table.max_component_points)
+      assert_equal(14, table.max_component_contours)
+      assert_equal(15, table.max_twilight_points)
+      assert_equal(16, table.max_storage)
+      assert_equal(17, table.max_function_defs)
+      assert_equal(18, table.max_instruction_defs)
+      assert_equal(19, table.max_stack_elements)
+      assert_equal(20, table.max_size_of_instructions)
+      assert_equal(21, table.max_component_elements)
+      assert_equal(22, table.max_component_depth)
+    end
+
+    it "reads the version 0.5 data from the associated file" do
+      table = create_table(:Maxp, [0, 0x5000, 10].pack('n*'))
+      assert_equal(0.3125, table.version)
+      assert_equal(10, table.num_glyphs)
+      assert_nil(table.max_points)
+      assert_nil(table.max_contours)
+      assert_nil(table.max_component_points)
+      assert_nil(table.max_component_contours)
+      assert_nil(table.max_twilight_points)
+      assert_nil(table.max_storage)
+      assert_nil(table.max_function_defs)
+      assert_nil(table.max_instruction_defs)
+      assert_nil(table.max_stack_elements)
+      assert_nil(table.max_size_of_instructions)
+      assert_nil(table.max_component_elements)
+      assert_nil(table.max_component_depth)
+    end
+  end
+end

data/test/hexapdf/font/true_type/table/test_name.rb

@@ -0,0 +1,76 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'common'
+require 'hexapdf/font/true_type/table/name'
+
+describe HexaPDF::Font::TrueType::Table::Name do
+  before do
+    data = [0, 3, 42].pack('n3') << \
+      [1, 0, 0, 0, 4, 0].pack('n6') << \
+      [0, 3, 1, 0, 8, 4].pack('n6') << \
+      [3, 1, 1033, 1, 14, 12].pack('n6') << \
+      'hexa'.encode('MACROMAN').b << \
+      'hexa'.encode('UTF-16BE').b <<
+      'hexapdf'.encode('UTF-16BE').b
+    set_up_stub_true_type_font(data)
+  end
+
+  describe "initialize" do
+    it "reads the data in format 0 from the associated file" do
+      table = create_table(:Name)
+      assert_equal(0, table.format)
+      assert_equal({}, table.language_tags)
+      assert_equal('hexa', table[:copyright][0])
+      assert_equal(1, table[:copyright][0].platform_id)
+      assert_equal(0, table[:copyright][0].encoding_id)
+      assert_equal(0, table[:copyright][0].language_id)
+      assert_equal('hexa', table[:copyright][1])
+      assert_equal(0, table[:copyright][1].platform_id)
+      assert_equal(3, table[:copyright][1].encoding_id)
+      assert_equal(1, table[:copyright][1].language_id)
+      assert_equal('hexapdf', table[:font_family][0])
+      assert_equal(3, table[:font_family][0].platform_id)
+      assert_equal(1, table[:font_family][0].encoding_id)
+      assert_equal(1033, table[:font_family][0].language_id)
+
+      assert_equal(table[0][0], table[0].preferred_record)
+      assert_equal(table[:font_family][0], table[:font_family].preferred_record)
+    end
+
+    it "reads the data in format 1 from the associated file" do
+      @font.io.string[0, 6] = [1, 3, 52].pack('n3')
+      @font.io.string[42, 0] = [2, 4, 26, 4, 30].pack('n*')
+      @font.io.string << 'ende'.encode('UTF-16BE').b
+      table = create_table(:Name)
+      assert_equal(1, table.format)
+      assert_equal({0x8000 => 'en', 0x8001 => 'de'}, table.language_tags)
+    end
+  end
+
+  describe "NameRecord" do
+    before do
+      @table = create_table(:Name)
+    end
+
+    describe "platform?" do
+      it "returns the correct value" do
+        assert(@table[:copyright][0].platform?(:macintosh))
+        assert(@table[:copyright][1].platform?(:unicode))
+        assert(@table[:font_family][0].platform?(:microsoft))
+      end
+
+      it "raises an error when called with an unknown identifier" do
+        assert_raises(ArgumentError) { @table[:copyright][0].platform?(:testing) }
+      end
+    end
+
+    describe "preferred?" do
+      it "returns true for names in US English that had been converted to UTF-8" do
+        assert(@table[:copyright][0].preferred?)
+        refute(@table[:copyright][1].preferred?)
+        assert(@table[:font_family][0].preferred?)
+      end
+    end
+  end
+end

data/test/hexapdf/font/true_type/table/test_os2.rb

@@ -0,0 +1,55 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'common'
+require 'hexapdf/font/true_type/table/os2'
+
+describe HexaPDF::Font::TrueType::Table::OS2 do
+  before do
+    data = [5, -1, 2, 3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15,
+            'PANOSPANOS', 16, 17, 'VEND', 16, 17, 18, -19, -20, -21, 22, 23, 24, -25, -26,
+            27, 28, 29, 30, 31].pack('ns>n2s>12a10Q>2a4n3s>3n2Q>s>2n5')
+    set_up_stub_true_type_font(data)
+  end
+
+  describe "initialize" do
+    it "reads the data from the associated file" do
+      table = create_table(:OS2)
+      assert_equal(5, table.version)
+      assert_equal(-1, table.x_avg_char_width)
+      assert_equal(200, table.weight_class)
+      assert_equal(3, table.width_class)
+      assert_equal(-4, table.type)
+      assert_equal(-5, table.subscript_x_size)
+      assert_equal(-6, table.subscript_y_size)
+      assert_equal(-7, table.subscript_x_offset)
+      assert_equal(-8, table.subscript_y_offset)
+      assert_equal(-9, table.superscript_x_size)
+      assert_equal(-10, table.superscript_y_size)
+      assert_equal(-11, table.superscript_x_offset)
+      assert_equal(-12, table.superscript_y_offset)
+      assert_equal(-13, table.strikeout_size)
+      assert_equal(-14, table.strikeout_position)
+      assert_equal(-15, table.family_class)
+      assert_equal('PANOSPANOS'.b, table.panose)
+      assert_equal(16 << 64 & 17, table.unicode_range)
+      assert_equal('VEND'.b, table.vendor_id)
+      assert_equal(16, table.selection)
+      assert_equal(17, table.first_char_index)
+      assert_equal(18, table.last_char_index)
+      assert_equal(-19, table.typo_ascender)
+      assert_equal(-20, table.typo_descender)
+      assert_equal(-21, table.typo_line_gap)
+      assert_equal(22, table.win_ascent)
+      assert_equal(23, table.win_descent)
+      assert_equal(24, table.code_page_range)
+      assert_equal(-25, table.x_height)
+      assert_equal(-26, table.cap_height)
+      assert_equal(27, table.default_char)
+      assert_equal(28, table.break_char)
+      assert_equal(29, table.max_context)
+      assert_equal(30, table.lower_point_size)
+      assert_equal(31, table.upper_point_size)
+    end
+  end
+end

data/test/hexapdf/font/true_type/table/test_post.rb

@@ -0,0 +1,78 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative 'common'
+require 'hexapdf/font/true_type/table/post'
+
+describe HexaPDF::Font::TrueType::Table::Post do
+  before do
+    data = [1, 0, 1, 0, -142, 15, 0, 0, 0, 0, 0].pack('n4s>2N5')
+    set_up_stub_true_type_font(data)
+  end
+
+  describe "initialize" do
+    it "reads the format 1 data from the associated file" do
+      table = create_table(:Post)
+      assert_equal(1, table.format)
+      assert_equal(1, table.italic_angle)
+      assert_equal(-142, table.underline_position)
+      assert_equal(15, table.underline_thickness)
+      assert_equal(0, table.is_fixed_pitch)
+      refute(table.is_fixed_pitch?)
+      assert_equal(0, table.min_mem_type42)
+      assert_equal(0, table.max_mem_type42)
+      assert_equal(0, table.min_mem_type1)
+      assert_equal(0, table.max_mem_type1)
+      assert_equal('.notdef', table[0])
+      assert_equal('A', table[36])
+      assert_equal('Delta', table[168])
+      assert_equal('.notdef', table[1000])
+    end
+
+    it "reads the format 2 data from the associated file" do
+      @font.io.string[0, 2] = [2].pack('n')
+      @font.io.string << ([260, 0] + (1..257).to_a.reverse + [258, 259]).pack('n*')
+      @font.io.string << [4, "hexa", 3, "pdf"].pack('CA4CA3')
+      table = create_table(:Post, @font.io.string)
+      assert_equal(2, table.format)
+      assert_equal('.notdef', table[0])
+      assert_equal('A', table[258 - 36])
+      assert_equal('Delta', table[258 - 168])
+      assert_equal('hexa', table[258])
+      assert_equal('pdf', table[259])
+      assert_equal('.notdef', table[1000])
+    end
+
+    it "reads the format 3 data from the associated file" do
+      @font.io.string[0, 2] = [3].pack('n')
+      table = create_table(:Post, @font.io.string)
+      assert_equal(3, table.format)
+      assert_equal('.notdef', table[0])
+      assert_equal('.notdef', table[36])
+      assert_equal('.notdef', table[1000])
+    end
+
+    it "reads the format 4 data from the associated file" do
+      @font.io.string[0, 2] = [4].pack('n')
+      @font.io.string << [0x1234, 0x5678].pack('n*')
+      table = create_table(:Post, @font.io.string)
+      assert_equal(4, table.format)
+      assert_equal(0x1234, table[0])
+      assert_equal(0x5678, table[1])
+      assert_equal(0xFFFF, table[2])
+      assert_equal(0xFFFF, table[36])
+      assert_equal(0xFFFF, table[1_000_000])
+    end
+
+    it "handles unsupported formats" do
+      @font.io.string[0, 2] = [5].pack('n')
+
+      @font.config['font.true_type.unknown_format'] = :ignore
+      table = create_table(:Post, @font.io.string)
+      assert_equal('.notdef', table[0])
+
+      @font.config['font.true_type.unknown_format'] = :raise
+      assert_raises(HexaPDF::Error) { create_table(:Post)[0] }
+    end
+  end
+end

data/test/hexapdf/font/true_type/test_builder.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+require 'stringio'
+require 'test_helper'
+require 'hexapdf/font/true_type'
+require 'hexapdf/font/true_type/builder'
+
+describe HexaPDF::Font::TrueType::Builder do
+  before do
+    font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
+    @font = HexaPDF::Font::TrueType::Font.new(File.open(font_file))
+  end
+
+  after do
+    @font.io.close
+  end
+
+  it "builds the font file" do
+    tables = {
+      "loca" => @font[:loca].raw_data << "0",
+      "head" => @font[:head].raw_data,
+      "glyf" => @font[:glyf].raw_data,
+      "maxp" => @font[:maxp].raw_data,
+    }
+    font_data = HexaPDF::Font::TrueType::Builder.build(tables)
+    built_font = HexaPDF::Font::TrueType::Font.new(StringIO.new(font_data))
+
+    assert(built_font[:head].checksum_valid?)
+    assert_equal(@font[:glyf].raw_data, built_font[:glyf].raw_data)
+    assert(built_font.directory.entry('glyf').offset % 4 == 0)
+    assert(built_font[:glyf].checksum_valid?)
+    assert_equal(@font[:loca].raw_data << "0", built_font[:loca].raw_data)
+    assert(built_font[:loca].checksum_valid?)
+    assert(built_font.directory.entry('loca').offset % 4 == 0)
+    assert_equal(@font[:maxp].raw_data, built_font[:maxp].raw_data)
+    assert(built_font[:maxp].checksum_valid?)
+    assert(built_font.directory.entry('maxp').offset % 4 == 0)
+
+    tables = built_font.directory.instance_variable_get(:@tables)
+    assert_equal(tables.keys.sort, tables.keys)
+  end
+end

data/test/hexapdf/font/true_type/test_font.rb

@@ -0,0 +1,116 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'hexapdf/font/true_type/font'
+require_relative 'common'
+
+describe HexaPDF::Font::TrueType::Font do
+  before do
+    @io = StringIO.new("TEST\x00\x01\x00\x00\x00\x00\x00\x00" \
+                       "TEST----\x00\x00\x00\x1C\x00\x00\x00\x05ENTRY".b)
+    @font = HexaPDF::Font::TrueType::Font.new(@io)
+    @font.config['font.true_type.table_mapping'][:TEST] = TestHelper::TrueTypeTestTable.name
+  end
+
+  describe "[]" do
+    it "returns a named table" do
+      table = @font[:TEST]
+      assert_equal('ENTRY', table.data)
+    end
+
+    it "always returns the same table instance" do
+      assert_same(@font[:TEST], @font[:TEST])
+    end
+
+    it "returns a generic table if no mapping exists" do
+      @font.config['font.true_type.table_mapping'].delete(:TEST)
+      assert_kind_of(HexaPDF::Font::TrueType::Table, @font[:TEST])
+    end
+
+    it "returns nil if the named table doesn't exist in the file" do
+      assert_nil(@font[:OTHE])
+    end
+  end
+
+  describe "getter methods" do
+    before do
+      font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
+      @font = HexaPDF::Font::TrueType::Font.new(File.open(font_file))
+    end
+
+    it "returns the postscript name" do
+      assert_equal("Ubuntu-Title", @font.font_name)
+    end
+
+    it "returns the full name" do
+      assert_equal("Ubuntu-Title", @font.full_name)
+    end
+
+    it "returns the family name" do
+      assert_equal("Ubuntu-Title", @font.family_name)
+    end
+
+    it "returns the font's weight" do
+      assert_equal(400, @font.weight)
+    end
+
+    it "returns the font's bounding box" do
+      assert_equal([-35, -187, 876, 801], @font.bounding_box)
+    end
+
+    it "returns the font's cap height" do
+      @font[:'OS/2'].cap_height = 832
+      assert_equal(832, @font.cap_height)
+    end
+
+    it "returns the font's x height" do
+      @font[:'OS/2'].x_height = 642
+      assert_equal(642, @font.x_height)
+    end
+
+    it "returns the font's ascender" do
+      assert_equal(800, @font.ascender)
+      @font[:'OS/2'].typo_ascender = nil
+      assert_equal(801, @font.ascender)
+    end
+
+    it "returns the font's descender" do
+      assert_equal(-200, @font.descender)
+      @font[:'OS/2'].typo_descender = nil
+      assert_equal(-187, @font.descender)
+    end
+
+    it "returns the font's italic angle" do
+      assert_equal(0.0, @font.italic_angle)
+    end
+
+    it "returns the font's dominant vertical stem width" do
+      assert_equal(80, @font.dominant_vertical_stem_width)
+    end
+
+    it "returns the underline position" do
+      assert_equal(-125, @font.underline_position)
+    end
+
+    it "returns the underline thickness" do
+      assert_equal(50, @font.underline_thickness)
+    end
+
+    it "returns the strikeout position" do
+      assert_equal(256, @font.strikeout_position)
+    end
+
+    it "returns the strikeout thickness" do
+      assert_equal(48, @font.strikeout_thickness)
+    end
+  end
+
+  it "is able to return the ID of the missing glyph" do
+    assert_equal(0, @font.missing_glyph_id)
+  end
+
+  it "returns the features available for a font" do
+    assert(@font.features.empty?)
+  end
+end

data/test/hexapdf/font/true_type/test_optimizer.rb

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+
+require 'stringio'
+require 'test_helper'
+require 'hexapdf/font/true_type'
+
+describe HexaPDF::Font::TrueType::Optimizer do
+  before do
+    font_file = File.join(TEST_DATA_DIR, "fonts", "Ubuntu-Title.ttf")
+    @font = HexaPDF::Font::TrueType::Font.new(File.open(font_file))
+  end
+
+  after do
+    @font.io.close
+  end
+
+  describe "build_for_pdf" do
+    it "builds a font file that is optimized for use with PDFs" do
+      font_data = HexaPDF::Font::TrueType::Optimizer.build_for_pdf(@font)
+      built_font = HexaPDF::Font::TrueType::Font.new(StringIO.new(font_data))
+      [:FFTM, :GDEF, :GPOS, :GSUB, :name, :post].each do |table|
+        refute(built_font[table])
+      end
+    end
+  end
+end