hexapdf 0.15.8 → 0.17.1

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

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

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

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

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

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

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

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

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

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

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

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

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