def test_parameterizing_string_type_error(monkeypatch):
"""Test formatters.ParameterizingString raising TypeError."""
from blessed.formatters import ParameterizingString
def tparm_raises_TypeError(*args):
raise TypeError('custom_err')
monkeypatch.setattr(curses, 'tparm', tparm_raises_TypeError)
# given,
pstr = ParameterizingString(u'cap', u'norm', u'cap-name')
# ensure TypeError when given a string raises custom exception
try:
pstr('XYZ')
assert False, "previous call should have raised TypeError"
except TypeError as err:
assert (err.args[0] == ( # py3x
"A native or nonexistent capability template, "
"'cap-name' received invalid argument ('XYZ',): "
"custom_err. You probably misspelled a "
"formatting call like `bright_red'") or err.args[0]
== ("A native or nonexistent capability template, "
"u'cap-name' received invalid argument ('XYZ',): "
"custom_err. You probably misspelled a "
"formatting call like `bright_red'"))
# ensure TypeError when given an integer raises its natural exception
try:
pstr(0)
assert False, "previous call should have raised TypeError"
except TypeError as err:
assert err.args[0] == "custom_err"
def test_parameterizing_string_type_error(monkeypatch):
"""Test formatters.ParameterizingString raising TypeError."""
from blessed.formatters import ParameterizingString
def tparm_raises_TypeError(*args):
raise TypeError('custom_err')
monkeypatch.setattr(curses, 'tparm', tparm_raises_TypeError)
# given,
pstr = ParameterizingString(u'cap', u'norm', u'cap-name')
# ensure TypeError when given a string raises custom exception
try:
pstr('XYZ')
assert False, "previous call should have raised TypeError"
except TypeError as err:
assert err.args[0] in (
(
"Unknown terminal capability, 'cap-name', or, TypeError "
"for arguments ('XYZ',): custom_err" # py3x
),
("Unknown terminal capability, u'cap-name', or, TypeError "
"for arguments ('XYZ',): custom_err")) # py2
# ensure TypeError when given an integer raises its natural exception
try:
pstr(0)
assert False, "previous call should have raised TypeError"
except TypeError as err:
assert err.args[0] == "custom_err"
def test_parameterizing_string_args(monkeypatch):
"""Test basic formatters.ParameterizingString."""
from blessed.formatters import ParameterizingString, FormattingString
# first argument to tparm() is the sequence name, returned as-is;
# subsequent arguments are usually Integers.
tparm = lambda *args: u'~'.join(
arg.decode('latin1') if not num else '%s' % (arg, )
for num, arg in enumerate(args)).encode('latin1')
monkeypatch.setattr(curses, 'tparm', tparm)
# given,
pstr = ParameterizingString(u'cap', u'norm', u'seq-name')
# exercise __new__
assert str(pstr) == u'cap'
assert pstr._normal == u'norm'
assert pstr._name == u'seq-name'
# exercise __call__
zero = pstr(0)
assert type(zero) is FormattingString
assert zero == u'cap~0'
assert zero('text') == u'cap~0textnorm'
# exercise __call__ with multiple args
onetwo = pstr(1, 2)
assert type(onetwo) is FormattingString
assert onetwo == u'cap~1~2'
assert onetwo('text') == u'cap~1~2textnorm'
def test_parameterizing_string_args(monkeypatch):
"""Test basic formatters.ParameterizingString."""
from blessed.formatters import ParameterizingString, FormattingString
# first argument to tparm() is the sequence name, returned as-is;
# subsequent arguments are usually Integers.
monkeypatch.setattr(curses, 'tparm', fn_tparm)
# given,
pstr = ParameterizingString(u'cap', u'norm', u'seq-name')
# exercise __new__
assert str(pstr) == u'cap'
assert pstr._normal == u'norm'
assert pstr._name == u'seq-name'
# exercise __call__
zero = pstr(0)
assert isinstance(zero, FormattingString)
assert zero == u'cap~0'
assert zero('text') == u'cap~0textnorm'
# exercise __call__ with multiple args
onetwo = pstr(1, 2)
assert isinstance(onetwo, FormattingString)
assert onetwo == u'cap~1~2'
assert onetwo('text') == u'cap~1~2textnorm'
def test_pickled_parameterizing_string(monkeypatch):
"""Test pickle-ability of a formatters.ParameterizingString."""
from blessed.formatters import ParameterizingString
# simply send()/recv() over multiprocessing Pipe, a simple
# pickle.loads(dumps(...)) did not reproduce this issue,
# first argument to tparm() is the sequence name, returned as-is;
# subsequent arguments are usually Integers.
monkeypatch.setattr(curses, 'tparm', fn_tparm)
# given,
pstr = ParameterizingString(u'seqname', u'norm', u'cap-name')
# multiprocessing Pipe implicitly pickles.
r, w = multiprocessing.Pipe()
# exercise picklability of ParameterizingString
for proto_num in range(pickle.HIGHEST_PROTOCOL):
assert pstr == pickle.loads(pickle.dumps(pstr, protocol=proto_num))
w.send(pstr)
assert r.recv() == pstr
# exercise picklability of FormattingString
# -- the return value of calling ParameterizingString
zero = pstr(0)
for proto_num in range(pickle.HIGHEST_PROTOCOL):
assert zero == pickle.loads(pickle.dumps(zero, protocol=proto_num))
w.send(zero)
assert r.recv() == zero
def child():
term = TestTerminal(stream=six.StringIO())
stime = time.time()
# monkey patch in an invalid response !
term.ungetch(u'\x1b[10;10R')
with mock.patch.object(term, 'u6') as mock_u6:
mock_u6.return_value = ParameterizingString(
u'\x1b[%d;%dR', term.normal, 'u6')
y, x = term.get_location(timeout=0.01)
assert (math.floor(time.time() - stime) == 0.0)
assert (y, x) == (10, 10)
def child():
from blessed.formatters import ParameterizingString
t = TestTerminal(force_styling=True)
color = ParameterizingString(t.color, t.normal, 'color')
pickle.loads(pickle.dumps(color)) == color
pickle.loads(pickle.dumps(color(3))) == color(3)
pickle.loads(pickle.dumps(color))(3) == color(3)
# and, pickle through multiprocessing
r, w = multiprocessing.Pipe()
w.send(color)
assert r.recv() == color
w.send(color(3))
assert r.recv() == color(3)
w.send(t.color)
assert r.recv()(3) == t.color(3)
def test_tparm_returns_null(monkeypatch):
""" Test 'tparm() returned NULL' is caught (win32 PDCurses systems). """
# on win32, any calls to tparm raises curses.error with message,
# "tparm() returned NULL", function PyCurses_tparm of _cursesmodule.c
from blessed.formatters import ParameterizingString, NullCallableString
def tparm(*args):
raise curses.error("tparm() returned NULL")
monkeypatch.setattr(curses, 'tparm', tparm)
term = mock.Mock()
term.normal = 'seq-normal'
pstr = ParameterizingString(u'cap', u'norm', u'seq-name')
value = pstr(u'x')
assert type(value) is NullCallableString
def test_tparm_other_exception(monkeypatch):
""" Test 'tparm() returned NULL' is caught (win32 PDCurses systems). """
# on win32, any calls to tparm raises curses.error with message,
# "tparm() returned NULL", function PyCurses_tparm of _cursesmodule.c
from blessed.formatters import ParameterizingString, NullCallableString
def tparm(*args):
raise curses.error("unexpected error in tparm()")
monkeypatch.setattr(curses, 'tparm', tparm)
term = mock.Mock()
term.normal = 'seq-normal'
pstr = ParameterizingString(u'cap', u'norm', u'seq-name')
try:
pstr(u'x')
assert False, "previous call should have raised curses.error"
except curses.error:
pass
def test_pickled_parameterizing_string(monkeypatch):
"""Test pickle-ability of a formatters.ParameterizingString."""
from blessed.formatters import ParameterizingString, FormattingString
# simply send()/recv() over multiprocessing Pipe, a simple
# pickle.loads(dumps(...)) did not reproduce this issue,
from multiprocessing import Pipe
import pickle
# first argument to tparm() is the sequence name, returned as-is;
# subsequent arguments are usually Integers.
tparm = lambda *args: u'~'.join(
arg.decode('latin1') if not num else '%s' % (arg, )
for num, arg in enumerate(args)).encode('latin1')
monkeypatch.setattr(curses, 'tparm', tparm)
# given,
pstr = ParameterizingString(u'seqname', u'norm', u'cap-name')
# multiprocessing Pipe implicitly pickles.
r, w = Pipe()
# exercise picklability of ParameterizingString
for proto_num in range(pickle.HIGHEST_PROTOCOL):
assert pstr == pickle.loads(pickle.dumps(pstr, protocol=proto_num))
w.send(pstr)
r.recv() == pstr
# exercise picklability of FormattingString
# -- the return value of calling ParameterizingString
zero = pstr(0)
for proto_num in range(pickle.HIGHEST_PROTOCOL):
assert zero == pickle.loads(pickle.dumps(zero, protocol=proto_num))
w.send(zero)
r.recv() == zero
