From 2c2a0964d7aba10049d7eecbd46914d836dbc466 Mon Sep 17 00:00:00 2001
From: Behdad Esfahbod <behdad@behdad.org>
Date: Wed, 1 Feb 2023 18:55:48 -0700
Subject: [PATCH] [ttGlyphSet_test] Add another varComposite test

This one has different characteristics, hitting more code.
---
 Tests/ttLib/data/varc-6868.ttf | Bin 0 -> 10848 bytes
 Tests/ttLib/ttGlyphSet_test.py | 232 ++++++++++++++++++++++++++++++++-
 2 files changed, 231 insertions(+), 1 deletion(-)
 create mode 100644 Tests/ttLib/data/varc-6868.ttf

diff --git a/Tests/ttLib/data/varc-6868.ttf b/Tests/ttLib/data/varc-6868.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..e096f94ee4b4c227a2a62ff71afffdaa1ceb001d
GIT binary patch
literal 10848
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

literal 0
HcmV?d00001

diff --git a/Tests/ttLib/ttGlyphSet_test.py b/Tests/ttLib/ttGlyphSet_test.py
index 2ce0b41de..05f43a77b 100644
--- a/Tests/ttLib/ttGlyphSet_test.py
+++ b/Tests/ttLib/ttGlyphSet_test.py
@@ -158,7 +158,7 @@ class TTGlyphSetTest(object):
 
         assert actual == expected, (location, actual, expected)
 
-    def test_glyphset_varComposite(self):
+    def test_glyphset_varComposite1(self):
         font = TTFont(self.getpath("varc-ac00-ac01.ttf"))
         glyphset = font.getGlyphSet(location={"wght": 600})
 
@@ -249,3 +249,233 @@ class TTGlyphSetTest(object):
         ]
 
         assert actual == expected, (actual, expected)
+
+    def test_glyphset_varComposite2(self):
+        # This test font has axis variations
+
+        font = TTFont(self.getpath("varc-6868.ttf"))
+        glyphset = font.getGlyphSet(location={"wght": 600})
+
+        pen = RecordingPen()
+        glyph = glyphset["uni6868"]
+
+        glyph.draw(pen)
+        actual = pen.value
+
+        expected = [
+            ("moveTo", ((460, 565),)),
+            (
+                "qCurveTo",
+                (
+                    (482, 577),
+                    (526, 603),
+                    (568, 632),
+                    (607, 663),
+                    (644, 698),
+                    (678, 735),
+                    (708, 775),
+                    (721, 796),
+                ),
+            ),
+            ("lineTo", ((632, 835),)),
+            (
+                "qCurveTo",
+                (
+                    (621, 817),
+                    (595, 784),
+                    (566, 753),
+                    (534, 724),
+                    (499, 698),
+                    (462, 675),
+                    (423, 653),
+                    (403, 644),
+                ),
+            ),
+            ("closePath", ()),
+            ("moveTo", ((616, 765),)),
+            ("lineTo", ((590, 682),)),
+            ("lineTo", ((830, 682),)),
+            ("lineTo", ((833, 682),)),
+            ("lineTo", ((828, 693),)),
+            (
+                "qCurveTo",
+                (
+                    (817, 671),
+                    (775, 620),
+                    (709, 571),
+                    (615, 525),
+                    (492, 490),
+                    (413, 480),
+                ),
+            ),
+            ("lineTo", ((454, 386),)),
+            (
+                "qCurveTo",
+                (
+                    (544, 403),
+                    (687, 455),
+                    (798, 519),
+                    (877, 590),
+                    (926, 655),
+                    (937, 684),
+                ),
+            ),
+            ("lineTo", ((937, 765),)),
+            ("closePath", ()),
+            ("moveTo", ((723, 555),)),
+            (
+                "qCurveTo",
+                (
+                    (713, 563),
+                    (693, 579),
+                    (672, 595),
+                    (651, 610),
+                    (629, 625),
+                    (606, 638),
+                    (583, 651),
+                    (572, 657),
+                ),
+            ),
+            ("lineTo", ((514, 590),)),
+            (
+                "qCurveTo",
+                (
+                    (525, 584),
+                    (547, 572),
+                    (568, 559),
+                    (589, 545),
+                    (609, 531),
+                    (629, 516),
+                    (648, 500),
+                    (657, 492),
+                ),
+            ),
+            ("closePath", ()),
+            ("moveTo", ((387, 375),)),
+            ("lineTo", ((387, 830),)),
+            ("lineTo", ((289, 830),)),
+            ("lineTo", ((289, 375),)),
+            ("closePath", ()),
+            ("moveTo", ((96, 383),)),
+            (
+                "qCurveTo",
+                (
+                    (116, 390),
+                    (156, 408),
+                    (194, 427),
+                    (231, 449),
+                    (268, 472),
+                    (302, 497),
+                    (335, 525),
+                    (351, 539),
+                ),
+            ),
+            ("lineTo", ((307, 610),)),
+            (
+                "qCurveTo",
+                (
+                    (291, 597),
+                    (257, 572),
+                    (221, 549),
+                    (185, 528),
+                    (147, 509),
+                    (108, 492),
+                    (69, 476),
+                    (48, 469),
+                ),
+            ),
+            ("closePath", ()),
+            ("moveTo", ((290, 653),)),
+            (
+                "qCurveTo",
+                (
+                    (281, 664),
+                    (261, 687),
+                    (240, 708),
+                    (219, 729),
+                    (196, 749),
+                    (173, 768),
+                    (148, 786),
+                    (136, 794),
+                ),
+            ),
+            ("lineTo", ((69, 727),)),
+            (
+                "qCurveTo",
+                (
+                    (81, 719),
+                    (105, 702),
+                    (129, 684),
+                    (151, 665),
+                    (173, 645),
+                    (193, 625),
+                    (213, 604),
+                    (222, 593),
+                ),
+            ),
+            ("closePath", ()),
+            ("moveTo", ((913, -57),)),
+            ("lineTo", ((953, 30),)),
+            (
+                "qCurveTo",
+                (
+                    (919, 41),
+                    (854, 67),
+                    (790, 98),
+                    (729, 134),
+                    (671, 173),
+                    (616, 217),
+                    (564, 264),
+                    (540, 290),
+                ),
+            ),
+            ("lineTo", ((522, 286),)),
+            ("qCurveTo", ((511, 267), (498, 235), (493, 213), (492, 206))),
+            ("lineTo", ((515, 209),)),
+            ("qCurveTo", ((569, 146), (695, 44), (835, -32), (913, -57))),
+            ("closePath", ()),
+            ("moveTo", ((474, 274),)),
+            ("lineTo", ((452, 284),)),
+            (
+                "qCurveTo",
+                (
+                    (428, 260),
+                    (377, 214),
+                    (323, 172),
+                    (266, 135),
+                    (206, 101),
+                    (144, 71),
+                    (80, 46),
+                    (47, 36),
+                ),
+            ),
+            ("lineTo", ((89, -53),)),
+            ("qCurveTo", ((163, -29), (299, 46), (423, 142), (476, 201))),
+            ("lineTo", ((498, 196),)),
+            ("qCurveTo", ((498, 203), (494, 225), (482, 255), (474, 274))),
+            ("closePath", ()),
+            ("moveTo", ((450, 250),)),
+            ("lineTo", ((550, 250),)),
+            ("lineTo", ((550, 379),)),
+            ("lineTo", ((450, 379),)),
+            ("closePath", ()),
+            ("moveTo", ((68, 215),)),
+            ("lineTo", ((932, 215),)),
+            ("lineTo", ((932, 305),)),
+            ("lineTo", ((68, 305),)),
+            ("closePath", ()),
+            ("moveTo", ((450, -71),)),
+            ("lineTo", ((550, -71),)),
+            ("lineTo", ((550, -71),)),
+            ("lineTo", ((550, 267),)),
+            ("lineTo", ((450, 267),)),
+            ("lineTo", ((450, -71),)),
+            ("closePath", ()),
+        ]
+
+        actual = [
+            (op, tuple((otRound(pt[0]), otRound(pt[1])) for pt in args))
+            for op, args in actual
+        ]
+
+        assert actual == expected, (actual, expected)