def test_modeline(self):
f = mocks.FE()
w = messager.Messager(f)
w.renderer = mocks.Renderer()
self.assertEqual(w.modeline(),
([(set(), 'filter default')], [({'right'}, '1')]))
m = f.context.backends._messages[0]
m.time = 0.0
w.renderer = mocks.Renderer((m, m))
os.environ['TZ'] = 'GMT'
self.assertEqual(w.modeline(),
([({'dim'}, '1970-01-01 00:00'),
(set(), ' filter default')], [({'right'}, '1')]))
m.time = float('NaN')
class mockdatetime(datetime.datetime):
@staticmethod
def now():
return datetime.datetime.fromtimestamp(60)
with patch('datetime.datetime', mockdatetime):
self.assertEqual(
w.modeline(),
([({'dim'}, '00:01'),
(set(), ' filter default')], [({'right'}, '1')]))
def test_check_redisplay_hint(self):
f = mocks.FE()
w = messager.Messager(f)
w.renderer = mocks.Renderer()
self.assertFalse(w.check_redisplay_hint({}))
hint = w.redisplay_hint()
self.assertTrue(w.check_redisplay_hint(hint))
r = (f.context.backends._messages[0], f.context.backends._messages[-1])
self.assertFalse(w.check_redisplay_hint({'messages': r}))
w.filter = filters.Yes()
w.renderer = mocks.Renderer(range=r)
self.assertTrue(w.check_redisplay_hint({'messages': r}))
def test_constructor_misc(self):
e = snipe.editor.Viewer(None)
e.renderer = mocks.Renderer()
f = snipe.editor.Viewer(None, prototype=e)
self.assertIs(e.buf, f.buf)
e = snipe.editor.Viewer(None)
e.renderer = mocks.Renderer()
e.set_mark()
self.assertIsNotNone(e.the_mark)
f = snipe.editor.Viewer(None, prototype=e)
self.assertIs(e.buf, f.buf)
self.assertEqual(e.the_mark, f.the_mark)
async def test_send(self):
f = mocks.FE()
m = mocks.Message()
m.omega = True
f.context.backends._messages.append(m)
w = messager.Messager(f)
w.renderer = mocks.Renderer((f.context.backends._messages[0],
f.context.backends._messages[-1]))
c = w.cursor
_read_args = None
_read_kw = None
_read_result = 'foo\nbar'
async def read_string(*args, **kw):
nonlocal _read_args, _read_kw
_read_args, _read_kw = args, kw
return _read_result
w.read_string = read_string
await w.send()
self.assertEqual(f.context.backends._sent[-1], ('foo', 'bar'))
self.assertNotIn('modes', _read_kw)
self.assertEqual(w.secondary, c)
w.cursor = c
_read_result = 'foo'
await w.send(msg=c)
self.assertIn('modes', _read_kw)
self.assertEqual(f.context.backends._sent[-1], ('foo', ''))
def test_pageup_backfill(self):
f = mocks.FE()
w = messager.Messager(f)
w.renderer = mocks.Renderer(range=tuple(f.context.backends._messages *
2))
self.assertIsNone(f.context.backends._target)
w.pageup()
self.assertTrue(math.isinf(f.context.backends._target))
def test_misc(self):
snipe.editor.Buffer.registry.clear()
e = snipe.editor.Viewer(None, name='foo')
self.assertEqual(e.title(), 'foo')
self.assertTrue(e.check_redisplay_hint(e.redisplay_hint()))
self.assertFalse(e.check_redisplay_hint({}))
e.renderer = mocks.Renderer()
f = snipe.editor.Viewer(None, prototype=e)
self.assertTrue(e.check_redisplay_hint(f.redisplay_hint()))
def test(self):
fe = mocks.FE()
v = snipe.editor.PopViewer(fe, content='', name='test')
v.renderer = mocks.Renderer()
v.renderer._range = [0, 0]
self.assertEqual(
(([(set(), '- test')]), ([({'right'}, '1')])), v.modeline())
name = v.buf.name
self.assertIn(name, v.buf.registry)
v.destroy()
self.assertNotIn(name, v.buf.registry)
def test_0(self):
fe = mocks.FE()
w = messager.Messager(fe)
self.assertEqual([[({'visible', 'bar'}, '\n')]],
[chunk.tagsets() for (mark, chunk) in w.view(0)])
w.renderer = mocks.Renderer()
f = filters.Yes()
fe.context.conf['rule'] = [('yes', {'foreground': 'green'})]
x = messager.Messager(fe, prototype=w, filter_new=f)
self.assertEqual([[({'visible', 'bar'}, '\n')]],
[chunk.tagsets() for (mark, chunk) in w.view(0)])
self.assertIs(x.filter, f)
self.assertEqual(len(x.rules), len(fe.context.conf['rule']))
def test_constructor(self):
e = snipe.editor.Editor(None)
self.assertEqual(e.fill_column, 0)
e = snipe.editor.Editor(None, fill=True)
self.assertEqual(e.fill_column, e.default_fill_column)
self.assertTrue(e._writable)
e.toggle_writable()
self.assertFalse(e._writable)
e.renderer = mocks.Renderer()
f = snipe.editor.Editor(None, prototype=e)
self.assertFalse(f._writable)
def test_longprompt0(self):
result = None
def cb(s):
nonlocal result
result = s
w = prompt.LongPrompt(None, prompt=': ', history='test0', callback=cb)
w.insert('data1')
w.runcallback()
w.destroy()
self.assertEqual(result, 'data1')
result = None
x = prompt.LongPrompt(None, prompt=': ', history='test0', callback=cb)
x.previous_history()
x.runcallback()
x.destroy()
self.assertEqual(result, 'data1')
result = None
y = prompt.LongPrompt(None, prompt=': ', history='test0', callback=cb)
y.previous_history()
y.next_history()
y.runcallback()
self.assertEqual(result, '')
y.insert('frogs')
y.renderer = mocks.Renderer()
result = None
z = prompt.LongPrompt(None, prototype=y)
z.runcallback()
self.assertEqual(result, 'frogs')
z.previous_history()
self.assertEqual(w.input(), 'data1')
x = z.histptr
z.move_history(-100)
self.assertEqual(x, z.histptr)
def test_init(self):
w = window.Window(mocks.FE())
w.renderer = mocks.Renderer()
w.cursor = object()
x = window.Window(mocks.FE(), prototype=w)
self.assertIs(w.cursor, x.cursor)
def test_constructor_misc(self):
e = snipe.editor.Viewer(None)
e.renderer = mocks.Renderer()
f = snipe.editor.Viewer(None, prototype=e)
self.assertIs(e.buf, f.buf)
