test/shape/run-tests.py - third_party/harfbuzz - Git at Google

 #!/usr/bin/env python3

 import sys, os, subprocess, hashlib

 print("TAP version 14")

 args = sys.argv[1:]

 verbose = False
 if args and args[0] == "-v":
     verbose = True
     args = args[1:]

 if not args or args[0].find("hb-shape") == -1 or not os.path.exists(args[0]):
     sys.exit("""First argument does not seem to point to usable hb-shape.""")
 hb_shape, args = args[0], args[1:]

 env = os.environ.copy()
 env["LC_ALL"] = "C"

 EXE_WRAPPER = os.environ.get("MESON_EXE_WRAPPER")


 def open_shape_batch_process():
     cmd = [hb_shape, "--batch"]
     if EXE_WRAPPER:
         cmd = [EXE_WRAPPER] + cmd

     process = subprocess.Popen(
         cmd,
         stdin=subprocess.PIPE,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         env=env,
     )
     return [process]


 shape_process = open_shape_batch_process()
 no_glyph_names_process = None


 def shape_cmd(command, shape_process, verbose=False):
     global hb_shape

     # (Re)start shaper if it is dead
     if shape_process[0].poll() is not None:
         shape_process[0].stdin.close()
         shape_process[0].stdout.close()
         shape_process[0].stderr.close()
         shape_process[0] = open_shape_batch_process()[0]

     if verbose:
         print("# " + hb_shape + " " + " ".join(command))
     shape_process[0].stdin.write((";".join(command) + "\n").encode("utf-8"))
     shape_process[0].stdin.flush()
     return shape_process[0].stdout.readline().decode("utf-8").strip()


 def plural(what):
     if not what.endswith("s"):
         what += "s"
     return what


 def whats_var_name(what):
     return plural(what).replace("-", "_")


 def supported_whats_var_name(what):
     whats = whats_var_name(what)
     return "supported_" + whats


 def supported_whats(what):
     return globals()[supported_whats_var_name(what)]


 def all_whats_var_name(what):
     whats = whats_var_name(what)
     return "all_" + whats


 def all_whats(what):
     return globals()[all_whats_var_name(what)]


 # Collect supported backends
 for what in ["shaper", "face-loader", "font-funcs"]:
     subcommand = "--list-" + plural(what)

     cmd = [hb_shape, subcommand]
     if EXE_WRAPPER:
         cmd = [EXE_WRAPPER] + cmd

     what_process = subprocess.Popen(
         cmd,
         stdin=subprocess.PIPE,
         stdout=subprocess.PIPE,
         stderr=sys.stdout,
         env=env,
     )
     # Capture the output
     what_list = what_process.communicate()[0].decode("utf-8").strip().split()
     if what_process.returncode:
         sys.exit(f"Failed to run: {hb_shape} {subcommand}")
     whats = plural(what)
     var_name = supported_whats_var_name(what)
     globals()[var_name] = what_list
     print(f"# Supported {whats}: {what_list}")

 # If running under Wine and not native dlls, make the respective shapers unavailable.
 if os.environ.get("WINEPATH"):
     overrides = os.environ.get("WINEDLLOVERRIDES", "").lower()
     if "directwrite" in supported_shapers and overrides.find("dwrite") == -1:
         supported_shapers.remove("directwrite")
         print("# Skipping DirectWrite shaper under Wine.")
     if "uniscribe" in supported_shapers and overrides.find("usp10") == -1:
         supported_shapers.remove("uniscribe")
         print("# Skipping Uniscribe shaper under Wine.")


 number = 0
 passes = 0
 fails = 0
 skips = 0

 if not len(args):
     args = ["-"]

 for filename in args:
     if filename == "-":
         print("# Running tests from standard input")
     else:
         print("# Running tests in " + filename)

     if filename == "-":
         f = sys.stdin
     else:
         f = open(filename, encoding="utf8")

     # By default test all backends
     for what in ["shaper", "face-loader", "font-funcs"]:
         all_var_name = all_whats_var_name(what)
         globals()[all_var_name] = supported_whats(what)
     all_face_loaders = os.environ.get("HB_FACE_LOADER", "ot").split(",")
     all_shapers = os.environ.get("HB_SHAPER_LIST", "ot").split(",")

     # Right now we only test the 'ot' shaper if nothing specified,
     # but try all font-funcs unless overriden.
     # Only 'ot' face-loader is tested.

     for line in f:
         comment = False
         if line.startswith("#"):
             comment = True
             line = line[1:]

             if line.startswith(" "):
                 if verbose:
                     print("#%s" % line)
                 continue

         line = line.strip()
         if not line:
             continue

         if line.startswith("@"):
             # Directive
             line = line.strip()
             line = line.split("#")[0].strip()[1:]
             consumed = False
             for what in ["shaper", "face-loader", "font-funcs"]:
                 whats = plural(what)
                 if line.startswith(what) or line.startswith(whats):
                     command, values = line.split("=")
                     values = values.strip().split(",")

                     supported = supported_whats(what)
                     if command[-1] == "-":
                         # Exclude
                         values = [v for v in supported if v not in values]
                     else:
                         # Specify
                         values = [v for v in values if v in supported]

                     var_name = all_whats_var_name(what)
                     print(f"# Setting {whats} to test to {values}")
                     globals()[var_name] = values
                     consumed = True
             if consumed:
                 print("#", line)
                 continue
             else:
                 print("Unrecognized directive: %s" % line, file=sys.stderr)
                 sys.exit(1)

         fontfile, options, unicodes, glyphs_expected = line.split(";")
         options = options.split()
         if fontfile.startswith("/") or fontfile.startswith('"/'):
             if os.name == "nt":  # Skip on Windows
                 continue

             fontfile, expected_hash = (fontfile.split("@") + [""])[:2]

             try:
                 with open(fontfile, "rb") as ff:
                     if expected_hash:
                         actual_hash = hashlib.sha1(ff.read()).hexdigest().strip()
                         if actual_hash != expected_hash:
                             skips += 1
                             print(
                                 "# Different version of %s found; Expected hash %s, got %s; skipping."
                                 % (fontfile, expected_hash, actual_hash)
                             )
                             continue
             except IOError:
                 skips += 1
                 print("# %s not found, skip." % fontfile)
                 continue
         else:
             cwd = os.path.dirname(filename)
             fontfile = os.path.normpath(os.path.join(cwd, fontfile))

         if comment:
             if verbose:
                 print('# # %s "%s" --unicodes %s' % (hb_shape, fontfile, unicodes))
             continue

         skip_test = False
         shaper = None
         face_loader = None
         font_funcs = None
         new_options = []
         it = iter(options)
         for option in it:
             consumed = False
             for what in ["shaper", "face-loader", "font-funcs"]:
                 if option.startswith("--" + what):
                     try:
                         backend = option.split("=")[1]
                     except IndexError:
                         backend = next(it)
                     if backend not in supported_whats(what):
                         skips += 1
                         number += 1
                         print(
                             f"ok {number} - {fontfile} # skip {what}={backend} not supported"
                         )
                         print(f"# Skipping test with {what}={backend}.")
                         skip_test = True
                         break
                     what = what.replace("-", "_")
                     globals()[what] = backend
                     consumed = True
             if not consumed:
                 new_options.append(option)

             if skip_test:
                 break
         if skip_test:
             continue
         options = new_options

         for face_loader in [face_loader] if face_loader else all_whats("face-loader"):
             for shaper in [shaper] if shaper else all_whats("shaper"):
                 all_font_funcs_for_shaper = (
                     all_whats("font-funcs") if shaper == "ot" else [None]
                 )
                 for font_funcs in (
                     [font_funcs] if font_funcs else all_font_funcs_for_shaper
                 ):
                     number += 1
                     extra_options = []

                     if shaper:
                         extra_options.append("--shaper=" + shaper)
                     if face_loader:
                         extra_options.append("--face-loader=" + face_loader)
                     if font_funcs:
                         extra_options.append("--font-funcs=" + font_funcs)

                     if glyphs_expected != "*":
                         extra_options.append("--verify")
                         extra_options.append("--unsafe-to-concat")
                         extra_options.append("--safe-to-insert-tatweel")

                     if verbose:
                         print(
                             "# shaper=%s face-loader=%s font-funcs=%s"
                             % (shaper, face_loader, font_funcs)
                         )
                     cmd = (
                         [fontfile] + ["--unicodes", unicodes] + options + extra_options
                     )
                     glyphs = shape_cmd(cmd, shape_process, verbose).strip()

                     if glyphs_expected == "*":
                         passes += 1
                         print(f"ok {number} - {fontfile}")
                         continue

                     final_glyphs = glyphs
                     final_glyphs_expected = glyphs_expected

                     if glyphs != glyphs_expected and glyphs.find("gid") != -1:
                         if not no_glyph_names_process:
                             no_glyph_names_process = open_shape_batch_process()

                         cmd2 = [fontfile] + ["--glyphs", "--no-glyph-names", glyphs]
                         final_glyphs = shape_cmd(cmd2, no_glyph_names_process).strip()

                         cmd2 = [fontfile] + [
                             "--glyphs",
                             "--no-glyph-names",
                             glyphs_expected,
                         ]
                         final_glyphs_expected = shape_cmd(
                             cmd2, no_glyph_names_process
                         ).strip()

                     # If the removal of glyph_ids failed, fail the test.
                     # https://github.com/harfbuzz/harfbuzz/issues/5169
                     if (
                         not final_glyphs_expected
                         or final_glyphs != final_glyphs_expected
                     ):
                         fails += 1
                         cmd = hb_shape + " " + " ".join(cmd)
                         print(f"not ok {number} - {cmd}")
                         print("   ---", file=sys.stderr)
                         print('   test_file: "' + filename + '"', file=sys.stderr)
                         print('   cmd: "' + cmd + '"', file=sys.stderr)
                         print('   actual:   "' + glyphs + '"', file=sys.stderr)
                         print('   expected: "' + glyphs_expected + '"', file=sys.stderr)
                         if final_glyphs != glyphs:
                             print(
                                 '   actual_gids:   "' + final_glyphs + '"',
                                 file=sys.stderr,
                             )
                             print(
                                 '   expected_gids: "' + final_glyphs_expected + '"',
                                 file=sys.stderr,
                             )
                         print("   ...", file=sys.stderr)
                     else:
                         cmd = hb_shape + " " + " ".join(cmd)
                         passes += 1
                         print(f"ok {number} - {cmd}")

 print("# %d tests passed; %d failed; %d skipped." % (passes, fails, skips))
 if not (fails + passes):
     print("# No tests ran.")
 elif not (fails + skips):
     print("# All tests passed.")

 print("1..%d" % number)
	#!/usr/bin/env python3

	import sys, os, subprocess, hashlib

	print("TAP version 14")

	args = sys.argv[1:]

	verbose = False
	if args and args[0] == "-v":
	verbose = True
	args = args[1:]

	if not args or args[0].find("hb-shape") == -1 or not os.path.exists(args[0]):
	sys.exit("""First argument does not seem to point to usable hb-shape.""")
	hb_shape, args = args[0], args[1:]

	env = os.environ.copy()
	env["LC_ALL"] = "C"

	EXE_WRAPPER = os.environ.get("MESON_EXE_WRAPPER")


	def open_shape_batch_process():
	cmd = [hb_shape, "--batch"]
	if EXE_WRAPPER:
	cmd = [EXE_WRAPPER] + cmd

	process = subprocess.Popen(
	cmd,
	stdin=subprocess.PIPE,
	stdout=subprocess.PIPE,
	stderr=subprocess.PIPE,
	env=env,
	)
	return [process]


	shape_process = open_shape_batch_process()
	no_glyph_names_process = None


	def shape_cmd(command, shape_process, verbose=False):
	global hb_shape

	# (Re)start shaper if it is dead
	if shape_process[0].poll() is not None:
	shape_process[0].stdin.close()
	shape_process[0].stdout.close()
	shape_process[0].stderr.close()
	shape_process[0] = open_shape_batch_process()[0]

	if verbose:
	print("# " + hb_shape + " " + " ".join(command))
	shape_process[0].stdin.write((";".join(command) + "\n").encode("utf-8"))
	shape_process[0].stdin.flush()
	return shape_process[0].stdout.readline().decode("utf-8").strip()


	def plural(what):
	if not what.endswith("s"):
	what += "s"
	return what


	def whats_var_name(what):
	return plural(what).replace("-", "_")


	def supported_whats_var_name(what):
	whats = whats_var_name(what)
	return "supported_" + whats


	def supported_whats(what):
	return globals()[supported_whats_var_name(what)]


	def all_whats_var_name(what):
	whats = whats_var_name(what)
	return "all_" + whats


	def all_whats(what):
	return globals()[all_whats_var_name(what)]


	# Collect supported backends
	for what in ["shaper", "face-loader", "font-funcs"]:
	subcommand = "--list-" + plural(what)

	cmd = [hb_shape, subcommand]
	if EXE_WRAPPER:
	cmd = [EXE_WRAPPER] + cmd

	what_process = subprocess.Popen(
	cmd,
	stdin=subprocess.PIPE,
	stdout=subprocess.PIPE,
	stderr=sys.stdout,
	env=env,
	)
	# Capture the output
	what_list = what_process.communicate()[0].decode("utf-8").strip().split()
	if what_process.returncode:
	sys.exit(f"Failed to run: {hb_shape} {subcommand}")
	whats = plural(what)
	var_name = supported_whats_var_name(what)
	globals()[var_name] = what_list
	print(f"# Supported {whats}: {what_list}")

	# If running under Wine and not native dlls, make the respective shapers unavailable.
	if os.environ.get("WINEPATH"):
	overrides = os.environ.get("WINEDLLOVERRIDES", "").lower()
	if "directwrite" in supported_shapers and overrides.find("dwrite") == -1:
	supported_shapers.remove("directwrite")
	print("# Skipping DirectWrite shaper under Wine.")
	if "uniscribe" in supported_shapers and overrides.find("usp10") == -1:
	supported_shapers.remove("uniscribe")
	print("# Skipping Uniscribe shaper under Wine.")


	number = 0
	passes = 0
	fails = 0
	skips = 0

	if not len(args):
	args = ["-"]

	for filename in args:
	if filename == "-":
	print("# Running tests from standard input")
	else:
	print("# Running tests in " + filename)

	if filename == "-":
	f = sys.stdin
	else:
	f = open(filename, encoding="utf8")

	# By default test all backends
	for what in ["shaper", "face-loader", "font-funcs"]:
	all_var_name = all_whats_var_name(what)
	globals()[all_var_name] = supported_whats(what)
	all_face_loaders = os.environ.get("HB_FACE_LOADER", "ot").split(",")
	all_shapers = os.environ.get("HB_SHAPER_LIST", "ot").split(",")

	# Right now we only test the 'ot' shaper if nothing specified,
	# but try all font-funcs unless overriden.
	# Only 'ot' face-loader is tested.

	for line in f:
	comment = False
	if line.startswith("#"):
	comment = True
	line = line[1:]

	if line.startswith(" "):
	if verbose:
	print("#%s" % line)
	continue

	line = line.strip()
	if not line:
	continue

	if line.startswith("@"):
	# Directive
	line = line.strip()
	line = line.split("#")[0].strip()[1:]
	consumed = False
	for what in ["shaper", "face-loader", "font-funcs"]:
	whats = plural(what)
	if line.startswith(what) or line.startswith(whats):
	command, values = line.split("=")
	values = values.strip().split(",")

	supported = supported_whats(what)
	if command[-1] == "-":
	# Exclude
	values = [v for v in supported if v not in values]
	else:
	# Specify
	values = [v for v in values if v in supported]

	var_name = all_whats_var_name(what)
	print(f"# Setting {whats} to test to {values}")
	globals()[var_name] = values
	consumed = True
	if consumed:
	print("#", line)
	continue
	else:
	print("Unrecognized directive: %s" % line, file=sys.stderr)
	sys.exit(1)

	fontfile, options, unicodes, glyphs_expected = line.split(";")
	options = options.split()
	if fontfile.startswith("/") or fontfile.startswith('"/'):
	if os.name == "nt": # Skip on Windows
	continue

	fontfile, expected_hash = (fontfile.split("@") + [""])[:2]

	try:
	with open(fontfile, "rb") as ff:
	if expected_hash:
	actual_hash = hashlib.sha1(ff.read()).hexdigest().strip()
	if actual_hash != expected_hash:
	skips += 1
	print(
	"# Different version of %s found; Expected hash %s, got %s; skipping."
	% (fontfile, expected_hash, actual_hash)
	)
	continue
	except IOError:
	skips += 1
	print("# %s not found, skip." % fontfile)
	continue
	else:
	cwd = os.path.dirname(filename)
	fontfile = os.path.normpath(os.path.join(cwd, fontfile))

	if comment:
	if verbose:
	print('# # %s "%s" --unicodes %s' % (hb_shape, fontfile, unicodes))
	continue

	skip_test = False
	shaper = None
	face_loader = None
	font_funcs = None
	new_options = []
	it = iter(options)
	for option in it:
	consumed = False
	for what in ["shaper", "face-loader", "font-funcs"]:
	if option.startswith("--" + what):
	try:
	backend = option.split("=")[1]
	except IndexError:
	backend = next(it)
	if backend not in supported_whats(what):
	skips += 1
	number += 1
	print(
	f"ok {number} - {fontfile} # skip {what}={backend} not supported"
	)
	print(f"# Skipping test with {what}={backend}.")
	skip_test = True
	break
	what = what.replace("-", "_")
	globals()[what] = backend
	consumed = True
	if not consumed:
	new_options.append(option)

	if skip_test:
	break
	if skip_test:
	continue
	options = new_options

	for face_loader in [face_loader] if face_loader else all_whats("face-loader"):
	for shaper in [shaper] if shaper else all_whats("shaper"):
	all_font_funcs_for_shaper = (
	all_whats("font-funcs") if shaper == "ot" else [None]
	)
	for font_funcs in (
	[font_funcs] if font_funcs else all_font_funcs_for_shaper
	):
	number += 1
	extra_options = []

	if shaper:
	extra_options.append("--shaper=" + shaper)
	if face_loader:
	extra_options.append("--face-loader=" + face_loader)
	if font_funcs:
	extra_options.append("--font-funcs=" + font_funcs)

	if glyphs_expected != "*":
	extra_options.append("--verify")
	extra_options.append("--unsafe-to-concat")
	extra_options.append("--safe-to-insert-tatweel")

	if verbose:
	print(
	"# shaper=%s face-loader=%s font-funcs=%s"
	% (shaper, face_loader, font_funcs)
	)
	cmd = (
	[fontfile] + ["--unicodes", unicodes] + options + extra_options
	)
	glyphs = shape_cmd(cmd, shape_process, verbose).strip()

	if glyphs_expected == "*":
	passes += 1
	print(f"ok {number} - {fontfile}")
	continue

	final_glyphs = glyphs
	final_glyphs_expected = glyphs_expected

	if glyphs != glyphs_expected and glyphs.find("gid") != -1:
	if not no_glyph_names_process:
	no_glyph_names_process = open_shape_batch_process()

	cmd2 = [fontfile] + ["--glyphs", "--no-glyph-names", glyphs]
	final_glyphs = shape_cmd(cmd2, no_glyph_names_process).strip()

	cmd2 = [fontfile] + [
	"--glyphs",
	"--no-glyph-names",
	glyphs_expected,
	]
	final_glyphs_expected = shape_cmd(
	cmd2, no_glyph_names_process
	).strip()

	# If the removal of glyph_ids failed, fail the test.
	# https://github.com/harfbuzz/harfbuzz/issues/5169
	if (
	not final_glyphs_expected
	or final_glyphs != final_glyphs_expected
	):
	fails += 1
	cmd = hb_shape + " " + " ".join(cmd)
	print(f"not ok {number} - {cmd}")
	print(" ---", file=sys.stderr)
	print(' test_file: "' + filename + '"', file=sys.stderr)
	print(' cmd: "' + cmd + '"', file=sys.stderr)
	print(' actual: "' + glyphs + '"', file=sys.stderr)
	print(' expected: "' + glyphs_expected + '"', file=sys.stderr)
	if final_glyphs != glyphs:
	print(
	' actual_gids: "' + final_glyphs + '"',
	file=sys.stderr,
	)
	print(
	' expected_gids: "' + final_glyphs_expected + '"',
	file=sys.stderr,
	)
	print(" ...", file=sys.stderr)
	else:
	cmd = hb_shape + " " + " ".join(cmd)
	passes += 1
	print(f"ok {number} - {cmd}")

	print("# %d tests passed; %d failed; %d skipped." % (passes, fails, skips))
	if not (fails + passes):
	print("# No tests ran.")
	elif not (fails + skips):
	print("# All tests passed.")

	print("1..%d" % number)