mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-19 14:45:29 +00:00
1061 lines
52 KiB
Python
1061 lines
52 KiB
Python
#!/usr/bin/env python
|
|
# License: GPL v3 Copyright: 2026, Kovid Goyal <kovid at kovidgoyal.net>
|
|
|
|
import array
|
|
import math
|
|
|
|
from kitty.fast_data_types import (
|
|
DECAWM,
|
|
parse_glyph_command,
|
|
parse_vg,
|
|
render_vg,
|
|
set_glyph_protocol_sprite_limits,
|
|
sprite_idx_to_pos,
|
|
test_render_line,
|
|
vg_live_glyph_memory,
|
|
vg_set_window_limits,
|
|
)
|
|
from kitty.fonts.render import setup_for_testing
|
|
|
|
from .base import BaseTest, draw_multicell, parse_bytes
|
|
from .fonts import FontBaseTest
|
|
|
|
|
|
class Dump(list):
|
|
def __call__(self, window_id, *a):
|
|
if a and a[0] == 'bytes':
|
|
return
|
|
self.append(a)
|
|
|
|
|
|
class TestGlyphProtocol(BaseTest):
|
|
def test_glyph_command_parsing(self):
|
|
def p(x):
|
|
return parse_glyph_command(('25a1;' + x).encode())
|
|
|
|
def ae(x, **expected):
|
|
expected.setdefault('fmt', '')
|
|
expected.setdefault('reply', 1)
|
|
if not expected.pop('placement_invalid', False):
|
|
expected.setdefault('fit', 'contain')
|
|
expected.setdefault('align', ('center', 'center'))
|
|
else:
|
|
expected['placement_invalid'] = True
|
|
self.ae(p(x), expected)
|
|
|
|
def err(x, msg):
|
|
with self.assertRaisesRegex(ValueError, msg):
|
|
parse_glyph_command(x.encode())
|
|
|
|
err('25a1', 'not a glyph protocol message')
|
|
err('25a2;s', 'not a glyph protocol message')
|
|
err('G25a1;s', 'not a glyph protocol message')
|
|
err('25a1;', 'invalid verb')
|
|
err('25a1;ss', 'invalid verb')
|
|
err('25a1;x', 'unknown verb')
|
|
err('25a1;S', 'unknown verb')
|
|
|
|
ae('s', verb='s')
|
|
ae('s;', verb='s')
|
|
ae('s;unknown=1;fmt=glyf', verb='s', fmt='glyf')
|
|
|
|
# query
|
|
ae('q;cp=e0a0', verb='q', cp=0xE0A0)
|
|
ae('q;cp=E0A0', verb='q', cp=0xE0A0)
|
|
ae('q;cp=100000', verb='q', cp=0x100000)
|
|
ae('q;cp=10ffff', verb='q', cp=0x10FFFF)
|
|
for bad in ('110000', 'd800', 'dfff', '', 'xyz', '123456789', '-1', ' 41'):
|
|
ae(f'q;cp={bad}', verb='q', cp=None)
|
|
ae('q;grapheme=1f468,200d,1f469', verb='q', grapheme=(0x1F468, 0x200D, 0x1F469))
|
|
ae('q;grapheme=' + ','.join(['41'] * 32), verb='q', grapheme=(0x41,) * 32)
|
|
ae('q;grapheme=' + ','.join(['41'] * 33), verb='q', grapheme=None)
|
|
ae('q;grapheme=41,,42', verb='q', grapheme=None)
|
|
ae('q;grapheme=41,d800', verb='q', grapheme=None)
|
|
ae('q;grapheme=', verb='q', grapheme=None)
|
|
ae('q;cp=41;grapheme=42', verb='q', cp=0x41, grapheme=(0x42,))
|
|
# fields that are not key=value pairs are ignored
|
|
ae('q;junk;cp=41', verb='q', cp=0x41)
|
|
|
|
# clear
|
|
ae('c', verb='c')
|
|
ae('c;cp=100001;reply=0', verb='c', cp=0x100001, reply=0)
|
|
ae('c;reply=2', verb='c', reply=2)
|
|
ae('c;reply=7', verb='c', reply=1)
|
|
ae('c;reply=', verb='c', reply=1)
|
|
|
|
# register, the payload is the last field, by position
|
|
ae('r', verb='r')
|
|
ae('r;', verb='r', payload=b'')
|
|
ae('r;payload', verb='r', payload=b'payload')
|
|
ae('r;cp=100000', verb='r', payload=b'cp=100000')
|
|
ae('r;cp=100000;fmt=glyf;AAA=', verb='r', cp=0x100000, fmt='glyf', payload=b'AAA=')
|
|
ae(
|
|
'r;cp=100000;fmt=vg;vb=0,0,24,24;fill=nonzero,fg:M0 0H24V24Z',
|
|
verb='r',
|
|
cp=0x100000,
|
|
fmt='vg',
|
|
vb=(0, 0, 24, 24),
|
|
payload=b'fill=nonzero,fg:M0 0H24V24Z',
|
|
)
|
|
ae('r;fmt=colrv0;x', verb='r', fmt='colrv0', payload=b'x')
|
|
ae('r;fmt=colrv1;x', verb='r', fmt='colrv1', payload=b'x')
|
|
ae('r;fmt=svg;x', verb='r', fmt='unknown', payload=b'x')
|
|
ae('r;cp=100000;;;x', verb='r', cp=0x100000, payload=b'x')
|
|
# last key wins
|
|
ae('r;fmt=glyf;fmt=vg;x', verb='r', fmt='vg', payload=b'x')
|
|
# ignored keys
|
|
ae('r;width=2;upm=1000;size=height;pad=0,0,0,0;x', verb='r', payload=b'x')
|
|
|
|
# placement
|
|
ae('r;vb=-1.5 2e1 , 3 .5;x', verb='r', vb=(-1.5, 20, 3, 0.5), payload=b'x')
|
|
ae('r;vb=0 0 1e6 1000000;x', verb='r', vb=(0, 0, 1e6, 1e6), payload=b'x')
|
|
for bad in (
|
|
'0,0,24',
|
|
'0,0,24,24,1',
|
|
'0,0,0,24',
|
|
'0,0,24,-1',
|
|
'0,,0,24,24',
|
|
'0,0,24,24 ',
|
|
'0,0,1.,24',
|
|
'1000001,0,1,1',
|
|
'0,0,1,1e7',
|
|
'a,b,c,d',
|
|
'0 0 1 1x',
|
|
'',
|
|
):
|
|
ae(f'r;vb={bad};x', verb='r', placement_invalid=True, payload=b'x')
|
|
ae('r;fit=cover;align=start,end;x', verb='r', fit='cover', align=('start', 'end'), payload=b'x')
|
|
ae('r;fit=stretch;x', verb='r', fit='stretch', payload=b'x')
|
|
for bad in ('fit=fill', 'fit=', 'align=center', 'align=center,baseline', 'align=start,end,', 'align=,'):
|
|
ae(f'r;{bad};x', verb='r', placement_invalid=True, payload=b'x')
|
|
# extreme aspect ratios
|
|
ae('r;vb=0 0 4096 1;x', verb='r', vb=(0, 0, 4096, 1), payload=b'x')
|
|
ae('r;vb=0 0 0.5 2048;x', verb='r', vb=(0, 0, 0.5, 2048), payload=b'x')
|
|
for bad in ('0 0 4097 1', '0 0 1 1e-6', '0 0 1e-45 1e-40'):
|
|
ae(f'r;vb={bad};x', verb='r', placement_invalid=True, payload=b'x')
|
|
# numbers with very many digits and large exponents
|
|
zeros = '0' * 200000
|
|
ae(f'r;vb=0.{zeros}1e200001,0,1,1;x', verb='r', vb=(1, 0, 1, 1), payload=b'x')
|
|
ae(f'r;vb=0.{zeros}1e2000000,0,1,1;x', verb='r', placement_invalid=True, payload=b'x')
|
|
ae(f'r;vb=1{zeros}e-2000000,0,1,1;x', verb='r', vb=(0, 0, 1, 1), payload=b'x')
|
|
ae(f'r;vb=1{zeros}e-200000,0,1,1;x', verb='r', vb=(1, 0, 1, 1), payload=b'x')
|
|
|
|
def test_glyph_command_via_parser(self):
|
|
s = self.create_screen()
|
|
d = Dump()
|
|
parse_bytes(s, b'\x1b_25a1;q;cp=41\x1b\\', d)
|
|
self.ae(d, [('glyph_command', {'verb': 'q', 'cp': 0x41, 'fmt': '', 'reply': 1, 'fit': 'contain', 'align': ('center', 'center')})])
|
|
d = Dump()
|
|
parse_bytes(s, b'\x1b_25a1;z\x1b\\', d)
|
|
self.ae(d, [('error', 'Ignoring APC escape code that is not a valid glyph protocol message: unknown verb')])
|
|
d = Dump()
|
|
parse_bytes(s, b'\x1b_2xyz\x1b\\', d)
|
|
self.ae(d, [('error', 'Ignoring APC escape code that is not a valid glyph protocol message: not a glyph protocol message')])
|
|
|
|
def test_glyph_support_and_query_replies(self):
|
|
s = self.create_screen()
|
|
|
|
def q(cmd, expected):
|
|
s.callbacks.wtcbuf = b''
|
|
parse_bytes(s, f'\x1b_25a1;{cmd}\x1b\\'.encode())
|
|
self.ae(s.callbacks.wtcbuf.decode(), ''.join(f'\x1b_25a1;{x}\x1b\\' for x in expected))
|
|
|
|
q('s', ['s;fmt=vg'])
|
|
# replies are sent in the order the requests arrive
|
|
q('s\x1b\\\x1b_25a1;q;cp=41', ['s;fmt=vg', 'q;cp=41;reason=unknown'])
|
|
q('q;cp=E0A0', ['q;cp=e0a0;reason=unknown'])
|
|
q('q;cp=100000', ['q;cp=100000;status='])
|
|
q('q;cp=1003ff', ['q;cp=1003ff;status='])
|
|
q('q;cp=100400', ['q;cp=100400;reason=unknown'])
|
|
q('q', ['q;reason=malformed_query'])
|
|
q('q;cp=d800', ['q;reason=malformed_query'])
|
|
q('q;cp=41;grapheme=42', ['q;reason=malformed_query'])
|
|
q('q;grapheme=41,d800', ['q;reason=malformed_query'])
|
|
q('q;grapheme=1F468,200d,1f469', ['q;grapheme=1f468,200d,1f469;reason=unsupported'])
|
|
q('q;grapheme=' + ','.join(['10ffff'] * 32), ['q;grapheme=' + ','.join(['10ffff'] * 32) + ';reason=unsupported'])
|
|
|
|
def test_vg_parsing(self):
|
|
vb = (0, 0, 24, 24)
|
|
|
|
def pv(payload, vb=vb):
|
|
return parse_vg(payload.encode(), vb)
|
|
|
|
def path(d, vb=vb):
|
|
return pv('fill=nonzero,fg:' + d, vb)['layers'][0]['path']
|
|
|
|
def bad(payload, reason='malformed_payload', msg='', vb=vb):
|
|
with self.assertRaisesRegex(ValueError, f'^{reason}: {msg}', msg=payload):
|
|
pv(payload, vb)
|
|
|
|
def badpath(d, reason='malformed_payload', msg=''):
|
|
bad('fill=nonzero,fg:' + d, reason, msg)
|
|
|
|
# numbers and separators
|
|
self.ae(path('M1 2'), 'M 1 2')
|
|
self.ae(path('M1,2'), 'M 1 2')
|
|
self.ae(path('M 1 , 2'), 'M 1 2')
|
|
self.ae(path('M-1-2'), 'M -1 -2')
|
|
self.ae(path('M.5.5'), 'M 0.5 0.5')
|
|
self.ae(path('M1.5.5'), 'M 1.5 0.5')
|
|
self.ae(path('M+1e1-1E-1'), 'M 10 -0.1')
|
|
self.ae(path('M0.1e+1 2'), 'M 1 2')
|
|
self.ae(path('M 1 2 '), 'M 1 2')
|
|
badpath('M1. 2', msg='invalid or missing number')
|
|
badpath('M1,,2')
|
|
badpath('M,1 2')
|
|
badpath('M1 2,')
|
|
badpath('M1 2,L3 4', msg='comma not followed by a number')
|
|
badpath('M1e 2')
|
|
badpath('M1 2 3')
|
|
badpath('M1 2 L')
|
|
badpath('M1 2 X3 4', msg='invalid path command')
|
|
badpath('M1 2Z3 4')
|
|
badpath('M1 1e39', 'outline_too_large')
|
|
badpath('M1 1e9999', 'outline_too_large')
|
|
self.ae(path('M1 1e-9999'), 'M 1 0')
|
|
bad('stroke=1/miter,fg:M0 0', msg='invalid stroke cap')
|
|
badpath('', msg='path data must start with a moveto')
|
|
badpath(' ', msg='path data must start with a moveto')
|
|
badpath('L1 2', msg='path data must start with a moveto')
|
|
|
|
# commands
|
|
self.ae(path('M0 0 1 1 2 2'), 'M 0 0 L 1 1 L 2 2')
|
|
self.ae(path('m1 1 1 1'), 'M 1 1 L 2 2')
|
|
self.ae(path('M1 1h2v3H0V0'), 'M 1 1 L 3 1 L 3 4 L 0 4 L 0 0')
|
|
self.ae(path('M1 1l1 1zl1 1'), 'M 1 1 L 2 2 Z M 1 1 L 2 2')
|
|
self.ae(path('M1 1l1 1zm1 1'), 'M 1 1 L 2 2 Z M 2 2')
|
|
self.ae(path('M0 0L1 1ZZz'), 'M 0 0 L 1 1 Z')
|
|
self.ae(path('M0 0Z'), 'M 0 0 Z')
|
|
self.ae(path('M0 0C1 1 2 2 3 3S5 5 6 6'), 'M 0 0 C 1 1 2 2 3 3 C 4 4 5 5 6 6')
|
|
self.ae(path('M0 0c1 1 2 2 3 3s2 2 3 3'), 'M 0 0 C 1 1 2 2 3 3 C 4 4 5 5 6 6')
|
|
self.ae(path('M1 1S2 2 3 3'), 'M 1 1 C 1 1 2 2 3 3')
|
|
self.ae(path('M0 0Q1 1 2 0T4 0'), 'M 0 0 Q 1 1 2 0 Q 3 -1 4 0')
|
|
self.ae(path('M0 0q1 1 2 0t2 0t2 0'), 'M 0 0 Q 1 1 2 0 Q 3 -1 4 0 Q 5 1 6 0')
|
|
self.ae(path('M1 1T3 3'), 'M 1 1 Q 1 1 3 3')
|
|
self.ae(path('M0 0C1 1 2 2 3 3T5 5'), 'M 0 0 C 1 1 2 2 3 3 Q 3 3 5 5')
|
|
|
|
# arcs
|
|
self.ae(path('M0 0A0 5 0 0 1 10 0'), 'M 0 0 L 10 0')
|
|
self.ae(path('M1 1A5 5 0 0 1 1 1'), 'M 1 1')
|
|
self.ae(path('M0 0a5 5 0 1010 0'), path('M0 0A5 5 0 1 0 10 0'))
|
|
self.ae(path('M0 0a5,5,0,1,0,10,0'), path('M0 0A5 5 0 1 0 10 0'))
|
|
# half circle: two quarter turns
|
|
self.ae(path('M2 12A10 10 0 0 1 22 12').count('C'), 2)
|
|
# radii that are too small are scaled up to a half circle
|
|
self.ae(path('M2 12A1 1 0 0 1 22 12'), path('M2 12A10 10 0 0 1 22 12'))
|
|
# three quarters of a circle
|
|
self.ae(path('M12 2A10 10 0 1 1 2 12').count('C'), 3)
|
|
# less than a quarter
|
|
self.ae(path('M12 2A10 10 0 0 1 19.07 4.93').count('C'), 1)
|
|
p = path('M12 2A10 10 0 0 1 22 12').split()
|
|
self.ae(p[-2:], ['22', '12'])
|
|
self.ae(len(p), 3 + 7)
|
|
# Control points of a quarter circle are at 4/3*tan(pi/8)*r from the end points
|
|
k = 4 / 3 * 0.41421356237 * 10
|
|
self.assertAlmostEqual(float(p[4]), 12 + k, places=3)
|
|
self.assertAlmostEqual(float(p[7]), 12 - k, places=3)
|
|
# drawing after an arc of identical endpoints
|
|
self.ae(path('M1 1A5 5 0 0 1 1 1L2 2'), 'M 1 1 L 2 2')
|
|
badpath('M0 0A5 5 0 2 0 10 0', msg='invalid arc flag')
|
|
badpath('M0 0A5 5 0 1 0 10', msg='invalid or missing number')
|
|
|
|
# layers
|
|
r = pv(
|
|
'fill=evenodd,#FF000080:M0 0|stroke=2,fg@0.5:M0 0|stroke=1.5/butt/miter10.5,#00ff00:M0 0|stroke=1/square/bevel,fg:M0 0|'
|
|
'clip=1,nonzero,m 1 0 0 1 2 3:M0 0|'
|
|
'fill=nonzero,fg,m2 0 0 2 0 0:M0 0'
|
|
)
|
|
self.assertTrue(r['uses_fg'])
|
|
self.assertTrue(r['uses_fixed_color'])
|
|
l0, l1, l2, l3, l4, l5 = r['layers']
|
|
self.ae(l0['rule'], 'evenodd')
|
|
self.ae(l0['paint'][:3], (1, 0, 0))
|
|
self.assertAlmostEqual(l0['paint'][3], 128 / 255)
|
|
self.ae(l1, {'kind': 'stroke', 'path': 'M 0 0', 'matrix': None, 'paint': 'fg@0.5', 'width': 2, 'cap': 'round', 'join': 'round', 'miter_limit': 4})
|
|
self.ae((l2['cap'], l2['join'], l2['miter_limit'], l2['width']), ('butt', 'miter', 10.5, 1.5))
|
|
self.ae((l3['cap'], l3['join']), ('square', 'bevel'))
|
|
self.ae(l4, {'kind': 'clip', 'path': 'M 0 0', 'matrix': (1, 0, 0, 1, 2, 3), 'rule': 'nonzero', 'clip_count': 1})
|
|
self.ae(l5['matrix'], (2, 0, 0, 2, 0, 0))
|
|
self.assertFalse(pv('fill=nonzero,#000000:M0 0')['uses_fg'])
|
|
self.assertFalse(pv('fill=nonzero,fg:M0 0')['uses_fixed_color'])
|
|
self.ae(pv('stroke=1/round/miter,fg:M0 0')['layers'][0]['miter_limit'], 4)
|
|
self.ae(pv('stroke=1/butt/miter1,fg:M0 0')['layers'][0]['miter_limit'], 1)
|
|
for x in (
|
|
'stroke=0,fg',
|
|
'stroke=-1,fg',
|
|
'stroke=1/flat,fg',
|
|
'stroke=1/round/sharp,fg',
|
|
'stroke=1/round/miter0.5,fg',
|
|
'stroke=1/round/miter1001,fg',
|
|
'stroke=1/round/miter/,fg',
|
|
'stroke=1',
|
|
'stroke=1/,fg',
|
|
'fill=nonzero',
|
|
'fill=winding,fg',
|
|
'fill=nonzero,fg,',
|
|
'fill=nonzero,fg,m',
|
|
'fill=nonzero,fg,m 1 0 0 1 0',
|
|
'fill=nonzero,fg,m 1 0 0 1 0 0 1',
|
|
'fill=nonzero,fg ,m 1 0 0 1 0 0',
|
|
'fill=nonzero,fg, m 1 0 0 1 0 0',
|
|
'fill=nonzero,fgx',
|
|
'fill=nonzero,fg@',
|
|
'fill=nonzero,fg@1.5',
|
|
'fill=nonzero,fg@-0.5',
|
|
'fill=nonzero,#fff',
|
|
'fill=nonzero,#fffffff',
|
|
'fill=nonzero,#ff00ff00f',
|
|
'fill=nonzero,#gggggg',
|
|
'fill=nonzero,red',
|
|
'blur=1,fg',
|
|
'clip=0,nonzero',
|
|
'clip=128,nonzero',
|
|
'clip=1.5,nonzero',
|
|
'clip=1',
|
|
'clip=1,fg',
|
|
'fill=nonzero,fg,m 0 0 0 0 0 0',
|
|
'fill=nonzero,fg,m 4097 0 0 1 0 0',
|
|
'fill=nonzero,fg,m 1 0 0 0.0002 0 0',
|
|
'stroke=25,fg',
|
|
'stroke=13,fg,m 2 0 0 2 0 0',
|
|
):
|
|
bad(x + ':M0 0')
|
|
self.ae(len(pv('stroke=24,fg:M0 0|stroke=6,fg,m 4 0 0 1 0 0:M0 0|fill=nonzero,fg,m 4096 0 0 1 0 0:M0 0')['layers']), 3)
|
|
bad('fill=nonzero,fg', msg='layer has no path data')
|
|
bad('fill=nonzero,fg:M0 0|', msg='layer has no path data')
|
|
bad('fill=nonzero,fg:M0 0\tL1 1', msg='payload contains invalid characters')
|
|
bad('fill=nonzero,fg:M0 0\x7fL1 1', msg='payload contains invalid characters')
|
|
|
|
# clips
|
|
self.ae(len(pv('clip=2,evenodd:M0 0|fill=nonzero,fg:M0 0|stroke=1,fg:M0 0|clip=1,nonzero:M0 0|fill=nonzero,fg:M0 0')['layers']), 5)
|
|
bad('clip=2,evenodd:M0 0|fill=nonzero,fg:M0 0', msg='clip layer applies to layers that do not exist')
|
|
bad('clip=2,evenodd:M0 0|clip=1,nonzero:M0 0|fill=nonzero,fg:M0 0', msg='clip layers cannot be clipped')
|
|
bad('fill=nonzero,fg:M0 0|clip=1,nonzero:M0 0')
|
|
|
|
# gradients
|
|
g = pv('fill=nonzero,lin(0 0 24 0 / 0 fg / 0.5 fg@0.5 / 1 #0000ff):M0 0')['layers'][0]['paint']
|
|
self.ae(g, {'type': 'lin', 'params': (0, 0, 24, 0), 'spread': 'pad', 'matrix': None, 'stops': ((0, 'fg'), (0.5, 'fg@0.5'), (1, (0, 0, 1, 1)))})
|
|
g = pv('fill=nonzero,rad(1,2,0,3,4,5 repeat m 1 0 0 1 0 0/0 fg/0 #000000):M0 0')['layers'][0]['paint']
|
|
self.ae(g, {'type': 'rad', 'params': (1, 2, 0, 3, 4, 5), 'spread': 'repeat', 'matrix': (1, 0, 0, 1, 0, 0), 'stops': ((0, 'fg'), (0, (0, 0, 0, 1)))})
|
|
g = pv('fill=nonzero,lin(0 0 1 1 reflect/0 fg/1 fg),m 2 0 0 2 0 0:M0 0')['layers'][0]
|
|
self.ae((g['paint']['spread'], g['matrix']), ('reflect', (2, 0, 0, 2, 0, 0)))
|
|
self.assertTrue(pv('stroke=1,lin(0 0 1 1 / 0 #000000 / 1 #ffffff):M0 0')['uses_fixed_color'])
|
|
stops = ' '.join(f'/ {i / 15} fg' for i in range(16))
|
|
self.ae(len(pv(f'fill=nonzero,lin(0 0 1 1 {stops}):M0 0')['layers'][0]['paint']['stops']), 16)
|
|
bad(f'fill=nonzero,lin(0 0 1 1 {stops} / 1 fg):M0 0', 'outline_too_large', 'too many gradient stops')
|
|
for x in (
|
|
'lin(0 0 1 1 / 0 fg)',
|
|
'lin(0 0 1 / 0 fg / 1 fg)',
|
|
'lin(0 0 1 1 / 0 fg / 1 fg',
|
|
'lin(0 0 1 1 / 1 fg / 0 fg)',
|
|
'lin(0 0 1 1 / 0 fg / 1.5 fg)',
|
|
'lin(0 0 1 1 / -0.5 fg / 1 fg)',
|
|
'lin(0 0 1 1 / 0fg / 1 fg)',
|
|
'lin(0 0 1 1 / 0 lin(0 0 1 1 / 0 fg / 1 fg) / 1 fg)',
|
|
'lin(0 0 1 1 mirror / 0 fg / 1 fg)',
|
|
'lin(0 0 1 1, / 0 fg / 1 fg)',
|
|
'lin(0 0 1 1 m 1 0 0 1 0 / 0 fg / 1 fg)',
|
|
'lin(0 0 1 1 m 0 0 0 0 0 0 / 0 fg / 1 fg)',
|
|
'rad(0 0 -1 0 0 1 / 0 fg / 1 fg)',
|
|
'rad(0 0 0 0 0 -1 / 0 fg / 1 fg)',
|
|
'rad(0 0 0 0 0 / 0 fg / 1 fg)',
|
|
'lin(0 0 1 1 / 0 fg / 1 fg) ',
|
|
'lin(0 0 1 1 / 0 fg / 1 fg)x',
|
|
'lin (0 0 1 1 / 0 fg / 1 fg)',
|
|
):
|
|
bad(f'fill=nonzero,{x}:M0 0')
|
|
|
|
# limits
|
|
self.ae(path('M-24-24L48 48'), 'M -24 -24 L 48 48')
|
|
self.ae(path('M0 0L50 54', vb=(2, 6, 24, 24)), 'M 0 0 L 50 54')
|
|
badpath('M0 0L48.01 0', 'outline_too_large', 'path point too far outside the viewBox')
|
|
badpath('M0 0C0 -24.01 0 0 0 0', 'outline_too_large', 'path point too far outside the viewBox')
|
|
bad('fill=nonzero,fg,m 2 0 0 2 0 0:M0 0L24.01 0', 'outline_too_large', 'path point too far outside the viewBox')
|
|
self.ae(len(pv('fill=nonzero,fg,m 2 0 0 2 0 0:M0 0L24 0')['layers']), 1)
|
|
# the viewBox size is the larger dimension
|
|
self.ae(path('M0 0L0 -48', vb=(0, 0, 48, 8)), 'M 0 0 L 0 -48')
|
|
# segments: movetos, lines, curves and closes each count one
|
|
self.ae(len(path('M0 0' + 'L1 1' * 2047).split()), 3 + 2047 * 3)
|
|
badpath('M0 0' + 'L1 1' * 2048, 'outline_too_large', 'too many path segments')
|
|
badpath('M0 0' + 'L0 0Z' * 1024, 'outline_too_large', 'too many path segments')
|
|
self.ae(path('M0 0' + 'L0 0' * 2046 + 'Z' * 5000).count('Z'), 1)
|
|
# the implied moveto after Z counts
|
|
badpath('M0 0' + 'ZL0 0' * 1024, 'outline_too_large', 'too many path segments')
|
|
# an arc counts as its cubics
|
|
path('M0 0' + 'L1 1' * 2045 + 'A10 10 0 0 1 21 1')
|
|
badpath('M0 0' + 'L1 1' * 2046 + 'A10 10 0 0 1 21 1', 'outline_too_large', 'too many path segments')
|
|
# and segments are counted across layers
|
|
badpath('M0 0' + 'L1 1' * 1023 + '|fill=nonzero,fg:M0 0' + 'L1 1' * 1024, 'outline_too_large', 'too many path segments')
|
|
# path length: 64 viewBox sizes
|
|
self.ae(len(path('M0 0' + 'H24H0' * 32).split()), 3 + 64 * 3)
|
|
badpath('M0 0' + 'H24H0' * 32 + 'H0.1', 'outline_too_large', 'path too long')
|
|
badpath('M0 0' + 'H24H0' * 31 + 'H24V24Z', 'outline_too_large', 'path too long')
|
|
# curves count the length of their control polygon
|
|
path('M0 0' + 'C0 24 24 24 24 0C24 24 0 24 0 0' * 10)
|
|
badpath('M0 0' + 'C0 24 24 24 24 0C24 24 0 24 0 0' * 11, 'outline_too_large', 'path too long')
|
|
# strokes add their width for every segment, moveto included
|
|
pv('stroke=4,fg:M0 0' + 'H24H0' * 27 + 'H16')
|
|
bad('stroke=4,fg:M0 0' + 'H24H0' * 27 + 'H16.1', 'outline_too_large', 'path too long')
|
|
# lengths are measured after the layer matrix
|
|
pv('fill=nonzero,fg,m 2 0 0 2 0 0:M0 0' + 'H12H0' * 32)
|
|
bad('fill=nonzero,fg,m 2 0 0 2 0 0:M0 0' + 'H12H0' * 32 + 'H0.1', 'outline_too_large', 'path too long')
|
|
# layers
|
|
self.ae(len(pv('|'.join(['fill=nonzero,fg:M0 0'] * 128))['layers']), 128)
|
|
bad('|'.join(['fill=nonzero,fg:M0 0'] * 129), 'outline_too_large', 'too many layers')
|
|
# payload size
|
|
bad('fill=nonzero,fg:M0 0' + ' ' * 32 * 1024, 'outline_too_large', 'payload too large')
|
|
|
|
def test_glyph_registration(self):
|
|
s = self.create_screen()
|
|
|
|
def send(cmd, *expected):
|
|
s.callbacks.wtcbuf = b''
|
|
parse_bytes(s, f'\x1b_25a1;{cmd}\x1b\\'.encode())
|
|
self.ae(s.callbacks.wtcbuf.decode(), ''.join(f'\x1b_25a1;{x}\x1b\\' for x in expected))
|
|
|
|
icon = 'fill=nonzero,fg:M0 0H24V24Z'
|
|
send(f'r;cp=100000;fmt=vg;vb=0 0 24 24;{icon}', 'r;cp=100000;status=0')
|
|
send('q;cp=100000', 'q;cp=100000;status=glossary')
|
|
send('q;cp=100001', 'q;cp=100001;status=')
|
|
send(f'r;cp=1003ff;fmt=vg;vb=0 0 24 24;fit=cover;align=start,end;reply=2;{icon}')
|
|
send('q;cp=1003ff', 'q;cp=1003ff;status=glossary')
|
|
# failures
|
|
send(f'r;cp=e0a0;fmt=vg;vb=0 0 24 24;{icon}', 'r;cp=e0a0;status=1;reason=out_of_namespace')
|
|
send(f'r;cp=100400;fmt=vg;vb=0 0 24 24;{icon}', 'r;cp=100400;status=1;reason=out_of_namespace')
|
|
send(f'r;cp=d800;fmt=vg;vb=0 0 24 24;{icon}', 'r;status=1;reason=out_of_namespace')
|
|
send(f'r;fmt=vg;vb=0 0 24 24;{icon}', 'r;status=1;reason=out_of_namespace')
|
|
send('r;cp=100002;AAAA', 'r;cp=100002;status=1;reason=unsupported_format')
|
|
for fmt in ('glyf', 'colrv0', 'colrv1', 'svg'):
|
|
send(f'r;cp=100002;fmt={fmt};AAAA', 'r;cp=100002;status=1;reason=unsupported_format')
|
|
send(f'r;cp=100002;fmt=vg;{icon}', 'r;cp=100002;status=1;reason=malformed_payload')
|
|
send(f'r;cp=100002;fmt=vg;vb=0 0 0 24;{icon}', 'r;cp=100002;status=1;reason=malformed_payload')
|
|
send(f'r;cp=100002;fmt=vg;vb=0 0 24 24;align=center,baseline;{icon}', 'r;cp=100002;status=1;reason=malformed_payload')
|
|
send('r;cp=100002;fmt=vg;vb=0 0 24 24;fill=nonzero,fg:L0 0', 'r;cp=100002;status=1;reason=malformed_payload')
|
|
send('r;cp=100002;fmt=vg;vb=0 0 24 24;fill=nonzero,fg:M0 0L100 0', 'r;cp=100002;status=1;reason=outline_too_large')
|
|
send('r;cp=100002;fmt=vg;vb=0 0 24 24;fill=nonzero,fg:M0 0' + ' ' * (32 * 1024), 'r;cp=100002;status=1;reason=payload_too_large')
|
|
send('r;cp=100002;fmt=vg;vb=0 0 24 24;reply=2;fill=nonzero,fg:L0 0', 'r;cp=100002;status=1;reason=malformed_payload')
|
|
send('r;cp=100002;fmt=vg;vb=0 0 24 24;reply=0;fill=nonzero,fg:L0 0')
|
|
send('q;cp=100002', 'q;cp=100002;status=')
|
|
# a failed registration does not affect an existing one
|
|
send('r;cp=100000;fmt=vg;vb=0 0 24 24;fill=nonzero,fg:L0 0', 'r;cp=100000;status=1;reason=malformed_payload')
|
|
send('q;cp=100000', 'q;cp=100000;status=glossary')
|
|
# clear
|
|
send('c;cp=100000', 'c;cp=100000;status=0')
|
|
send('q;cp=100000', 'q;cp=100000;status=')
|
|
send('c;cp=100000;reply=2')
|
|
send('c;cp=100000;reply=0')
|
|
send('c;cp=41', 'c;cp=41;status=1;reason=out_of_namespace')
|
|
send('c;cp=zz', 'c;status=1;reason=out_of_namespace')
|
|
send('c;cp=41;reply=0')
|
|
send('q;cp=1003ff', 'q;cp=1003ff;status=glossary')
|
|
send('c', 'c;status=0')
|
|
send('q;cp=1003ff', 'q;cp=1003ff;status=')
|
|
# RIS clears registrations
|
|
send(f'r;cp=100005;fmt=vg;vb=0 0 24 24;reply=0;{icon}')
|
|
send('q;cp=100005', 'q;cp=100005;status=glossary')
|
|
parse_bytes(s, b'\x1bc')
|
|
send('q;cp=100005', 'q;cp=100005;status=')
|
|
# registrations are shared between the main and alternate screens but not between screens
|
|
send(f'r;cp=100005;fmt=vg;vb=0 0 24 24;reply=0;{icon}')
|
|
parse_bytes(s, b'\x1b[?1049h')
|
|
send('q;cp=100005', 'q;cp=100005;status=glossary')
|
|
parse_bytes(s, b'\x1b[?1049l')
|
|
s2 = self.create_screen()
|
|
s2.callbacks.wtcbuf = b''
|
|
parse_bytes(s2, b'\x1b_25a1;q;cp=100005\x1b\\')
|
|
self.ae(s2.callbacks.wtcbuf, b'\x1b_25a1;q;cp=100005;status=\x1b\\')
|
|
|
|
def test_vg_parsing_robustness(self):
|
|
import random
|
|
|
|
rng = random.Random(1234)
|
|
valid = [
|
|
'fill=nonzero,fg:M0 0H24V24Z',
|
|
'stroke=2/butt/miter10,lin(0 0 24 0 reflect m 1 0 0 1 0 0 / 0 fg / 1 #ff000080):M2 2a10 10 0 0 1 20 0c1 1 2 2 3 3s1 1 2 2q1 1 2 2t2 2',
|
|
'clip=1,evenodd,m 1 0 0 1 0 0:M0 0h24v24h-24z|fill=nonzero,rad(1 2 0 12 12 10 / 0 fg@0.5 / 1 #00ff00):M12 2A10 10 0 1 1 11.99 2Z',
|
|
]
|
|
alphabet = 'MmLlHhVvCcSsQqTtAaZz0123456789.,-+eE /|:=#()@fgnonzerovdlicprtsk'
|
|
for i in range(4000):
|
|
if i % 2:
|
|
p = list(rng.choice(valid))
|
|
for _ in range(rng.randint(1, 4)):
|
|
op = rng.randint(0, 2)
|
|
pos = rng.randint(0, len(p))
|
|
if op == 0 and pos < len(p):
|
|
del p[pos]
|
|
elif op == 1:
|
|
p.insert(pos, rng.choice(alphabet))
|
|
elif pos < len(p):
|
|
p[pos] = rng.choice(alphabet)
|
|
payload = ''.join(p)
|
|
else:
|
|
payload = ''.join(rng.choice(alphabet) for _ in range(rng.randint(0, 80)))
|
|
try:
|
|
parse_vg(payload.encode(), (0, 0, 24, 24))
|
|
except ValueError as e:
|
|
self.assertRegex(str(e), '^(malformed_payload|outline_too_large): ')
|
|
|
|
def test_vg_rendering(self):
|
|
V = (0, 0, 24, 24)
|
|
|
|
def r(payload, w=24, h=24, vb=V, **kw):
|
|
return render_vg(payload.encode(), vb, w, h, **kw)
|
|
|
|
def mask(payload, w=24, h=24, vb=V, **kw):
|
|
ans = r(payload, w, h, vb, **kw)
|
|
self.assertIsNone(ans['color'])
|
|
return ans['fg']
|
|
|
|
def area(m):
|
|
return sum(m) / 255
|
|
|
|
def at(m, x, y, w=24):
|
|
return m[y * w + x]
|
|
|
|
# Simple fills
|
|
self.ae(set(mask('fill=nonzero,fg:M0 0H24V24H0Z')), {255})
|
|
self.ae(set(mask('fill=nonzero,fg:M0 0H24V24H0Z', 7, 13, fit='stretch')), {255})
|
|
m = mask('fill=nonzero,fg:M0 0H12.5V24H0Z')
|
|
self.ae({at(m, x, y) for x in range(12) for y in range(24)}, {255})
|
|
self.ae({at(m, x, y) for x in range(13, 24) for y in range(24)}, {0})
|
|
self.ae({at(m, 12, y) for y in range(24)}, {128})
|
|
# horizontal edges have coverage quantized to the sub-scanlines
|
|
m = mask('fill=nonzero,fg:M0 0H24V12.5H0Z')
|
|
self.ae({at(m, x, 12) for x in range(24)}, {128})
|
|
# open subpaths are closed for filling
|
|
self.ae(mask('fill=nonzero,fg:M0 0H24V24H0'), mask('fill=nonzero,fg:M0 0H24V24H0Z'))
|
|
# nothing to fill
|
|
self.ae(set(mask('fill=nonzero,fg:M0 0L24 24')), {0})
|
|
self.ae(set(mask('fill=nonzero,fg:M0 0')), {0})
|
|
|
|
# Circle area
|
|
sz = 120
|
|
m = mask('fill=nonzero,fg:M12 2A10 10 0 1 1 12 22A10 10 0 1 1 12 2Z', sz, sz)
|
|
expected = math.pi * (10 * sz / 24) ** 2
|
|
self.assertLess(abs(area(m) - expected) / expected, 0.002)
|
|
|
|
# Fill rules
|
|
same_dir = 'M2 2H22V22H2ZM7 7H17V17H7Z'
|
|
opposite_dir = 'M2 2H22V22H2ZM7 7V17H17V7Z'
|
|
self.ae(area(mask('fill=evenodd,fg:' + same_dir)), 400 - 100)
|
|
self.ae(area(mask('fill=nonzero,fg:' + same_dir)), 400)
|
|
self.ae(area(mask('fill=nonzero,fg:' + opposite_dir)), 400 - 100)
|
|
self.ae(area(mask('fill=evenodd,fg:' + opposite_dir)), 400 - 100)
|
|
# self intersecting path
|
|
self.ae(area(mask('fill=evenodd,fg:M0 0H24V24H0ZM0 0H24V24H0Z')), 0)
|
|
self.ae(area(mask('fill=nonzero,fg:M0 0H24V24H0ZM0 0V24H24V0Z')), 0)
|
|
|
|
# Placement
|
|
sq = 'fill=nonzero,fg:M0 0H24V24H0Z'
|
|
|
|
def columns(m, w):
|
|
return [x for x in range(w) if m[x] == 255]
|
|
|
|
self.ae(columns(mask(sq, 48, 24), 48), list(range(12, 36)))
|
|
self.ae(columns(mask(sq, 48, 24, align=('start', 'center')), 48), list(range(24)))
|
|
self.ae(columns(mask(sq, 48, 24, align=('end', 'center')), 48), list(range(24, 48)))
|
|
self.ae(set(mask(sq, 48, 24, fit='cover')), {255})
|
|
self.ae(set(mask(sq, 48, 24, fit='stretch')), {255})
|
|
m = mask(sq, 24, 48, align=('center', 'start'))
|
|
self.ae([y for y in range(48) if m[y * 24] == 255], list(range(24)))
|
|
m = mask(sq, 24, 48, align=('center', 'end'))
|
|
self.ae([y for y in range(48) if m[y * 24] == 255], list(range(24, 48)))
|
|
# cover crops, aligning picks the visible part
|
|
m = mask('fill=nonzero,fg:M0 0H12V24H0Z', 24, 48, fit='cover', align=('start', 'center'))
|
|
self.ae(set(m), {255})
|
|
m = mask('fill=nonzero,fg:M0 0H12V24H0Z', 24, 48, fit='cover', align=('end', 'center'))
|
|
self.ae(set(m), {0})
|
|
# the viewBox origin
|
|
self.ae(mask('fill=nonzero,fg:M10 10H34V34H10Z', vb=(10, 10, 24, 24)), mask(sq))
|
|
# ink outside the viewBox but inside the area is drawn, as SVG clips at the viewport
|
|
m = mask('fill=nonzero,fg:M-12 0H36V24H-12Z', 48, 24)
|
|
self.ae(set(m), {255})
|
|
# and ink outside the area is clipped
|
|
self.ae(area(mask('fill=nonzero,fg:M-24 -24H48V48H-24Z')), 24 * 24)
|
|
|
|
# Layer matrix
|
|
self.ae(area(mask('fill=nonzero,fg,m 0.5 0 0 0.5 0 0:M0 0H24V24H0Z')), 144)
|
|
self.ae(area(mask('fill=nonzero,fg,m 1 0 0 1 12 0:M0 0H24V24H0Z')), 288)
|
|
# a matrix with negative determinant reverses orientation, which does not affect filling
|
|
self.ae(area(mask('fill=nonzero,fg,m -1 0 0 1 24 0:M0 0H12V24H0Z')), 288)
|
|
|
|
# Strokes
|
|
def close(a, b, tolerance=0.01):
|
|
self.assertLess(abs(a - b) / b, tolerance, f'{a} != {b}')
|
|
|
|
sz = 240
|
|
scale = sz / 24
|
|
# butt caps
|
|
close(area(mask('stroke=2/butt,fg:M4 12H20', sz, sz)), 2 * 16 * scale**2)
|
|
# square caps extend by half the width at both ends
|
|
close(area(mask('stroke=2/square,fg:M4 12H20', sz, sz)), 2 * 18 * scale**2)
|
|
# round caps add a circle
|
|
close(area(mask('stroke=2/round,fg:M4 12H20', sz, sz)), (2 * 16 + math.pi) * scale**2)
|
|
# stroke is centered on the path
|
|
m = mask('stroke=2/butt,fg:M0 12H24', 24, 24)
|
|
self.ae([m[y * 24 + 5] for y in range(24)], [0] * 11 + [255] * 2 + [0] * 11)
|
|
# a closed rectangle: each side plus miter joins fill the corners
|
|
close(area(mask('stroke=2/butt/miter,fg:M4 4H20V20H4Z', sz, sz)), (18 * 18 - 14 * 14) * scale**2)
|
|
# bevel joins cut off the corners: 4 triangles of 1 x 1 / 2
|
|
close(area(mask('stroke=2/butt/bevel,fg:M4 4H20V20H4Z', sz, sz)), (18 * 18 - 14 * 14 - 2) * scale**2)
|
|
# round joins: quarter circles at the corners
|
|
close(area(mask('stroke=2/butt/round,fg:M4 4H20V20H4Z', sz, sz)), (18 * 18 - 14 * 14 - 4 + math.pi) * scale**2)
|
|
# an unclosed rectangle has caps instead of a join at its start
|
|
close(area(mask('stroke=2/butt/miter,fg:M4 4H20V20H4V4', sz, sz)), (18 * 18 - 14 * 14 - 1) * scale**2)
|
|
# miter limit: a sharp angle has a miter only if the limit allows it
|
|
sharp = 'M2 20L12 4L22 20'
|
|
bevelled = area(mask(f'stroke=2/butt/bevel,fg:{sharp}', sz, sz))
|
|
self.ae(area(mask(f'stroke=2/butt/miter1,fg:{sharp}', sz, sz)), bevelled)
|
|
self.assertGreater(area(mask(f'stroke=2/butt/miter10,fg:{sharp}', sz, sz)), bevelled + scale**2)
|
|
# zero length subpaths are dots with round and square caps only
|
|
close(area(mask('stroke=4/round,fg:M12 12Z', sz, sz)), math.pi * 4 * scale**2)
|
|
close(area(mask('stroke=4/round,fg:M12 12L12 12', sz, sz)), math.pi * 4 * scale**2)
|
|
close(area(mask('stroke=4/square,fg:M12 12Z', sz, sz)), 16 * scale**2)
|
|
self.ae(area(mask('stroke=4/butt,fg:M12 12Z', sz, sz)), 0)
|
|
# a moveto alone draws nothing
|
|
self.ae(area(mask('stroke=4/round,fg:M12 12', sz, sz)), 0)
|
|
# a non-uniform matrix gives an elliptical pen, here a vertical line
|
|
# stroked with a pen 3 times wider horizontally
|
|
close(area(mask('stroke=2/butt,fg,m 3 0 0 1 -24 0:M12 4V20', sz, sz)), 6 * 16 * scale**2)
|
|
# stroked curves: a semicircle of radius 8
|
|
close(area(mask('stroke=2/butt,fg:M4 12A8 8 0 0 1 20 12', sz, sz)), math.pi / 2 * (9 * 9 - 7 * 7) * scale**2)
|
|
|
|
# Colors
|
|
ans = r('fill=nonzero,#ff800080:M0 0H24V24H0Z')
|
|
self.assertIsNone(ans['fg'])
|
|
self.ae(set(zip(*[iter(ans['color'])] * 4)), {(128, 64, 0, 128)})
|
|
ans = r('fill=nonzero,fg@0.5:M0 0H24V24H0Z')
|
|
self.assertIsNone(ans['color'])
|
|
self.ae(set(ans['fg']), {128})
|
|
# mixed: fg layer under a half transparent red layer
|
|
ans = r('fill=nonzero,fg:M0 0H24V24H0Z|fill=nonzero,#ff000080:M0 0H24V24H0Z')
|
|
self.ae(set(zip(*[iter(ans['color'])] * 4)), {(128, 0, 0, 255)})
|
|
self.ae(set(ans['fg']), {127})
|
|
# fg layer over a red layer
|
|
ans = r('fill=nonzero,#ff0000:M0 0H24V24H0Z|fill=nonzero,fg@0.25:M0 0H24V24H0Z')
|
|
self.ae(set(zip(*[iter(ans['color'])] * 4)), {(191, 0, 0, 255)})
|
|
self.ae(set(ans['fg']), {64})
|
|
|
|
# Gradients
|
|
def row(m, y=0, w=24):
|
|
return list(m[y * w : (y + 1) * w])
|
|
|
|
m = mask('fill=nonzero,lin(0 0 24 0 / 0 fg@0 / 1 fg):M0 0H24V24H0Z')
|
|
self.ae(row(m), [round((x + 0.5) / 24 * 255) for x in range(24)])
|
|
self.ae(row(m), row(m, 23))
|
|
# pad
|
|
m = mask('fill=nonzero,lin(6 0 18 0 / 0 fg@0 / 1 fg):M0 0H24V24H0Z')
|
|
self.ae(row(m)[:6], [0] * 6)
|
|
self.ae(row(m)[18:], [255] * 6)
|
|
# repeat and reflect
|
|
m = mask('fill=nonzero,lin(0 0 12 0 repeat / 0 fg@0 / 1 fg):M0 0H24V24H0Z')
|
|
self.ae(row(m)[:12], row(m)[12:])
|
|
m = mask('fill=nonzero,lin(0 0 12 0 reflect / 0 fg@0 / 1 fg):M0 0H24V24H0Z')
|
|
self.ae(row(m)[:12], row(m)[12:][::-1])
|
|
# gradient matrix: rotated by 90 degrees, so the gradient is vertical
|
|
m = mask('fill=nonzero,lin(0 0 24 0 m 0 1 -1 0 0 0 / 0 fg@0 / 1 fg):M0 0H24V24H0Z')
|
|
self.ae([m[y * 24] for y in range(24)], [round((y + 0.5) / 24 * 255) for y in range(24)])
|
|
# the gradient goes through the layer matrix
|
|
m = mask('fill=nonzero,lin(0 0 12 0 / 0 fg@0 / 1 fg),m 2 0 0 1 0 0:M0 0H12V24H0Z')
|
|
self.ae(row(m), [round((x + 0.5) / 24 * 255) for x in range(24)])
|
|
# hard stops
|
|
m = mask('fill=nonzero,lin(0 0 24 0 / 0 fg / 0.5 fg / 0.5 fg@0 / 1 fg@0):M0 0H24V24H0Z')
|
|
self.ae(row(m), [255] * 12 + [0] * 12)
|
|
# radial
|
|
m = mask('fill=nonzero,rad(12 12 0 12 12 12 / 0 fg / 1 fg@0):M0 0H24V24H0Z')
|
|
self.ae(at(m, 12, 12), round(255 * (1 - math.hypot(0.5, 0.5) / 12)))
|
|
self.ae(at(m, 0, 0), 0)
|
|
self.ae(at(m, 0, 12), at(m, 12, 0))
|
|
# radial with the focal circle outside the end circle paints only inside the cone
|
|
m = mask('fill=nonzero,rad(2 12 1 18 12 3 / 0 fg / 1 fg):M0 0H24V24H0Z')
|
|
self.ae(at(m, 0, 0), 0)
|
|
self.ae(at(m, 12, 12), 255)
|
|
# degenerate gradients paint their last stop
|
|
self.ae(set(mask('fill=nonzero,lin(5 5 5 5 / 0 fg@0 / 1 fg):M0 0H24V24H0Z')), {255})
|
|
self.ae(set(mask('fill=nonzero,rad(5 5 2 5 5 2 / 0 fg@0 / 1 fg):M0 0H24V24H0Z')), {255})
|
|
# mixed fg and fixed stops
|
|
ans = r('fill=nonzero,lin(0 0 24 0 / 0 fg / 1 #ff0000):M0 0H24V24H0Z')
|
|
self.ae(ans['fg'][0] + ans['color'][0], 255)
|
|
self.assertGreater(ans['fg'][0], 240)
|
|
self.assertGreater(ans['color'][23 * 4], 240)
|
|
self.ae(set(ans['color'][3::4]), {255})
|
|
|
|
# Clips
|
|
circle = 'M12 2A10 10 0 1 1 12 22A10 10 0 1 1 12 2Z'
|
|
sz = 120
|
|
clipped = mask(f'clip=1,nonzero:{circle}|fill=nonzero,fg:M0 0H24V24H0Z', sz, sz)
|
|
self.ae(clipped, mask(f'fill=nonzero,fg:{circle}', sz, sz))
|
|
# clips apply only to the specified number of layers
|
|
m = mask(f'clip=1,nonzero:{circle}|fill=nonzero,fg:M0 0H1V1H0Z|fill=nonzero,fg:M23 23H24V24H23Z', sz, sz)
|
|
self.ae(m[0], 0)
|
|
self.ae(m[-1], 255)
|
|
m = mask(f'clip=2,nonzero:{circle}|fill=nonzero,fg:M0 0H1V1H0Z|fill=nonzero,fg:M23 23H24V24H23Z', sz, sz)
|
|
self.ae(set(m), {0})
|
|
# an empty clip hides everything
|
|
self.ae(set(mask('clip=1,nonzero:M0 0|fill=nonzero,fg:M0 0H24V24H0Z')), {0})
|
|
# evenodd clips
|
|
self.ae(area(mask('clip=1,evenodd:M2 2H22V22H2ZM7 7H17V17H7Z|fill=nonzero,fg:M0 0H24V24H0Z')), 300)
|
|
|
|
# Rendering is bounded in time: geometry that is huge relative to
|
|
# the area it is rendered into is rejected
|
|
bomb = 'stroke=0.001,fg:M0.5 0' + ' q2e-05 2e-05 0 4e-05 q-2e-05 -2e-05 0 -4e-05' * 64
|
|
with self.assertRaisesRegex(ValueError, '^too_complex'):
|
|
render_vg(bomb.encode(), (0, 0, 1, 1 / 4096), 80, 160, fit='cover')
|
|
self.assertIn('work', render_vg(bomb.encode(), (0, 0, 1, 1 / 4096), 80, 160, fit='contain'))
|
|
# the most expensive valid payloads are well within the limit
|
|
heavy = '|'.join(['fill=nonzero,rad(4 4 1 12 12 30 reflect / 0 fg / 0.3 #ff0000 / 0.6 #00ff0080 / 1 #0000ff):M0 0H24V24H0Z'] * 16)
|
|
for w, h in ((10, 20), (80, 160), (560, 1120)):
|
|
r(heavy, w, h, fit='stretch')
|
|
|
|
# Determinism
|
|
p = 'stroke=1.5,lin(0 0 24 24 reflect / 0 fg / 1 #00ff0080):M3 12c3-8 6-8 9 0s6 8 9 0|fill=evenodd,fg@0.5:' + circle
|
|
self.ae(r(p, 37, 71), r(p, 37, 71))
|
|
|
|
|
|
class GlyphRendering(FontBaseTest):
|
|
def sprite(self, sprite_idx):
|
|
pos = sprite_idx_to_pos(sprite_idx, setup_for_testing.xnum, setup_for_testing.ynum)
|
|
pixels = array.array('I', self.sprites[pos])
|
|
# the last row is the underline exclusion zone
|
|
return pixels[: self.cell_width * self.cell_height]
|
|
|
|
def register(self, s, cp, layers, vb='0 0 24 24', **kw):
|
|
extra = ''.join(f';{k}={v}' for k, v in kw.items())
|
|
s.callbacks.wtcbuf = b''
|
|
parse_bytes(s, f'\x1b_25a1;r;cp={cp:x};fmt=vg;vb={vb}{extra};{layers}\x1b\\'.encode())
|
|
self.ae(s.callbacks.wtcbuf, f'\x1b_25a1;r;cp={cp:x};status=0\x1b\\'.encode())
|
|
|
|
def render(self, s, text, y=0):
|
|
s.reset_mode(DECAWM)
|
|
s.cursor_position(y + 1, 1)
|
|
s.erase_in_line(2)
|
|
s.draw(text)
|
|
line = s.line(y)
|
|
test_render_line(line)
|
|
return line
|
|
|
|
def test_registered_glyph_rendering(self):
|
|
s = self.create_screen(cols=8, lines=4, scrollback=0)
|
|
cw, ch = self.cell_width, self.cell_height
|
|
full = 'fill=nonzero,fg:M-24 -24H48V48H-24Z'
|
|
self.register(s, 0x100000, full)
|
|
line = self.render(s, '\U00100000x')
|
|
idx = line.sprite_at(0)
|
|
self.ae(idx & 0xC0000000, 0)
|
|
self.ae(set(self.sprite(idx)), {0xFFFFFF00 | 255})
|
|
# unregistered codepoints in the block are rendered via fonts
|
|
line = self.render(s, '\U00100001x')
|
|
self.assertNotEqual(line.sprite_at(0), idx)
|
|
|
|
# a glyph with fixed colors is a colored sprite with unpremultiplied colors
|
|
self.register(s, 0x100002, 'fill=nonzero,#ff000080:M-24 -24H48V48H-24Z')
|
|
line = self.render(s, '\U00100002x')
|
|
cidx = line.sprite_at(0)
|
|
self.ae(cidx & 0xC0000000, 0x80000000)
|
|
self.ae(set(self.sprite(cidx)), {0xFF000080})
|
|
|
|
# a glyph mixing fixed colors and the foreground color has the weight
|
|
# of the foreground color in the sprite to its right
|
|
self.register(s, 0x100003, 'fill=nonzero,fg:M-24 -24H48V48H-24Z|fill=nonzero,#0000ff80:M-24 -24H48V48H-24Z', fit='stretch')
|
|
line = self.render(s, '\U00100003x')
|
|
midx = line.sprite_at(0)
|
|
self.ae(midx & 0xC0000000, 0xC0000000)
|
|
midx &= 0x3FFFFFFF
|
|
pos, fg_pos = (sprite_idx_to_pos(i, setup_for_testing.xnum, setup_for_testing.ynum) for i in (midx, midx + 1))
|
|
self.ae(fg_pos, (pos[0] + 1, pos[1], pos[2]))
|
|
# K = (0, 0, 128) with A = 255 and F = 127, relative to alpha
|
|
self.ae(set(self.sprite(midx)), {0x000080FF})
|
|
self.ae(set(self.sprite(midx + 1)), {0xFFFFFF00 | 127})
|
|
|
|
# identical glyphs share sprites, even at different codepoints
|
|
self.register(s, 0x100004, full)
|
|
self.ae(self.render(s, '\U00100004x').sprite_at(0), idx)
|
|
|
|
# changing a registration changes the rendering
|
|
self.register(s, 0x100000, 'fill=nonzero,fg:M0 0H24V12H0Z', fit='stretch')
|
|
line = self.render(s, '\U00100000x')
|
|
half_idx = line.sprite_at(0)
|
|
self.assertNotEqual(half_idx, idx)
|
|
pixels = self.sprite(half_idx)
|
|
self.ae(set(pixels[: cw * (ch // 2 - 1)]), {0xFFFFFF00 | 255})
|
|
self.ae(set(pixels[cw * (ch // 2 + 1) :]), {0xFFFFFF00})
|
|
|
|
# a clear makes the codepoint render via fonts again
|
|
parse_bytes(s, b'\x1b_25a1;c;cp=100000;reply=0\x1b\\')
|
|
self.assertNotIn(self.render(s, '\U00100000x').sprite_at(0), (idx, half_idx))
|
|
|
|
def test_registered_glyph_width(self):
|
|
s = self.create_screen(cols=8, lines=4, scrollback=0)
|
|
cw, ch = self.cell_width, self.cell_height
|
|
self.assertGreater(ch, cw)
|
|
# a square glyph followed by a space is rendered across two cells, as
|
|
# its width when fitting the cell height is more than one cell. It is
|
|
# contained in the two cells, which can be narrower than the cell height.
|
|
sq = 'fill=nonzero,fg:M0 0H24V24H0Z'
|
|
self.register(s, 0x100000, sq)
|
|
line = self.render(s, '\U00100000 x')
|
|
left, right = self.sprite(line.sprite_at(0)), self.sprite(line.sprite_at(1))
|
|
coverage = sum(p & 0xFF for p in left) + sum(p & 0xFF for p in right)
|
|
side = min(ch, 2 * cw)
|
|
self.assertAlmostEqual(coverage / 255, side * side, delta=side)
|
|
# the glyph is centered in the two cells
|
|
self.ae(sum(p & 0xFF for p in left), sum(p & 0xFF for p in right))
|
|
# without a trailing space it is rendered in one cell
|
|
line = self.render(s, '\U00100000x')
|
|
self.assertAlmostEqual(sum(p & 0xFF for p in self.sprite(line.sprite_at(0))) / 255, cw * cw, delta=cw)
|
|
# a glyph whose viewBox fits in one cell is not widened
|
|
self.register(s, 0x100001, sq, vb='0 0 8 24')
|
|
line = self.render(s, '\U00100001 x')
|
|
self.ae(line.sprite_at(1), 0)
|
|
|
|
def test_registered_glyph_text_sizing(self):
|
|
s = self.create_screen(cols=8, lines=4, scrollback=0)
|
|
cw, ch = self.cell_width, self.cell_height
|
|
# with s=2 the glyph covers 2x2 cells
|
|
self.register(s, 0x100000, 'fill=nonzero,fg:M0 0H24V24H0Z', fit='stretch')
|
|
draw_multicell(s, '\U00100000', scale=2)
|
|
total = 0
|
|
for y in range(2):
|
|
line = s.line(y)
|
|
test_render_line(line)
|
|
for x in range(2):
|
|
total += sum(p & 0xFF for p in self.sprite(line.sprite_at(x))) / 255
|
|
self.ae(total, 4 * cw * ch)
|
|
# with w=3 the glyph covers 3 cells
|
|
s.reset()
|
|
self.register(s, 0x100000, 'fill=nonzero,fg:M0 0H12V24H0Z', fit='stretch')
|
|
draw_multicell(s, '\U00100000', width=3)
|
|
line = s.line(0)
|
|
test_render_line(line)
|
|
cov = [sum(p & 0xFF for p in self.sprite(line.sprite_at(x))) / 255 for x in range(3)]
|
|
# the left half of the 3 cell wide area is covered
|
|
self.assertAlmostEqual(sum(cov), 1.5 * cw * ch, delta=ch)
|
|
self.ae(cov[0], cw * ch)
|
|
self.ae(cov[2], 0)
|
|
|
|
def test_registered_glyphs_are_bound_when_printed(self):
|
|
s = self.create_screen(cols=8, lines=4, scrollback=20)
|
|
base_memory = vg_live_glyph_memory()
|
|
circle = 'fill=nonzero,fg:M12 2A10 10 0 1 1 12 22A10 10 0 1 1 12 2Z'
|
|
square = 'fill=nonzero,fg:M2 2H22V22H2Z'
|
|
self.register(s, 0x100000, circle)
|
|
line = self.render(s, '\U00100000x')
|
|
circle_idx = line.sprite_at(0)
|
|
# the text of the cell is just the codepoint
|
|
self.ae(str(line), '\U00100000x')
|
|
# re-registering does not change what was already printed
|
|
self.register(s, 0x100000, square)
|
|
test_render_line(line)
|
|
self.ae(line.sprite_at(0), circle_idx)
|
|
# but text printed later uses the new glyph
|
|
line2 = self.render(s, '\U00100000x', y=1)
|
|
square_idx = line2.sprite_at(0)
|
|
self.assertNotEqual(square_idx, circle_idx)
|
|
# combining chars keep the glyph bound to the cell
|
|
s.cursor_position(1, 2)
|
|
s.draw('\u0301')
|
|
self.ae(str(s.line(0)), '\U00100000\u0301x')
|
|
line = s.line(0)
|
|
test_render_line(line)
|
|
self.ae(line.sprite_at(0), circle_idx)
|
|
# clearing does not affect printed text
|
|
parse_bytes(s, b'\x1b_25a1;c;reply=0\x1b\\')
|
|
for y, idx in ((0, circle_idx), (1, square_idx)):
|
|
line = s.line(y)
|
|
test_render_line(line)
|
|
self.ae(line.sprite_at(0), idx)
|
|
# but text printed later is not rendered with a registered glyph
|
|
self.assertNotIn(self.render(s, '\U00100000x', y=2).sprite_at(0), (circle_idx, square_idx))
|
|
# registering identical glyphs shares the glyph objects
|
|
self.register(s, 0x100001, circle)
|
|
self.register(s, 0x100002, circle)
|
|
self.ae(self.render(s, '\U00100001\U00100002', y=3).sprite_at(0), circle_idx)
|
|
self.ae(s.line(3).sprite_at(1), circle_idx)
|
|
# text with bound glyphs keeps them alive until the text is gone
|
|
self.assertGreater(vg_live_glyph_memory(), base_memory)
|
|
parse_bytes(s, b'\x1b_25a1;c;reply=0\x1b\\')
|
|
self.assertGreater(vg_live_glyph_memory(), base_memory)
|
|
s.erase_in_display(3, False)
|
|
s.erase_in_display(2, False)
|
|
s.garbage_collect_text_cache()
|
|
self.ae(vg_live_glyph_memory(), base_memory)
|
|
# text in the scrollback keeps its glyphs
|
|
self.register(s, 0x100003, circle)
|
|
s.draw('\U00100003')
|
|
for i in range(6):
|
|
s.index()
|
|
s.garbage_collect_text_cache()
|
|
self.assertGreater(vg_live_glyph_memory(), base_memory)
|
|
# RIS releases all glyphs
|
|
s.reset()
|
|
self.ae(vg_live_glyph_memory(), base_memory)
|
|
|
|
def test_registered_glyphs_in_multicell(self):
|
|
s = self.create_screen(cols=8, lines=4, scrollback=0)
|
|
self.register(s, 0x100000, 'fill=nonzero,fg:M0 0H24V24H0Z', fit='stretch')
|
|
draw_multicell(s, '\U00100000', scale=2)
|
|
line = s.line(0)
|
|
test_render_line(line)
|
|
first = line.sprite_at(0)
|
|
# re-registering does not change the multicell char
|
|
self.register(s, 0x100000, 'fill=nonzero,fg:M0 0H12V24H0Z', fit='stretch')
|
|
for y in range(2):
|
|
line = s.line(y)
|
|
test_render_line(line)
|
|
self.ae(sum(p & 0xFF for x in range(2) for p in self.sprite(line.sprite_at(x))) / 255, 2 * self.cell_width * self.cell_height)
|
|
self.ae(s.line(0).sprite_at(0), first)
|
|
|
|
def test_registered_glyph_sprites_are_reused(self):
|
|
import gc
|
|
|
|
# free screens from earlier tests, as freeing their glyphs creates holes
|
|
gc.collect()
|
|
s = self.create_screen(cols=8, lines=4, scrollback=0)
|
|
|
|
def glyph(i, mixed=False):
|
|
ans = f'fill=nonzero,fg:M0 0H{1 + i % 23}V24H0Z'
|
|
if mixed:
|
|
ans += f'|fill=nonzero,#ff0000:M0 0H24V{1 + i % 23}H0Z'
|
|
return ans
|
|
|
|
def show(i, mixed=False):
|
|
self.register(s, 0x100000, glyph(i, mixed))
|
|
return self.render(s, '\U00100000x').sprite_at(0) & 0x3FFFFFFF
|
|
|
|
def release():
|
|
# erase the text and the registration, so the glyph is freed
|
|
s.erase_in_display(2, False)
|
|
parse_bytes(s, b'\x1b_25a1;c;reply=0\x1b\\')
|
|
s.garbage_collect_text_cache()
|
|
|
|
a = show(1)
|
|
release()
|
|
self.ae(show(2), a)
|
|
release()
|
|
# a pair of slots for a glyph mixing fg and fixed colors is reused for another such glyph
|
|
m = show(3, True)
|
|
release()
|
|
self.ae(show(4, True), m)
|
|
release()
|
|
# single slots are reused before pairs are split
|
|
self.ae(show(5), a)
|
|
# and then pairs are split into single slots
|
|
self.register(s, 0x100001, glyph(6))
|
|
self.register(s, 0x100002, glyph(7))
|
|
line = self.render(s, '\U00100001\U00100002', y=1)
|
|
self.ae([line.sprite_at(x) for x in range(2)], [m, m + 1])
|
|
release()
|
|
|
|
# registering and printing new glyphs uses a bounded number of sprites
|
|
before = len(self.sprites)
|
|
for i in range(200):
|
|
show(100 + i, i % 3 == 0)
|
|
if i % 10 == 9:
|
|
s.garbage_collect_text_cache()
|
|
self.assertLess(len(self.sprites) - before, 40)
|
|
|
|
def test_registered_glyph_window_limits(self):
|
|
self.addCleanup(vg_set_window_limits)
|
|
vg_set_window_limits(1 << 30, 10)
|
|
s = self.create_screen(cols=8, lines=4, scrollback=100)
|
|
|
|
def reg(screen, i):
|
|
screen.callbacks.wtcbuf = b''
|
|
parse_bytes(screen, f'\x1b_25a1;r;cp=100000;fmt=vg;vb=0 0 24 24;fill=nonzero,fg:M0 0H{i / 4}V1Z\x1b\\'.encode())
|
|
return screen.callbacks.wtcbuf.decode()
|
|
|
|
ok, full = '\x1b_25a1;r;cp=100000;status=0\x1b\\', '\x1b_25a1;r;cp=100000;status=1;reason=no_space\x1b\\'
|
|
# each new glyph printed into the scrollback is kept alive by the text
|
|
results = []
|
|
for i in range(1, 20):
|
|
results.append(reg(s, i))
|
|
s.draw('\U00100000')
|
|
s.linefeed()
|
|
s.carriage_return()
|
|
self.ae(results[:8], [ok] * 8)
|
|
self.ae(results[-1], full)
|
|
# other windows are not affected
|
|
s2 = self.create_screen()
|
|
self.ae(reg(s2, 50), ok)
|
|
# once the text is gone the glyphs are released and registering works again
|
|
s.erase_in_display(3, False)
|
|
s.erase_in_display(2, False)
|
|
s.garbage_collect_text_cache()
|
|
self.ae(reg(s, 60), ok)
|
|
# the text cache is garbage collected automatically when the limits are reached
|
|
s3 = self.create_screen(cols=8, lines=4, scrollback=0)
|
|
for i in range(1, 6):
|
|
self.ae(reg(s3, i), ok)
|
|
s3.draw('\U00100000')
|
|
s3.erase_in_display(2, False)
|
|
for i in range(6, 12):
|
|
self.ae(reg(s3, i), ok, f'registration {i} failed')
|
|
s3.draw('\U00100000')
|
|
|
|
def test_registered_glyph_sprite_limits(self):
|
|
import gc
|
|
|
|
gc.collect()
|
|
self.addCleanup(set_glyph_protocol_sprite_limits)
|
|
MISSING = 1
|
|
|
|
# each glyph can be rendered with a limited number of distinct parameters
|
|
set_glyph_protocol_sprite_limits(65536, 16384, 12)
|
|
s = self.create_screen(cols=8, lines=4, scrollback=0)
|
|
self.register(s, 0x100000, 'fill=nonzero,fg:M0 0H24V24H0Z')
|
|
results = []
|
|
for n in range(1, 8):
|
|
s.reset_mode(DECAWM)
|
|
s.cursor_position(1, 1)
|
|
draw_multicell(s, '\U00100000', width=2, subscale_n=n, subscale_d=8)
|
|
line = s.line(0)
|
|
test_render_line(line)
|
|
results.append(line.sprite_at(0))
|
|
# 2 sprites per variant, the seventh variant exceeds the limit of 12
|
|
self.assertNotIn(MISSING, results[:6])
|
|
self.ae(results[6], MISSING)
|
|
|
|
# each window can use a limited number of sprite slots
|
|
# 2 slots are reserved per sprite, as glyphs mixing colors use a pair
|
|
set_glyph_protocol_sprite_limits(65536, 6, 1024)
|
|
s = self.create_screen(cols=8, lines=4, scrollback=0)
|
|
for i in range(8):
|
|
self.register(s, 0x100000 + i, f'fill=nonzero,fg:M0 0H{i + 1}V24H0Z')
|
|
line = self.render(s, ''.join(chr(0x100000 + i) for i in range(8)))
|
|
sprites = [line.sprite_at(x) for x in range(8)]
|
|
self.assertNotIn(MISSING, sprites[:5])
|
|
self.ae(sprites[5:], [MISSING] * 3)
|
|
# other windows are not affected
|
|
s2 = self.create_screen(cols=8, lines=4, scrollback=0)
|
|
self.register(s2, 0x100000, 'fill=nonzero,fg:M0 0H20V24H0Z')
|
|
self.assertNotEqual(self.render(s2, '\U00100000').sprite_at(0), MISSING)
|
|
# once the glyphs are no longer used the window can render again
|
|
s.erase_in_display(2, False)
|
|
parse_bytes(s, b'\x1b_25a1;c;reply=0\x1b\\')
|
|
s.garbage_collect_text_cache()
|
|
self.register(s, 0x100000, 'fill=nonzero,fg:M0 0H21V24H0Z')
|
|
self.assertNotEqual(self.render(s, '\U00100000').sprite_at(0), MISSING)
|
|
set_glyph_protocol_sprite_limits()
|
|
|
|
# glyphs that are too complex to render are rendered as the missing glyph
|
|
s = self.create_screen(cols=8, lines=8, scrollback=0)
|
|
bomb = 'stroke=0.001,fg:M0.5 0' + ' q2e-05 2e-05 0 4e-05 q-2e-05 -2e-05 0 -4e-05' * 64
|
|
self.register(s, 0x100001, bomb, vb=f'0 0 1 {1 / 4096}', fit='cover')
|
|
draw_multicell(s, '\U00100001', scale=7)
|
|
for i in range(2): # the second time the failure is cached
|
|
line = s.line(0)
|
|
test_render_line(line)
|
|
self.ae([line.sprite_at(x) for x in range(7)], [MISSING] * 7)
|
|
|
|
def test_paused_rendering_releases_glyphs(self):
|
|
import gc
|
|
|
|
gc.collect()
|
|
base = vg_live_glyph_memory()
|
|
s = self.create_screen(cols=8, lines=4, scrollback=0)
|
|
self.register(s, 0x100000, 'fill=nonzero,fg:M0 0H24V24H0Z')
|
|
s.draw('\U00100000')
|
|
self.assertTrue(s.pause_rendering(True, 5000))
|
|
self.assertTrue(s.pause_rendering(False, 0))
|
|
s.reset()
|
|
self.ae(vg_live_glyph_memory(), base)
|