' . $html . '
'); + + return array_values(unpack('N*', mb_convert_encoding($mpdf->drawnText[0], 'UTF-32BE', 'UTF-8'))); + } + + /** + * The mark the nested subtable does cover is still substituted, which is what the rule is for. The + * capital form has no codepoint of its own and is mapped into the Private Use Area as the subset + * is built, so it is read as "not the character written" rather than named. + */ + public function testAMarkTheNestedSubtableCoversIsStillSubstituted() + { + $drawn = $this->drawn([self::CAPITAL_A, self::GRAVE]); + + $this->assertCount(2, $drawn); + $this->assertSame(self::CAPITAL_A, $drawn[0]); + $this->assertNotSame(self::GRAVE, $drawn[1], 'the capital form of the grave was not substituted'); + } + + /** + * A mark it does not cover is left as itself. It was being given the record at Coverage Index 0 - + * the capital grave - so a macron written over a capital A was drawn as a grave accent. + */ + public function testAMarkTheNestedSubtableDoesNotCoverIsLeftAlone() + { + $this->assertSame([self::CAPITAL_A, self::MACRON], $this->drawn([self::CAPITAL_A, self::MACRON])); + } + + /** + * With a lowercase letter in front of it the context does not match at all, so even the mark the + * nested subtable does cover stays as written. + */ + public function testAMarkAfterALowercaseLetterIsLeftAlone() + { + $this->assertSame([self::SMALL_A, self::GRAVE], $this->drawn([self::SMALL_A, self::GRAVE])); + } + + /** + * The positioning half, and the shape GravityPDF/mpdf#102 was reported from. + * + * NotoSansGurmukhi-NestedCoverage-Subset is 5 glyphs of Noto Sans Gurmukhi 2.005 (OFL 1.1) whose + * `dist` chained context names a single adjustment at a Devanagari stress sign. That lookup has + * two subtables - the first covers the bindi and a conjunct, the second the two stress signs - and + * the bindi's value record was what the stress signs were positioned by. + * + * @return array the adjustment the mark of a two-character run was given + */ + private function markPosition($mark) + { + $mpdf = new PositionRecordingMpdf([ + 'mode' => 'utf-8', + 'fontDir' => [__DIR__ . '/../data/ttf'], + 'fontdata' => ['gurmukhinested' => [ + 'R' => 'NotoSansGurmukhi-NestedCoverage-Subset.ttf', + 'useOTL' => 0xFF, + ]], + 'default_font' => 'gurmukhinested', + ]); + $mpdf->WriteHTML('' . self::KA . $mark . '
'); + + return $mpdf->drawnPositions[0][1]; + } + + /** + * The udatta is raised above the letter by its own record in the second subtable, where the first + * subtable's record left it on the baseline and 150 units to the left. + */ + public function testAMarkIsPositionedByTheSubtableThatCoversIt() + { + $this->assertSame( + ['BaseWidth' => 622, 'XPlacement' => 602, 'YPlacement' => 275, 'XAdvanceL' => 602, 'XAdvanceR' => 602], + $this->markPosition(self::UDATTA) + ); + } + + /** + * The anudatta is the same the other way: its own record drops it below the letter, where the + * first subtable's put it on the baseline. + */ + public function testTheSecondMarkOfTheSameSubtableIsPositionedByItToo() + { + $this->assertSame( + ['BaseWidth' => 622, 'XPlacement' => 255, 'YPlacement' => -355, 'XAdvanceL' => 255, 'XAdvanceR' => 255], + $this->markPosition(self::ANUDATTA) + ); + } + + /** + * The bindi is the glyph the first subtable does cover, and the one whose record the other two + * were being given. It is positioned exactly as it was, so the guard turns away the glyphs the + * subtable does not cover without turning away the one it does. + */ + public function testTheGlyphTheFirstSubtableCoversIsPositionedAsItWas() + { + $this->assertSame( + ['BaseWidth' => 622, 'XPlacement' => 603, 'YPlacement' => 0, 'XAdvanceL' => 603, 'XAdvanceR' => 603], + $this->markPosition(self::BINDI) + ); + } + + /** + * Reading a Coverage at a glyph it does not hold is a warning per glyph per subtable under E_ALL, + * and the value it yields is an offset, so what follows it can be a deprecation as well. Asserted + * beside the positions, since an install running at production's error_reporting sees none of it - + * only a mark in the wrong place. + */ + public function testANestedLookupReadsNoCoverageItHasNot() + { + $raised = []; + + set_error_handler(function ($number, $message, $file, $line) use (&$raised) { + // Filtered to the shaper so a notice raised elsewhere in the render cannot fail this + if (false !== strpos($file, 'Otl.php')) { + $raised[] = sprintf('%s in %s:%d', $message, basename($file), $line); + } + + return true; + }); + + try { + foreach ([self::UDATTA, self::ANUDATTA, self::BINDI] as $mark) { + $this->markPosition($mark); + } + } finally { + restore_error_handler(); + } + + $this->assertSame([], $raised); + } + +} diff --git a/tests/Snapshots/NestedLookupCoverageSnapshotTest.php b/tests/Snapshots/NestedLookupCoverageSnapshotTest.php new file mode 100644 index 000000000..8fe19424a --- /dev/null +++ b/tests/Snapshots/NestedLookupCoverageSnapshotTest.php @@ -0,0 +1,223 @@ + 0x0300, + 'acute' => 0x0301, + 'circumflex' => 0x0302, + 'tilde' => 0x0303, + 'dieresis' => 0x0308, + ]; + + /** + * Marks it has no capital form of. Every one of these was drawn as the capital grave, because the + * subtable holds that at Coverage Index 0 and a missing index reads as 0. + */ + const UNCOVERED = [ + 'macron' => 0x0304, + 'overline' => 0x0305, + 'hook above' => 0x0309, + 'comma above' => 0x0313, + 'double overline' => 0x033F, + ]; + + /** U+0A15 GURMUKHI LETTER KA */ + const KA = 'ਕ'; + + /** U+0A02 GURMUKHI SIGN BINDI, the glyph the nested subtable does cover */ + const BINDI = 'ਂ'; + + /** U+0951 DEVANAGARI STRESS SIGN UDATTA, drawn above the letter */ + const UDATTA = '॑'; + + /** U+0952 DEVANAGARI STRESS SIGN ANUDATTA, drawn below it */ + const ANUDATTA = '॒'; + + /** + * @return string A unique identifier / name for the snapshot + */ + public function getId() + { + return 'nested-lookup-coverage'; + } + + /** + * Generate a PDF document by initializing the Mpdf object on $this->mpdf and + * loading it with content + * + * @return void + * @internal Don't call any $this->mpdf->Output*() method + */ + public function generatePdf() + { + $this->mpdf = $this->createMpdf($this->config()); + $this->mpdf->WriteHTML($this->style() . $this->markSamples() . $this->gurmukhiSamples()); + } + + /** + * DejaVu Sans is shipped and needs no registering. The Gurmukhi subset is 5 glyphs of Noto Sans + * Gurmukhi 2.005 (OFL 1.1) - the KA, the bindi, the two stress signs and the conjunct that keeps + * the nested lookup's first subtable at the two entries that make it index its Coverage. + */ + private function config() + { + return [ + 'mode' => 'utf-8', + 'fontDir' => [__DIR__ . '/../data/ttf'], + 'fontdata' => [ + 'gurmukhinested' => [ + 'R' => 'NotoSansGurmukhi-NestedCoverage-Subset.ttf', + 'useOTL' => 0xFF, + ], + ], + ]; + } + + private function style() + { + ob_start(); + ?> + + +DejaVu Sans has a capital form of some combining marks and not of others.' + . ' The lowercase column is the mark as written; the capital column is the form drawn over a' + . ' capital letter. Read down the second table: each mark should be its own, not the grave of' + . ' the first row above.
'; + + foreach (['a capital form' => self::COVERED, 'no capital form' => self::UNCOVERED] as $heading => $marks) { + $html .= '| ' . $label . ' U+' . sprintf('%04X', $mark) . ' | ' + . '' . sprintf('A&#x%04X;', $mark) . ' | ' + . '' . sprintf('a&#x%04X;', $mark) . ' |
The udatta sits above the letter and the anudatta below it. Both were given' + . ' the bindi\'s adjustment instead - on the baseline, and to the left of where the bindi' + . ' itself is drawn.
' + . '' . $text . '
'); + + return preg_split('//u', $mpdf->drawnText[0], -1, PREG_SPLIT_NO_EMPTY); + } + + /** + * The document only shows anything if the marks the nested substitution does not cover are drawn + * as themselves rather than as the capital grave. The capital forms have no codepoints of their + * own - they are mapped into the Private Use Area as the subset is built - so the samples are + * compared with each other rather than named. + */ + public function testTheMarksWithNoCapitalFormAreNotDrawnAsTheGrave() + { + $grave = $this->glyphsOf('À'); + + foreach (self::UNCOVERED as $label => $mark) { + $sample = $this->glyphsOf(sprintf('A&#x%04X;', $mark)); + $written = $this->glyphsOf(sprintf('a&#x%04X;', $mark)); + + $this->assertNotSame($grave[1], $sample[1], $label . ' is drawn as the capital grave'); + $this->assertSame($written[1], $sample[1], $label . ' over a capital is not the mark written'); + } + } + + /** + * The marks that do have a capital form still get it, which is what tells the guard apart from + * turning the rule off. Each is drawn as something other than the character written, and each as + * something other than the others. + */ + public function testTheMarksWithACapitalFormStillGetIt() + { + $drawn = []; + foreach (self::COVERED as $label => $mark) { + $sample = $this->glyphsOf(sprintf('A&#x%04X;', $mark)); + $written = $this->glyphsOf(sprintf('a&#x%04X;', $mark)); + + $this->assertNotSame($written[1], $sample[1], $label . ' was not given its capital form'); + $drawn[] = $sample[1]; + } + + $this->assertSame($drawn, array_unique($drawn), 'two capital forms are drawn as the same glyph'); + } +} diff --git a/tests/data/fontcache/NotoSansGurmukhi-NestedCoverage-Subset.json b/tests/data/fontcache/NotoSansGurmukhi-NestedCoverage-Subset.json new file mode 100644 index 000000000..969fd3591 --- /dev/null +++ b/tests/data/fontcache/NotoSansGurmukhi-NestedCoverage-Subset.json @@ -0,0 +1,100 @@ +{ + "_": "Generated by composer fontcache:update. See tests/Mpdf/Fonts/ParserGoldenMaster.php.", + "fullName": "NotoSansGurmukhi-Regular", + "mtx": { + "GSUBScriptLang": [], + "GSUBFeatures": [], + "GSUBLookups": [], + "GPOSScriptLang": { + "gur2": "DFLT " + }, + "GPOSFeatures": { + "gur2": { + "DFLT": { + "abvm": [ + 0 + ], + "dist": [ + 1 + ] + } + } + }, + "GPOSLookups": [ + { + "Type": 4, + "Flag": 0, + "SubtableCount": 1, + "Subtables": [ + 74 + ], + "MarkFilteringSet": "" + }, + { + "Type": 8, + "Flag": 0, + "SubtableCount": 2, + "Subtables": [ + 162, + 186 + ], + "MarkFilteringSet": "" + }, + { + "Type": 1, + "Flag": 0, + "SubtableCount": 2, + "Subtables": [ + 230, + 250 + ], + "MarkFilteringSet": "" + } + ], + "MarkGlyphSets": [], + "rtlPUAstr": "", + "haskernGPOS": false, + "hassmallcapsGSUB": false + }, + "cache": { + "GDEFdata.json": { + "GlyphClassBases": " 00A15", + "GlyphClassMarks": " 00951| 00952| 00A02| 0E000", + "GlyphClassLigatures": "", + "GlyphClassComponents": "", + "MarkGlyphSets": [], + "MarkAttachmentType": [] + }, + "GPOS.dat": "270 bytes, sha256 141fe74bac6028f61694f29b20070b0c62950a8ad4392743aa464aaacff0f0b6", + "GPOSdata.json": [ + [ + { + "2562": 0, + "57344": 1, + "2385": 2, + "2386": 3 + } + ], + [ + { + "2385": 0 + }, + { + "2386": 0 + } + ], + [ + { + "2562": 0, + "57344": 1 + }, + { + "2385": 0, + "2386": 1 + } + ] + ], + "GSUB.dat": "26 bytes, sha256 aa7ce2b45ba3a2c52647924a58315c984a0acb7958ba1d7b9aaab161ec333b84", + "GSUBdata.json": [] + } +} diff --git a/tests/data/otldump/NotoSansGurmukhi-NestedCoverage-Subset.txt b/tests/data/otldump/NotoSansGurmukhi-NestedCoverage-Subset.txt new file mode 100644 index 000000000..eff8c7183 --- /dev/null +++ b/tests/data/otldump/NotoSansGurmukhi-NestedCoverage-Subset.txt @@ -0,0 +1,17 @@ +