summaryrefslogtreecommitdiff
path: root/Build/source/texk/web2c/luatexdir/luaharfbuzz/spec/harfbuzz_spec.lua
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/texk/web2c/luatexdir/luaharfbuzz/spec/harfbuzz_spec.lua')
-rw-r--r--Build/source/texk/web2c/luatexdir/luaharfbuzz/spec/harfbuzz_spec.lua501
1 files changed, 501 insertions, 0 deletions
diff --git a/Build/source/texk/web2c/luatexdir/luaharfbuzz/spec/harfbuzz_spec.lua b/Build/source/texk/web2c/luatexdir/luaharfbuzz/spec/harfbuzz_spec.lua
new file mode 100644
index 00000000000..966a1865faf
--- /dev/null
+++ b/Build/source/texk/web2c/luatexdir/luaharfbuzz/spec/harfbuzz_spec.lua
@@ -0,0 +1,501 @@
+local harfbuzz = require("harfbuzz")
+
+describe("harfbuzz module", function()
+
+ it("returns a valid version string", function()
+ assert.are_equal("string", type(harfbuzz.version()))
+ end)
+
+ it("returns a valid list of shapers", function()
+ local shapers = { harfbuzz.shapers }
+ assert.is_not.True(#shapers == 0)
+ end)
+
+ describe("harfbuzz.Blob", function()
+ it("can be initialized with a string", function()
+ local s = "test string"
+ local blob = harfbuzz.Blob.new(s)
+ assert.are_equal(string.len(s), blob:get_length())
+ end)
+ end)
+
+ describe("harfbuzz.Face", function()
+ local face = harfbuzz.Face.new('fonts/notonastaliq.ttf')
+ it("can be initialized with a blob", function()
+ local fontfile = io.open('fonts/notonastaliq.ttf', "r")
+ local fontdata = fontfile:read("*all")
+ fontfile:close()
+
+ local blob = harfbuzz.Blob.new(fontdata)
+ harfbuzz.Face.new_from_blob(blob,0)
+ end)
+
+ it("can be initialized with a file and a font index", function()
+ harfbuzz.Face.new('fonts/notonastaliq.ttf',0)
+ end)
+
+ it("can be initialized with a file only", function()
+ harfbuzz.Face.new('fonts/notonastaliq.ttf')
+ end)
+
+ it("returns a valid upem value", function()
+ assert.are_equal(2048,face:get_upem())
+ end)
+
+ it("can return SFNT table", function()
+ local b = face:get_table(harfbuzz.Tag.new("OS/2"))
+ local d = b:get_data()
+ assert.are_equal(96,b:get_length())
+ assert.are_equal(96,#d)
+ assert.are_equal(4,string.unpack(">H", d, 1))
+ assert.are_equal(1155,string.unpack(">h", d, 3))
+ assert.are_equal(5,string.unpack(">H", d, -2))
+ end)
+
+ it("can return table tags", function()
+ local t = face:get_table_tags()
+ assert.are_equal(14,#t)
+ assert.are_equal("GDEF",tostring(t[1]))
+ assert.are_equal("post",tostring(t[#t]))
+ end)
+
+ it("can return glyph count", function()
+ assert.are_equal(1133,face:get_glyph_count())
+ end)
+
+ it("can return unicode characters supported by face", function()
+ local u = face:collect_unicodes()
+ assert.are_equal(267,#u)
+ assert.are_equal(0x0000,u[1])
+ assert.are_equal(0xFEFF,u[#u])
+ end)
+
+ it("can return face names", function()
+ assert.are_equal("Copyright 2014 Google Inc. All Rights Reserved.",face:get_name(harfbuzz.ot.NAME_ID_COPYRIGHT))
+ assert.are_equal("Noto Nastaliq Urdu",face:get_name(harfbuzz.ot.NAME_ID_FONT_FAMILY))
+ assert.are_equal("Regular",face:get_name(harfbuzz.ot.NAME_ID_FONT_SUBFAMILY))
+ assert.are_equal("Noto Nastaliq Urdu",face:get_name(harfbuzz.ot.NAME_ID_FULL_NAME))
+ assert.are_equal("NotoNastaliqUrdu",face:get_name(harfbuzz.ot.NAME_ID_POSTSCRIPT_NAME))
+ assert.are_equal("Noto is a trademark of Google Inc.",face:get_name(harfbuzz.ot.NAME_ID_TRADEMARK))
+ assert.are_equal(331,#face:get_name(harfbuzz.ot.NAME_ID_LICENSE))
+ assert.are_equal(nil,face:get_name(harfbuzz.ot.NAME_ID_INVALID))
+ end)
+
+ it("can return face names with language", function()
+ local f = harfbuzz.Face.new('fonts/amiri-regular.ttf')
+ local ar = harfbuzz.Language.new("ar")
+ local en = harfbuzz.Language.new("en")
+ assert.are_equal("حقوق النشر 2010-2015، خالد حسني <khaledhosny@eglug.org>.",f:get_name(harfbuzz.ot.NAME_ID_COPYRIGHT, ar))
+ assert.are_equal("Copyright (c) 2010-2015, Khaled Hosny <khaledhosny@eglug.org>.\nPortions copyright (c) 2010, Sebastian Kosch <sebastian@aldusleaf.org>.",f:get_name(harfbuzz.ot.NAME_ID_COPYRIGHT, en))
+ assert.are_equal("عادي",f:get_name(harfbuzz.ot.NAME_ID_FONT_SUBFAMILY, ar))
+ assert.are_equal("Regular",f:get_name(harfbuzz.ot.NAME_ID_FONT_SUBFAMILY, en))
+ assert.are_equal("إصدارة 000٫108",f:get_name(harfbuzz.ot.NAME_ID_VERSION_STRING, ar))
+ assert.are_equal("Version 000.108 ",f:get_name(harfbuzz.ot.NAME_ID_VERSION_STRING, en))
+ assert.are_equal("خالد حسني",f:get_name(harfbuzz.ot.NAME_ID_DESIGNER, ar))
+ assert.are_equal("Khaled Hosny",f:get_name(harfbuzz.ot.NAME_ID_DESIGNER, en))
+ assert.are_equal(512,#f:get_name(harfbuzz.ot.NAME_ID_DESCRIPTION, ar))
+ assert.are_equal(263,#f:get_name(harfbuzz.ot.NAME_ID_DESCRIPTION, en))
+ assert.are_equal("صِفْ خَلْقَ خَوْدٍ كَمِثْلِ ٱلشَّمْسِ إِذْ بَزَغَتْ يَحْظَىٰ ٱلضَّجِيعُ بِهَا نَجْلَاءَ مِعْطَارِ.",f:get_name(harfbuzz.ot.NAME_ID_SAMPLE_TEXT, ar))
+ assert.are_equal("صِفْ خَلْقَ خَوْدٍ كَمِثْلِ ٱلشَّمْسِ إِذْ بَزَغَتْ يَحْظَىٰ ٱلضَّجِيعُ بِهَا نَجْلَاءَ مِعْطَارِ.",f:get_name(harfbuzz.ot.NAME_ID_SAMPLE_TEXT, en))
+ end)
+
+ it("can check color palettes", function()
+ local f = harfbuzz.Face.new('fonts/amiriquran-colored.ttf')
+ assert.are_equal(false,face:ot_color_has_palettes())
+ assert.are_equal(true,f:ot_color_has_palettes())
+ end)
+
+ it("can return number of color palettes", function()
+ local f = harfbuzz.Face.new('fonts/amiriquran-colored.ttf')
+ assert.are_equal(0,face:ot_color_palette_get_count())
+ assert.are_equal(1,f:ot_color_palette_get_count())
+ end)
+
+ it("can return palette colors", function()
+ local f = harfbuzz.Face.new('fonts/amiriquran-colored.ttf')
+ assert.are_equal(nil,face:ot_color_palette_get_colors())
+ local colors = {
+ { alpha = 255, blue = 51, green = 51, red = 204, },
+ { alpha = 255, blue = 80, green = 165, red = 0, },
+ { alpha = 255, blue = 51, green = 153, red = 238, },
+ { alpha = 255, blue = 153, green = 102, red = 51, },
+ }
+ assert.are_same(colors,f:ot_color_palette_get_colors())
+ end)
+
+ it("can check color layers", function()
+ local f = harfbuzz.Face.new('fonts/amiriquran-colored.ttf')
+ assert.are_equal(false,face:ot_color_has_layers())
+ assert.are_equal(true,f:ot_color_has_layers())
+ end)
+
+ it("can return glyph color layers", function()
+ local f = harfbuzz.Face.new('fonts/amiriquran-colored.ttf')
+ assert.are_equal(nil,face:ot_color_glyph_get_layers(100))
+ assert.are_equal(nil,f:ot_color_glyph_get_layers(2))
+ local layers = {
+ { color_index = 65535, glyph = 1341 },
+ { color_index = 1, glyph = 1370 },
+ }
+ assert.are_same(layers,f:ot_color_glyph_get_layers(100))
+ end)
+
+ it("can check color layers", function()
+ local f = harfbuzz.Face.new('fonts/notocoloremoji-subset.ttf')
+ assert.are_equal(false,face:ot_color_has_png())
+ assert.are_equal(true,f:ot_color_has_png())
+ end)
+
+ it("can return script tags", function()
+ local t
+ local tags = {
+ harfbuzz.Tag.new("arab"),
+ harfbuzz.Tag.new("dflt"),
+ harfbuzz.Tag.new("latn"),
+ }
+ t = face:ot_layout_get_script_tags(harfbuzz.Tag.new("GSUB"))
+ assert.are_same(tags, t)
+ t = face:ot_layout_get_script_tags(harfbuzz.Tag.new("GPOS"))
+ assert.are_same({ tags[1] }, t)
+ end)
+
+ it("can return language tags", function()
+ local t
+ local tags = {
+ harfbuzz.Tag.new("ARA "),
+ harfbuzz.Tag.new("FAR "),
+ harfbuzz.Tag.new("KSH "),
+ harfbuzz.Tag.new("SND "),
+ harfbuzz.Tag.new("URD "),
+ }
+ t = face:ot_layout_get_language_tags(harfbuzz.Tag.new("GSUB"), 0)
+ assert.are_same(tags, t)
+ t = face:ot_layout_get_language_tags(harfbuzz.Tag.new("GPOS"), 0)
+ assert.are_equal(nil, t)
+ end)
+
+ it("can return feature tags", function()
+ local t, tags
+ tags = {
+ harfbuzz.Tag.new("ccmp"),
+ harfbuzz.Tag.new("isol"),
+ harfbuzz.Tag.new("init"),
+ harfbuzz.Tag.new("medi"),
+ harfbuzz.Tag.new("fina"),
+ harfbuzz.Tag.new("rlig"),
+ }
+ t = face:ot_layout_get_feature_tags(harfbuzz.Tag.new("GSUB"), 0, 0)
+ assert.are_same(tags, t)
+ tags = {
+ harfbuzz.Tag.new("curs"),
+ harfbuzz.Tag.new("mark"),
+ harfbuzz.Tag.new("mkmk"),
+ }
+ t = face:ot_layout_get_feature_tags(harfbuzz.Tag.new("GPOS"), 0, harfbuzz.ot.LAYOUT_DEFAULT_LANGUAGE_INDEX)
+ assert.are_same(tags, t)
+ end)
+
+ it("can find scripts, languages and features", function()
+ local r, i
+ r, i = face:ot_layout_find_script(harfbuzz.Tag.new("GSUB"), harfbuzz.Tag.new("latn"))
+ assert.True(r)
+ assert.are_same(2, i)
+ r, i = face:ot_layout_find_language(harfbuzz.Tag.new("GSUB"), i, harfbuzz.Tag.new("ENG "))
+ assert.False(r)
+ assert.are_same(harfbuzz.ot.LAYOUT_DEFAULT_LANGUAGE_INDEX, i)
+ r, i = face:ot_layout_find_language(harfbuzz.Tag.new("GSUB"), 0, harfbuzz.Tag.new("ARA "))
+ assert.True(r)
+ assert.are_same(0, i)
+ r, i = face:ot_layout_find_feature(harfbuzz.Tag.new("GSUB"), 0, i, harfbuzz.Tag.new("rlig"))
+ assert.True(r)
+ assert.are_same(13, i)
+
+ r, i = face:ot_layout_find_feature(harfbuzz.Tag.new("GSUB"), 1, harfbuzz.ot.LAYOUT_DEFAULT_LANGUAGE_INDEX, harfbuzz.Tag.new("rlig"))
+ assert.True(r)
+ assert.are_same(13, i)
+ end)
+ end)
+
+ describe("harfbuzz.Font", function()
+ local face = harfbuzz.Face.new('fonts/notonastaliq.ttf')
+ it("can be initialized with a face", function()
+ harfbuzz.Font.new(face)
+ end)
+
+ it("has a default scale set to the fonts upem", function()
+ local font = harfbuzz.Font.new(face)
+ local upem = face:get_upem()
+ local xs, ys = font:get_scale()
+ assert.are_equal(upem, xs)
+ assert.are_equal(upem, ys)
+ end)
+
+ it("can set the scale of the font using set_scale", function()
+ local font = harfbuzz.Font.new(face)
+ font:set_scale(1024,2048)
+ local xs, ys = font:get_scale()
+ assert.are_equal(1024, xs)
+ assert.are_equal(2048, ys)
+ end)
+
+ it("can get glyph extents using get_glyph_extents", function()
+ local font = harfbuzz.Font.new(face)
+ local extents = font:get_glyph_extents(0)
+ assert.are_equal(145, extents.x_bearing)
+ assert.are_equal(2452, extents.y_bearing)
+ assert.are_equal(1553, extents.width)
+ assert.are_equal(-2452, extents.height)
+ extents = font:get_glyph_extents(1)
+ assert.are_equal(0, extents.x_bearing)
+ assert.are_equal(0, extents.y_bearing)
+ assert.are_equal(0, extents.width)
+ assert.are_equal(0, extents.height)
+ end)
+
+ it("can get font extents", function()
+ local font = harfbuzz.Font.new(face)
+ local extents = font:get_h_extents(0)
+ assert.are_equal(3900, extents.ascender)
+ assert.are_equal(-1220, extents.descender)
+ assert.are_equal(0, extents.line_gap)
+ extents = font:get_v_extents(1)
+ assert.are_equal(nil, extents)
+ end)
+
+ it("can get glyph name using get_glyph_name", function()
+ local font = harfbuzz.Font.new(face)
+ assert.are_equal(".notdef", font:get_glyph_name(0))
+ assert.are_equal("null", font:get_glyph_name(1))
+ end)
+
+ it("can get glyph using get_glyph_from_name", function()
+ local font = harfbuzz.Font.new(face)
+ assert.are_equal(0, font:get_glyph_from_name(".notdef"))
+ assert.are_equal(1, font:get_glyph_from_name("null"))
+ end)
+
+ it("can get glyph advance using get_glyph_h_advance", function()
+ local font = harfbuzz.Font.new(face)
+ assert.are_equal(1843, font:get_glyph_h_advance(0))
+ assert.are_equal(0, font:get_glyph_h_advance(1))
+ end)
+
+ it("can get glyph advance using get_glyph_v_advance", function()
+ local font = harfbuzz.Font.new(face)
+ assert.are_equal(-2048, font:get_glyph_v_advance(0))
+ assert.are_equal(-2048, font:get_glyph_v_advance(1))
+ end)
+
+ it("can get nominal glyph for codepoint", function()
+ local font = harfbuzz.Font.new(face)
+ assert.are_equal(nil, font:get_nominal_glyph(0x0041))
+ assert.are_equal(858, font:get_nominal_glyph(0x0627))
+ end)
+
+ it("can return glyph color png", function()
+ local font = harfbuzz.Font.new(face)
+ local f = harfbuzz.Font.new(harfbuzz.Face.new('fonts/notocoloremoji-subset.ttf'))
+
+ assert.are_equal(nil,font:ot_color_glyph_get_png(100))
+ assert.are_equal(nil,f:ot_color_glyph_get_png(0))
+ assert.are_same(2233,f:ot_color_glyph_get_png(1):get_length())
+ assert.are_same(2857,f:ot_color_glyph_get_png(2):get_length())
+ assert.are_same("\137PNG",f:ot_color_glyph_get_png(2):get_data():sub(1, 4))
+ end)
+ end)
+
+ describe("harfbuzz.Feature", function()
+ it("can be initialised with a valid feature string", function()
+ harfbuzz.Feature.new('kern')
+ harfbuzz.Feature.new('+kern')
+ end)
+
+ it("throws an error when trying to initialise a new Feature with an invalid string", function()
+ assert.are_equal(nil, harfbuzz.Feature.new(''))
+ assert.are_equal(nil, harfbuzz.Feature.new('#kern'))
+ end)
+
+ it("has a valid tostring value", function()
+ local fs = 'kern'
+ local f = harfbuzz.Feature.new(fs)
+ assert.are_equal(fs, tostring(f))
+ end)
+ end)
+
+ describe("harfbuzz.Tag", function()
+ it("can be initialised with a valid tag string", function()
+ harfbuzz.Tag.new('Zyyy')
+ end)
+
+ it("can be initialised to NONE with nil or empty argument", function()
+ local t = harfbuzz.Tag.new()
+ assert.are_equal(harfbuzz.Tag.NONE, t)
+ t = harfbuzz.Tag.new(nil)
+ assert.are_equal(harfbuzz.Tag.NONE, t)
+ end)
+
+ it("has a valid tostring value", function()
+ local ts = 'Arab'
+ local t = harfbuzz.Tag.new(ts)
+ assert.are_equal(ts, tostring(t))
+ end)
+
+ it("has a valid equality check functions", function()
+ local ts = 'Arab'
+ local t1 = harfbuzz.Tag.new(ts)
+ local t2 = harfbuzz.Tag.new(ts)
+ local t3 = harfbuzz.Tag.new("Latn")
+ assert.are_equal(t1, t2)
+ assert.are_not_equal(t1, t3)
+ end)
+
+ it("has a preset value for NONE", function()
+ local n = harfbuzz.Tag.NONE
+ assert.is_not_nil(n)
+ assert.are_equal("", tostring(n))
+ assert.are_equal(harfbuzz.Tag.NONE, harfbuzz.Tag.new(""))
+ end)
+ end)
+
+ describe("harfbuzz.Script", function()
+ it("can be initialised with a string", function()
+ harfbuzz.Script.new('Arab')
+ end)
+
+ it("can be initialised to INVALID with nil or empty argument", function()
+ local t = harfbuzz.Script.new()
+ assert.are_equal(harfbuzz.Script.INVALID, t)
+ t = harfbuzz.Script.new(nil)
+ assert.are_equal(harfbuzz.Script.INVALID, t)
+ end)
+
+ it("can be initialised with a tag", function()
+ local ts = "Arab"
+ local s = harfbuzz.Script.from_iso15924_tag(harfbuzz.Tag.new(ts))
+ assert.are_equal(ts, tostring(s))
+ end)
+
+ it("can be converted to a tag", function()
+ local s = 'Arab'
+ local sc = harfbuzz.Script.new(s)
+ assert.are_equal(s, tostring(sc:to_iso15924_tag()))
+ end)
+
+ it("has a valid tostring value", function()
+ local ts = 'Arab'
+ local t = harfbuzz.Script.new(ts)
+ assert.are_equal(ts, tostring(t))
+ end)
+
+ it("has a valid equality check functions", function()
+ local ts = 'Arab'
+ local t1 = harfbuzz.Script.new(ts)
+ local t2 = harfbuzz.Script.new(ts)
+ local t3 = harfbuzz.Script.new("Latn")
+ assert.are_equal(t1, t2)
+ assert.are_not_equal(t1, t3)
+ end)
+ end)
+
+ describe("harfbuzz.Direction", function()
+ it("can be initialised with a valid tag string", function()
+ harfbuzz.Direction.new('LTR')
+ end)
+
+ it("can be initialised with invalid strings", function()
+ local d1 = harfbuzz.Direction.new("i")
+ local d2 = harfbuzz.Direction.new("inv")
+
+ assert.are_equal(d1, d2)
+ assert.are_equal("invalid", tostring(d1))
+ end)
+
+ it("has a valid tostring value", function()
+ local ts = 'ltr'
+ local t = harfbuzz.Direction.new(ts)
+ assert.are_equal(ts, tostring(t))
+
+ t = harfbuzz.Direction.new("LTR")
+ assert.are_equal(ts, tostring(t))
+ end)
+
+ it("has a valid equality check functions", function()
+ local ts = 'ltr'
+ local t1 = harfbuzz.Direction.new(ts)
+ local t2 = harfbuzz.Direction.new(ts)
+ local t3 = harfbuzz.Direction.new("rtl")
+ assert.are_equal(t1, t2)
+ assert.are_not_equal(t1, t3)
+ end)
+
+ it("has a is_valid function", function()
+ assert.True(harfbuzz.Direction.LTR:is_valid())
+ assert.False(harfbuzz.Direction.INVALID:is_valid())
+ end)
+
+ it("has a is_horizontal function", function()
+ assert.True(harfbuzz.Direction.LTR:is_horizontal())
+ assert.False(harfbuzz.Direction.TTB:is_horizontal())
+ end)
+
+ it("has a is_vertical function", function()
+ assert.True(harfbuzz.Direction.TTB:is_vertical())
+ assert.False(harfbuzz.Direction.LTR:is_vertical())
+ end)
+
+ it("has a is_forward function", function()
+ assert.True(harfbuzz.Direction.LTR:is_forward())
+ assert.False(harfbuzz.Direction.RTL:is_forward())
+ end)
+
+ it("has a is_backward function", function()
+ assert.True(harfbuzz.Direction.RTL:is_backward())
+ assert.False(harfbuzz.Direction.LTR:is_backward())
+ end)
+ end)
+
+ describe("harfbuzz.Language", function()
+ it("can be initialised with a valid language string", function()
+ harfbuzz.Language.new('urd')
+ end)
+
+ it("can be initialised to INVALID with nil or empty argument", function()
+ local t = harfbuzz.Language.new()
+ assert.are_equal(harfbuzz.Language.INVALID, t)
+ t = harfbuzz.Language.new(nil)
+ assert.are_equal(harfbuzz.Language.INVALID, t)
+ end)
+
+ it("has a valid tostring value", function()
+ local ts = 'urd'
+ local t = harfbuzz.Language.new(ts)
+ assert.are_equal(ts, tostring(t))
+ end)
+
+ it("has a valid equality check functions", function()
+ local ts = 'urd'
+ local t1 = harfbuzz.Language.new(ts)
+ local t2 = harfbuzz.Language.new(ts)
+ local t3 = harfbuzz.Language.new("hin")
+ assert.are_equal(t1, t2)
+ assert.are_not_equal(t1, t3)
+ end)
+
+ it("has a preset value for INVALID", function()
+ local n = harfbuzz.Language.INVALID
+ assert.is_not_nil(n)
+ assert.are_equal(harfbuzz.Language.INVALID, harfbuzz.Language.new())
+ assert.are_equal("", tostring(n))
+ end)
+ end)
+
+ describe("harfbuzz.unicode", function()
+ describe("script function returns a valid script for a codepoint",function()
+ local s = harfbuzz.unicode.script(0x0020)
+ assert.are_equal(harfbuzz.Script.COMMON, s)
+ s = harfbuzz.unicode.script(0x0041)
+ assert.are_equal(harfbuzz.Script.new("Latn"), s)
+ end)
+ end)
+end)
+