hexapdf 0.1.0

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

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'hexapdf/font/true_type/table/head'
+require 'hexapdf/font/true_type/table/loca'
+
+describe HexaPDF::Font::TrueType::Table::Loca do
+  before do
+    @file = Object.new
+    @file.define_singleton_method(:io) { @io ||= StringIO.new('') }
+    head = HexaPDF::Font::TrueType::Table::Head.new(@file)
+    head.index_to_loc_format = 0
+    @file.define_singleton_method(:[]) {|_arg| head }
+    @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('loca', 0, 0, @file.io.length)
+  end
+
+  describe "initialize" do
+    it "reads the data in short format from the associated file" do
+      @file.io.string = [0, 10, 30, 50, 90].pack('n*')
+      @entry.length = @file.io.length
+      table = HexaPDF::Font::TrueType::Table::Loca.new(@file, @entry)
+      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
+      @file.io.string = [0, 10, 30, 50, 90].pack('N*')
+      @file[:head].index_to_loc_format = 1
+      @entry.length = @file.io.length
+      table = HexaPDF::Font::TrueType::Table::Loca.new(@file, @entry)
+      assert_equal([0, 10, 30, 50, 90], table.offsets)
+    end
+
+    it "loads some default values if no entry is given" do
+      table = HexaPDF::Font::TrueType::Table::Loca.new(@file)
+      assert_equal([], table.offsets)
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+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*')
+    io = StringIO.new(data)
+    @file = Object.new
+    @file.define_singleton_method(:io) { io }
+    @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('hhea', 0, 0, io.length)
+  end
+
+  describe "initialize" do
+    it "reads the version 1.0 data from the associated file" do
+      table = HexaPDF::Font::TrueType::Table::Maxp.new(@file, @entry)
+      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
+      @file.io.string = [0, 0x5000, 10].pack('n*')
+      @entry.length = @file.io.length
+      table = HexaPDF::Font::TrueType::Table::Maxp.new(@file, @entry)
+      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
+
+    it "loads some default values if no entry is given" do
+      table = HexaPDF::Font::TrueType::Table::Maxp.new(@file)
+      assert_equal(1, table.version)
+      assert_equal(0, table.num_glyphs)
+      assert_equal(0, table.max_points)
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'hexapdf/font/true_type/table/name'
+
+describe HexaPDF::Font::TrueType::Table::Name do
+  before do
+    @file = Object.new
+    @file.define_singleton_method(:io) { @io ||= StringIO.new(''.b) }
+
+    @file.io.string = [0, 3, 42].pack('n3')
+    @file.io.string << [1, 0, 0, 0, 4, 0].pack('n6')
+    @file.io.string << [0, 3, 1, 0, 8, 4].pack('n6')
+    @file.io.string << [0, 3, 2, 1, 14, 12].pack('n6')
+    @file.io.string << 'hexa'.encode('MACROMAN').b << 'hexa'.encode('UTF-16BE').b <<
+      'hexapdf'.encode('UTF-16BE').b
+
+    @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('name', 0, 0, @file.io.length)
+  end
+
+  describe "initialize" do
+    it "reads the data in format 0 from the associated file" do
+      table = HexaPDF::Font::TrueType::Table::Name.new(@file, @entry)
+      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(0, table[:font_family][0].platform_id)
+      assert_equal(3, table[:font_family][0].encoding_id)
+      assert_equal(2, table[:font_family][0].language_id)
+      assert_equal(table[:copyright][0], table[:copyright].preferred_record)
+    end
+
+    it "reads the data in format 1 from the associated file" do
+      @file.io.string[0, 6] = [1, 3, 52].pack('n3')
+      @file.io.string[42, 0] = [2, 4, 26, 4, 30].pack('n*')
+      @file.io.string << 'ende'.encode('UTF-16BE').b
+      table = HexaPDF::Font::TrueType::Table::Name.new(@file, @entry)
+      assert_equal(1, table.format)
+      assert_equal({0x8000 => 'en', 0x8001 => 'de'}, table.language_tags)
+    end
+
+    it "loads some default values if no entry is given" do
+      table = HexaPDF::Font::TrueType::Table::Name.new(@file)
+      assert_equal(0, table.format)
+      assert_equal({}, table.records)
+      assert_equal({}, table.language_tags)
+    end
+  end
+
+  describe "add" do
+    it "adds a new record for a name" do
+      table = HexaPDF::Font::TrueType::Table::Name.new(@file)
+      table.add(:postscript_name, "test")
+      record = table[:postscript_name][0]
+      assert_equal("test", record)
+      assert_equal(HexaPDF::Font::TrueType::Table::Name::Record::PLATFORM_MACINTOSH, record.platform_id)
+      assert_equal(0, record.encoding_id)
+      assert_equal(0, record.language_id)
+    end
+  end
+
+  describe "NameRecord" do
+    before do
+      @table = HexaPDF::Font::TrueType::Table::Name.new(@file, @entry)
+    end
+
+    describe "platform?" do
+      it "returns the correct value" do
+        assert(@table[:copyright][0].platform?(:macintosh))
+        assert(@table[:copyright][1].platform?(:unicode))
+        refute(@table[:copyright][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?)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+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')
+    @file = Object.new
+    @file.define_singleton_method(:io) { @io ||= StringIO.new(data) }
+    @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('OS/2', 0, 0, @file.io.length)
+  end
+
+  describe "initialize" do
+    it "reads the data from the associated file" do
+      table = HexaPDF::Font::TrueType::Table::OS2.new(@file, @entry)
+      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
+
+    it "loads some default values if no entry is given" do
+      table = HexaPDF::Font::TrueType::Table::OS2.new(@file)
+      assert_equal(5, table.version)
+      assert_equal(''.b, table.panose)
+      assert_equal('    '.b, table.vendor_id)
+      assert_equal(0, table.default_char)
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+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')
+    @file = Object.new
+    @file.define_singleton_method(:io) { @io ||= StringIO.new(data) }
+    @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('post', 0, 0, @file.io.length)
+  end
+
+  describe "initialize" do
+    it "reads the format 1 data from the associated file" do
+      table = HexaPDF::Font::TrueType::Table::Post.new(@file, @entry)
+      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
+      @file.io.string[0, 2] = [2].pack('n')
+      @file.io.string << ([260, 0] + (1..257).to_a.reverse + [258, 259]).pack('n*')
+      @file.io.string << [4, "hexa", 3, "pdf"].pack('CA4CA3')
+      @entry.length = @file.io.length
+      table = HexaPDF::Font::TrueType::Table::Post.new(@file, @entry)
+      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
+      @file.io.string[0, 2] = [3].pack('n')
+      table = HexaPDF::Font::TrueType::Table::Post.new(@file, @entry)
+      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
+      @file.io.string[0, 2] = [4].pack('n')
+      @file.io.string << [0x1234, 0x5678].pack('n*')
+      @entry.length = @file.io.length
+      table = HexaPDF::Font::TrueType::Table::Post.new(@file, @entry)
+      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 "loads some default values if no entry is given" do
+      table = HexaPDF::Font::TrueType::Table::Post.new(@file)
+      assert_equal(1, table.format)
+      assert_equal(0, table.italic_angle)
+      assert_equal(0, table.underline_position)
+      assert_equal(0, table.underline_thickness)
+      assert_equal(0, 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)
+    end
+
+    it "raises an error if an unsupported format is given" do
+      @file.io.string[0, 2] = [5].pack('n')
+      assert_raises(HexaPDF::Error) { HexaPDF::Font::TrueType::Table::Post.new(@file, @entry) }
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# -*- 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: @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 "add_table" do
+    it "returns the existing table if one exists" do
+      assert_same(@font[:TEST], @font.add_table(:TEST))
+    end
+
+    it "creates a new table instance if needed" do
+      assert_kind_of(HexaPDF::Font::TrueType::Table::Head, @font.add_table(:head))
+    end
+  end
+
+  describe "getter methods" do
+    before do
+      @font.add_table(:name)
+      @font.add_table(:post)
+      @font.add_table(:head)
+      @font.add_table(:hhea)
+      @font.add_table(:"OS/2")
+    end
+
+    it "returns the postscript name" do
+      @font[:name].add(:postscript_name, "name")
+      assert_equal("name", @font.font_name)
+    end
+
+    it "returns the full name" do
+      @font[:name].add(:font_name, "name")
+      assert_equal("name", @font.full_name)
+    end
+
+    it "returns the family name" do
+      @font[:name].add(:font_family, "name")
+      assert_equal("name", @font.family_name)
+    end
+
+    it "returns the font's weight" do
+      @font[:"OS/2"].weight_class = 400
+      assert_equal(400, @font.weight)
+    end
+
+    it "returns the font's bounding box" do
+      @font[:head].bbox = [0, 1, 2, 3]
+      assert_equal([0, 1, 2, 3], @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
+      @font[:"OS/2"].typo_ascender = 800
+      @font[:hhea].ascent = 790
+      assert_equal(800, @font.ascender)
+      @font.instance_eval { @tables.delete(:"OS/2") }
+      assert_equal(790, @font.ascender)
+    end
+
+    it "returns the font's descender" do
+      @font[:"OS/2"].typo_descender = -200
+      @font[:hhea].descent = -180
+      assert_equal(-200, @font.descender)
+      @font.instance_eval { @tables.delete(:"OS/2") }
+      assert_equal(-180, @font.descender)
+    end
+
+    it "returns the font's italic angle" do
+      @font[:post].italic_angle = Rational(325, 10)
+      assert_equal(32.5, @font.italic_angle)
+    end
+
+    it "returns the font's dominant vertical stem width" do
+      @font[:"OS/2"].weight_class = 400
+      assert_equal(80, @font.dominant_vertical_stem_width)
+    end
+  end
+
+  it "is able to return the ID of the missing glyph" do
+    assert_equal(0, @font.missing_glyph_id)
+  end
+end

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

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'hexapdf/font/true_type/table'
+require_relative 'common'
+
+describe HexaPDF::Font::TrueType::Table do
+  before do
+    io = StringIO.new('some string')
+    @file = Object.new
+    @file.define_singleton_method(:io) { io }
+    @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('tagg', 0, 0, @file.io.string.length)
+  end
+
+  describe "initialize" do
+    it "reads the data from the associated file" do
+      table = TestHelper::TrueTypeTestTable.new(@file, @entry)
+      assert_equal(@file.io.string, table.data)
+    end
+
+    it "loads some default values if no entry is given" do
+      table = TestHelper::TrueTypeTestTable.new(@file)
+      assert_equal('default', table.data)
+    end
+  end
+
+  describe "checksum_valid?" do
+    it "checks whether an entry's checksum is valid" do
+      @file.io.string = 254.chr * 17 + 0.chr * 3
+      @entry.checksum = (0xfefefefe * 4 + 0xfe000000) % 2**32
+      @entry.length = @file.io.string.length
+      table = TestHelper::TrueTypeTestTable.new(@file, @entry)
+      assert(table.checksum_valid?)
+    end
+
+    it "raises an error if the checksum can't be verified because none is available" do
+      assert_raises(HexaPDF::Error) { TestHelper::TrueTypeTestTable.new(@file).checksum_valid? }
+    end
+  end
+end

data/test/hexapdf/font/type1/test_afm_parser.rb

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/type1'
+require 'hexapdf/data_dir'
+require 'tempfile'
+require 'stringio'
+
+describe HexaPDF::Font::Type1::AFMParser do
+  describe "::parse" do
+    before do
+      @file = Tempfile.new('hexapdf-afm')
+      @file.write("StartFontMetrics 4.1\nFontName Test\nEndFontMetrics\n")
+      @file.close
+    end
+
+    after do
+      @file.unlink
+    end
+
+    it "can work with file names" do
+      assert_equal('Test', HexaPDF::Font::Type1::AFMParser.parse(@file.path).font_name)
+    end
+
+    it "can work with IO streams" do
+      @file.open
+      assert_equal('Test', HexaPDF::Font::Type1::AFMParser.parse(@file).font_name)
+    end
+  end
+
+  it "can parse the 14 core PDF font files" do
+    Dir[File.join(HexaPDF.data_dir, 'afm', '*.afm')].each do |file|
+      metrics = HexaPDF::Font::Type1::AFMParser.parse(file)
+      basename = File.basename(file, '.*')
+      assert_equal(basename, metrics.font_name, basename)
+      assert_equal(basename.sub(/-.*/, ''), metrics.family_name, basename)
+      assert(metrics.character_metrics.size > 0, basename)
+    end
+  end
+
+  it "calculates an ascender and descender value from the font bounding box if necessary" do
+    metrics = HexaPDF::Font::Type1::AFMParser.parse(File.join(HexaPDF.data_dir, 'afm/Symbol.afm'))
+    assert_equal(metrics.bounding_box[1], metrics.descender)
+    assert_equal(metrics.bounding_box[3], metrics.ascender)
+  end
+
+  it "fails if the file doesn't start with the correct line" do
+    file = StringIO.new("some\nthing")
+    assert_raises(HexaPDF::Error) { HexaPDF::Font::Type1::AFMParser.parse(file) }
+  end
+end

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

@@ -0,0 +1,68 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/type1'
+
+describe HexaPDF::Font::Type1::Font do
+  before do
+    metrics = HexaPDF::Font::Type1::FontMetrics.new
+    @font = HexaPDF::Font::Type1::Font.new(metrics)
+  end
+
+  describe "::from_afm" do
+    it "can load the Font object from an AFM file" do
+      font = HexaPDF::Font::Type1::Font.from_afm(File.join(HexaPDF.data_dir, 'afm/Symbol.afm'))
+      assert_equal('Symbol', font.family_name)
+    end
+  end
+
+  describe "encoding" do
+    it "uses the StandardEncoding if possible" do
+      @font.metrics.encoding_scheme = 'AdobeStandardEncoding'
+      assert_equal(HexaPDF::Font::Encoding.for_name(:StandardEncoding), @font.encoding)
+    end
+
+    it "handles the special case of the ZapfDingbats font" do
+      @font.metrics.font_name = "ZapfDingbats"
+      assert_equal(HexaPDF::Font::Encoding.for_name(:ZapfDingbatsEncoding), @font.encoding)
+    end
+
+    it "handles the special case of the Symbol font" do
+      @font.metrics.font_name = "Symbol"
+      assert_equal(HexaPDF::Font::Encoding.for_name(:SymbolEncoding), @font.encoding)
+    end
+
+    it "generates an encoding object if necessary" do
+      char_metrics = HexaPDF::Font::Type1::CharacterMetrics.new
+      char_metrics.code = 5
+      char_metrics.name = :A
+      @font.metrics.character_metrics[5] = char_metrics.dup
+      char_metrics.code = 6
+      char_metrics.name = :Z
+      @font.metrics.character_metrics[6] = char_metrics.dup
+
+      assert_equal({5 => :A, 6 => :Z}, @font.encoding.code_to_name)
+    end
+  end
+
+  describe "width" do
+    before do
+      @char_metrics = HexaPDF::Font::Type1::CharacterMetrics.new
+      @char_metrics.width = 100
+    end
+
+    it "returns the width for a code point in the built-in encoding" do
+      @font.metrics.character_metrics[5] = @char_metrics
+      assert_equal(100, @font.width(5))
+    end
+
+    it "returns the width for a named glyph" do
+      @font.metrics.character_metrics[:A] = @char_metrics
+      assert_equal(100, @font.width(:A))
+    end
+  end
+
+  it "is able to return the ID of the missing glyph" do
+    assert_equal(:'.notdef', @font.missing_glyph_id)
+  end
+end

data/test/hexapdf/font/type1/test_pfb_parser.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/font/type1'
+
+describe HexaPDF::Font::Type1::PFBParser do
+  describe "::encoding" do
+    it "can extract the encoding specified as StandardEncoding" do
+      data = "bla bla bla /Encoding StandardEncoding def bla bla"
+      assert_same(HexaPDF::Font::Encoding.for_name(:StandardEncoding),
+                  HexaPDF::Font::Type1::PFBParser.encoding(data))
+    end
+
+    it "can extract the encoding specified as array" do
+      data = <<-EOF
+      bla bla bla
+      /Encoding 256 array
+      0 1 255 {1 index exch /.notdef put} for
+      dup 32 /space put
+      dup 33 /exclam put
+      dup 34 /universal put
+      dup 35 /numbersign put
+      dup 36 /existential put
+      readonly def
+      bla bla bla
+      EOF
+      enc = HexaPDF::Font::Type1::PFBParser.encoding(data)
+      assert_equal(:space, enc.name(32))
+      assert_equal(:existential, enc.name(36))
+    end
+
+    it "fails if the encoding can't be extracted" do
+      data = "something without an encoding"
+      assert_raises(HexaPDF::Error) { HexaPDF::Font::Type1::PFBParser.encoding(data) }
+    end
+  end
+end