I broke up with neovim....vim is my best friend now
This commit is contained in:
LinlyBoi
@@ -0,0 +1,56 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import unittest
|
||||
|
||||
import test_vimbuffer
|
||||
|
||||
import test_libagendafilter
|
||||
import test_libcheckbox
|
||||
import test_libbase
|
||||
import test_libheading
|
||||
import test_liborgdate
|
||||
import test_liborgdate_utf8
|
||||
import test_liborgdate_parsing
|
||||
import test_liborgdatetime
|
||||
import test_liborgtimerange
|
||||
|
||||
import test_plugin_date
|
||||
import test_plugin_edit_structure
|
||||
import test_plugin_edit_checkbox
|
||||
import test_plugin_misc
|
||||
import test_plugin_navigator
|
||||
import test_plugin_show_hide
|
||||
import test_plugin_tags_properties
|
||||
import test_plugin_todo
|
||||
import test_plugin_mappings
|
||||
|
||||
if __name__ == '__main__':
|
||||
tests = unittest.TestSuite()
|
||||
|
||||
tests.addTests(test_vimbuffer.suite())
|
||||
|
||||
# lib
|
||||
tests.addTests(test_libbase.suite())
|
||||
tests.addTests(test_libcheckbox.suite())
|
||||
tests.addTests(test_libagendafilter.suite())
|
||||
tests.addTests(test_libheading.suite())
|
||||
tests.addTests(test_liborgdate.suite())
|
||||
tests.addTests(test_liborgdate_utf8.suite())
|
||||
tests.addTests(test_liborgdate_parsing.suite())
|
||||
tests.addTests(test_liborgdatetime.suite())
|
||||
tests.addTests(test_liborgtimerange.suite())
|
||||
|
||||
# plugins
|
||||
tests.addTests(test_plugin_date.suite())
|
||||
tests.addTests(test_plugin_edit_structure.suite())
|
||||
tests.addTests(test_plugin_edit_checkbox.suite())
|
||||
tests.addTests(test_plugin_misc.suite())
|
||||
tests.addTests(test_plugin_navigator.suite())
|
||||
tests.addTests(test_plugin_show_hide.suite())
|
||||
tests.addTests(test_plugin_tags_properties.suite())
|
||||
tests.addTests(test_plugin_todo.suite())
|
||||
tests.addTests(test_plugin_mappings.suite())
|
||||
|
||||
runner = unittest.TextTestRunner()
|
||||
runner.run(tests)
|
||||
37
dot_vim/plugged/vim-orgmode/tests/orgmode_testfile.org
Normal file
37
dot_vim/plugged/vim-orgmode/tests/orgmode_testfile.org
Normal file
@@ -0,0 +1,37 @@
|
||||
|
||||
* bold, italics and underline syntax matching
|
||||
** Should match:
|
||||
|
||||
*foo* *foo*
|
||||
*Really, quite long sentence*.
|
||||
_foo_ _foo_
|
||||
_really, quite long sentence._.
|
||||
|
||||
*Übermensch á* *eä* *ý€*
|
||||
_Ÿ ï_
|
||||
|
||||
*sdf l.*
|
||||
*sdfsdf ,.*
|
||||
*foo_ sdf /*
|
||||
/sdf sdf sdf ./
|
||||
|
||||
/google.com/
|
||||
|
||||
*[sdf]*
|
||||
*a* /a/ =b= ~b~ `d`
|
||||
|
||||
*abc* /abc/ =bde= ~bde~ `def`
|
||||
*=*a*=*
|
||||
** Should not match
|
||||
http://google.com/
|
||||
//google.com/
|
||||
* sdf* _ sdf_
|
||||
*sdfsdf sdf,*
|
||||
*foo *
|
||||
foo_not underlined_bar
|
||||
|
||||
*.sdf*[
|
||||
[*.sdf*
|
||||
[*sdf*]
|
||||
*=*a*=
|
||||
|
||||
168
dot_vim/plugged/vim-orgmode/tests/test_libagendafilter.py
Normal file
168
dot_vim/plugged/vim-orgmode/tests/test_libagendafilter.py
Normal file
@@ -0,0 +1,168 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
import unittest
|
||||
from datetime import date
|
||||
from datetime import timedelta
|
||||
|
||||
from orgmode.liborgmode.headings import Heading
|
||||
from orgmode.liborgmode.orgdate import OrgDate
|
||||
from orgmode.liborgmode.agendafilter import contains_active_todo
|
||||
from orgmode.liborgmode.agendafilter import contains_active_date
|
||||
from orgmode.liborgmode.orgdate import OrgDateTime
|
||||
from orgmode.liborgmode.agendafilter import is_within_week
|
||||
from orgmode.liborgmode.agendafilter import is_within_week_and_active_todo
|
||||
from orgmode.liborgmode.agendafilter import filter_items
|
||||
|
||||
import vim
|
||||
|
||||
from orgmode.py3compat.encode_compatibility import *
|
||||
|
||||
counter = 0
|
||||
|
||||
class AgendaFilterTestCase(unittest.TestCase):
|
||||
u"""Tests all the functionality of the Agenda filter module."""
|
||||
|
||||
def setUp(self):
|
||||
global counter
|
||||
counter += 1
|
||||
|
||||
vim.EVALHISTORY = []
|
||||
vim.EVALRESULTS = {
|
||||
# no org_todo_keywords for b
|
||||
u_encode(u'exists("b:org_todo_keywords")'): u_encode('0'),
|
||||
# global values for org_todo_keywords
|
||||
u_encode(u'exists("g:org_todo_keywords")'): u_encode('1'),
|
||||
u_encode(u'g:org_todo_keywords'): [u_encode(u'TODO'), u_encode(u'|'), u_encode(u'DONE')],
|
||||
u_encode(u'exists("g:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("*repeat#set()")'): u_encode(u'0'),
|
||||
u_encode(u'b:changedtick'): u_encode(u'%d' % counter),
|
||||
u_encode(u"v:count"): u_encode(u'0')
|
||||
}
|
||||
vim.current.buffer[:] = [u_encode(i) for i in u"""
|
||||
* TODO Heading 1
|
||||
some text
|
||||
""".split(u'\n')]
|
||||
|
||||
def test_contains_active_todo(self):
|
||||
heading = Heading(title=u'Refactor the code', todo='TODO')
|
||||
self.assertTrue(contains_active_todo(heading))
|
||||
|
||||
heading = Heading(title=u'Refactor the code', todo='DONE')
|
||||
self.assertFalse(contains_active_todo(heading))
|
||||
|
||||
heading = Heading(title=u'Refactor the code', todo=None)
|
||||
self.assertFalse(contains_active_todo(heading))
|
||||
|
||||
def test_contains_active_date(self):
|
||||
heading = Heading(title=u'Refactor the code', active_date=None)
|
||||
self.assertFalse(contains_active_date(heading))
|
||||
|
||||
odate = OrgDate(True, 2011, 11, 1)
|
||||
heading = Heading(title=u'Refactor the code', active_date=odate)
|
||||
self.assertTrue(contains_active_date(heading))
|
||||
|
||||
def test_is_within_week_with_orgdate(self):
|
||||
# to far in the future
|
||||
tmpdate = date.today() + timedelta(days=8)
|
||||
odate = OrgDate(True, tmpdate.year, tmpdate.month, tmpdate.day)
|
||||
heading = Heading(title=u'Refactor the code', active_date=odate)
|
||||
self.assertFalse(is_within_week(heading))
|
||||
|
||||
# within a week
|
||||
tmpdate = date.today() + timedelta(days=5)
|
||||
odate = OrgDate(True, tmpdate.year, tmpdate.month, tmpdate.day)
|
||||
heading = Heading(title=u'Refactor the code', active_date=odate)
|
||||
self.assertTrue(is_within_week(heading))
|
||||
|
||||
# in the past
|
||||
tmpdate = date.today() - timedelta(days=105)
|
||||
odate = OrgDate(True, tmpdate.year, tmpdate.month, tmpdate.day)
|
||||
heading = Heading(title=u'Refactor the code', active_date=odate)
|
||||
self.assertTrue(is_within_week(heading))
|
||||
|
||||
def test_is_within_week_with_orgdatetime(self):
|
||||
# to far in the future
|
||||
tmp = date.today() + timedelta(days=1000)
|
||||
odate = OrgDateTime(True, tmp.year, tmp.month, tmp.day, 10, 10)
|
||||
heading = Heading(title=u'Refactor the code', active_date=odate)
|
||||
self.assertFalse(is_within_week(heading))
|
||||
|
||||
# within a week
|
||||
tmpdate = date.today() + timedelta(days=5)
|
||||
odate = OrgDateTime(True, tmpdate.year, tmpdate.month, tmpdate.day, 1, 0)
|
||||
heading = Heading(title=u'Refactor the code', active_date=odate)
|
||||
self.assertTrue(is_within_week(heading))
|
||||
|
||||
# in the past
|
||||
tmpdate = date.today() - timedelta(days=5)
|
||||
odate = OrgDateTime(True, tmpdate.year, tmpdate.month, tmpdate.day, 1, 0)
|
||||
heading = Heading(title=u'Refactor the code', active_date=odate)
|
||||
self.assertTrue(is_within_week(heading))
|
||||
|
||||
def test_filter_items(self):
|
||||
# only headings with date and todo should be returned
|
||||
vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = \
|
||||
[u_encode(u'TODO'), u_encode(u'STARTED'), u_encode(u'|'), u_encode(u'DONE')]
|
||||
tmpdate = date.today()
|
||||
odate = OrgDate(True, tmpdate.year, tmpdate.month, tmpdate.day)
|
||||
tmp_head = Heading(title=u'Refactor the code', todo=u'TODO', active_date=odate)
|
||||
tmp_head_01 = Heading(title=u'Refactor the code', todo=u'STARTED', active_date=odate)
|
||||
# TODO add more tests
|
||||
headings = [tmp_head, tmp_head_01]
|
||||
filtered = list(filter_items(headings,
|
||||
[contains_active_date, contains_active_todo]))
|
||||
|
||||
self.assertEqual(len(filtered), 2)
|
||||
self.assertEqual(filtered, headings)
|
||||
|
||||
# try a longer list
|
||||
headings = headings * 3
|
||||
filtered = list(filter_items(headings,
|
||||
[contains_active_date, contains_active_todo]))
|
||||
|
||||
self.assertEqual(len(filtered), 6)
|
||||
self.assertEqual(filtered, headings)
|
||||
|
||||
# date does not contain all needed fields thus gets ignored
|
||||
tmpdate = date.today()
|
||||
odate = OrgDate(True, tmpdate.year, tmpdate.month, tmpdate.day)
|
||||
tmp_head = Heading(title=u'Refactor the code', active_date=odate)
|
||||
headings = [tmp_head]
|
||||
filtered = list(filter_items(headings, [contains_active_date,
|
||||
contains_active_todo]))
|
||||
self.assertEqual([], filtered)
|
||||
|
||||
def test_filter_items_with_some_todos_and_dates(self):
|
||||
u"""
|
||||
Only the headings with todo and dates should be returned.
|
||||
"""
|
||||
tmp = [u"* TODO OrgMode Demo und Tests"
|
||||
u"<2011-08-22 Mon>"]
|
||||
headings = [Heading.parse_heading_from_data(tmp, [u'TODO'])]
|
||||
filtered = list(filter_items(headings,
|
||||
[is_within_week_and_active_todo]))
|
||||
self.assertEqual(len(filtered), 1)
|
||||
self.assertEqual(headings, filtered)
|
||||
|
||||
tmp = [Heading.parse_heading_from_data([u"** DONE something <2011-08-10 Wed>"], [u'TODO']),
|
||||
Heading.parse_heading_from_data([u"*** TODO rsitenaoritns more <2011-08-25 Thu>"], [u'TODO']),
|
||||
Heading.parse_heading_from_data([u"*** DONE some more <2011-08-25 Thu>"], [u'TODO']),
|
||||
Heading.parse_heading_from_data([u"*** TODO some more <2011-08-25 Thu>"], [u'TODO']),
|
||||
Heading.parse_heading_from_data([u"** DONE something2 <2011-08-10 Wed>"], [u'TODO'])
|
||||
]
|
||||
for h in tmp:
|
||||
headings.append(h)
|
||||
|
||||
filtered = list(filter_items(headings,
|
||||
[is_within_week_and_active_todo]))
|
||||
self.assertEqual(len(filtered), 3)
|
||||
self.assertEqual(filtered, [headings[0], headings[2], headings[4]])
|
||||
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(AgendaFilterTestCase)
|
||||
33
dot_vim/plugged/vim-orgmode/tests/test_libbase.py
Normal file
33
dot_vim/plugged/vim-orgmode/tests/test_libbase.py
Normal file
@@ -0,0 +1,33 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
from orgmode.liborgmode.base import Direction, get_domobj_range
|
||||
from orgmode.liborgmode.headings import Heading
|
||||
|
||||
|
||||
class LibBaseTestCase(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.case1 = """
|
||||
* head1
|
||||
heading body
|
||||
for testing
|
||||
* head2
|
||||
** head3
|
||||
""".split("\n")
|
||||
|
||||
def test_base_functions(self):
|
||||
# direction FORWARD
|
||||
(start, end) = get_domobj_range(content=self.case1, position=1, identify_fun=Heading.identify_heading)
|
||||
self.assertEqual((start, end), (1, 3))
|
||||
(start, end) = get_domobj_range(content=self.case1, position=3, direction=Direction.BACKWARD, \
|
||||
identify_fun=Heading.identify_heading)
|
||||
self.assertEqual((start, end), (1, 3))
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader() \
|
||||
.loadTestsFromTestCase(
|
||||
LibBaseTestCase)
|
||||
130
dot_vim/plugged/vim-orgmode/tests/test_libcheckbox.py
Normal file
130
dot_vim/plugged/vim-orgmode/tests/test_libcheckbox.py
Normal file
@@ -0,0 +1,130 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
import vim
|
||||
from orgmode.liborgmode.checkboxes import Checkbox
|
||||
from orgmode._vim import ORGMODE
|
||||
|
||||
from orgmode.py3compat.encode_compatibility import *
|
||||
|
||||
def set_vim_buffer(buf=None, cursor=(2, 0), bufnr=0):
|
||||
if buf is None:
|
||||
buf = []
|
||||
vim.current.buffer[:] = buf
|
||||
vim.current.window.cursor = cursor
|
||||
vim.current.buffer.number = bufnr
|
||||
|
||||
|
||||
class CheckboxTestCase(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
counter = 0
|
||||
vim.CMDHISTORY = []
|
||||
vim.CMDRESULTS = {}
|
||||
vim.EVALHISTORY = []
|
||||
vim.EVALRESULTS = {
|
||||
# no org_todo_keywords for b
|
||||
u_encode(u'exists("b:org_todo_keywords")'): u_encode('0'),
|
||||
# global values for org_todo_keywords
|
||||
u_encode(u'exists("g:org_todo_keywords")'): u_encode('1'),
|
||||
u_encode(u'g:org_todo_keywords'): [u_encode(u'TODO'), u_encode(u'|'), u_encode(u'DONE')],
|
||||
u_encode(u'exists("g:org_improve_split_heading")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_improve_split_heading")'): u_encode(u'0'),
|
||||
u_encode(u'exists("g:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("*repeat#set()")'): u_encode(u'0'),
|
||||
u_encode(u'b:changedtick'): u_encode(u'%d' % counter),
|
||||
u_encode(u'&ts'): u_encode(u'8'),
|
||||
u_encode(u'exists("g:org_tag_column")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_tag_column")'): u_encode(u'0'),
|
||||
u_encode(u"v:count"): u_encode(u'0')}
|
||||
|
||||
self.c1 = """
|
||||
* heading1 [/]
|
||||
- [-] checkbox1 [%]
|
||||
- [X] checkbox2
|
||||
- [ ] checkbox3
|
||||
- [X] checkbox4
|
||||
""".split("\n")
|
||||
|
||||
self.c2 = """
|
||||
* heading1
|
||||
- [ ] checkbox1
|
||||
- [ ] checkbox2
|
||||
- [ ] checkbox3
|
||||
- [ ] checkbox4
|
||||
- [ ] checkbox5
|
||||
- [ ] checkbox6
|
||||
""".split("\n")
|
||||
|
||||
def test_init(self):
|
||||
# test initialize Checkbox
|
||||
c = Checkbox(level=1, title="checkbox1")
|
||||
self.assertEqual(str(c), " - [ ] checkbox1")
|
||||
c = Checkbox(level=3, title="checkbox2", status="[X]")
|
||||
self.assertEqual(str(c), " - [X] checkbox2")
|
||||
|
||||
def test_basic(self):
|
||||
bufnr = 1
|
||||
set_vim_buffer(buf=self.c1, bufnr=bufnr)
|
||||
h = ORGMODE.get_document(bufnr=bufnr).current_heading()
|
||||
h.init_checkboxes()
|
||||
|
||||
c = h.current_checkbox(position=2)
|
||||
self.assertEqual(str(c), self.c1[2])
|
||||
self.assertFalse(c.are_children_all(Checkbox.STATUS_ON))
|
||||
self.assertTrue(c.is_child_one(Checkbox.STATUS_OFF))
|
||||
self.assertFalse(c.are_siblings_all(Checkbox.STATUS_ON))
|
||||
|
||||
for child in c.all_children():
|
||||
pass
|
||||
for sibling in c.all_siblings():
|
||||
pass
|
||||
c = h.current_checkbox(position=3)
|
||||
new_checkbox = c.copy()
|
||||
self.assertEqual(str(c), self.c1[3])
|
||||
c.get_parent_list()
|
||||
c.get_index_in_parent_list()
|
||||
|
||||
def test_identify(self):
|
||||
# test identify_checkbox
|
||||
self.assertEqual(Checkbox.identify_checkbox(self.c1[2]), 2)
|
||||
self.assertEqual(Checkbox.identify_checkbox(self.c1[3]), 8)
|
||||
# check for corner case
|
||||
self.assertEqual(Checkbox.identify_checkbox(" - [ ]"), 1)
|
||||
|
||||
def test_toggle(self):
|
||||
bufnr = 2
|
||||
# test init_checkboxes
|
||||
set_vim_buffer(buf=self.c1, bufnr=bufnr)
|
||||
h = ORGMODE.get_document(bufnr=bufnr).current_heading()
|
||||
h.init_checkboxes()
|
||||
|
||||
# toggle checkbox
|
||||
c = h.current_checkbox(position=4)
|
||||
c.toggle()
|
||||
self.assertEqual(str(c), " - [X] checkbox3")
|
||||
c.toggle()
|
||||
self.assertEqual(str(c), " - [ ] checkbox3")
|
||||
|
||||
(total, on) = c.all_siblings_status()
|
||||
self.assertEqual((total, on), (2, 1))
|
||||
|
||||
def test_subtasks(self):
|
||||
bufnr = 3
|
||||
set_vim_buffer(buf=self.c1, bufnr=bufnr)
|
||||
h = ORGMODE.get_document(bufnr=bufnr).current_heading()
|
||||
h.init_checkboxes()
|
||||
c = h.current_checkbox(position=3)
|
||||
c.toggle()
|
||||
c = h.current_checkbox(position=2)
|
||||
(total, on) = c.all_siblings_status()
|
||||
c.update_subtasks(total=total, on=on)
|
||||
self.assertEqual(str(c), " - [-] checkbox1 [50%]")
|
||||
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(CheckboxTestCase)
|
||||
154
dot_vim/plugged/vim-orgmode/tests/test_libheading.py
Normal file
154
dot_vim/plugged/vim-orgmode/tests/test_libheading.py
Normal file
@@ -0,0 +1,154 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
from orgmode.liborgmode.headings import Heading
|
||||
from orgmode.liborgmode.orgdate import OrgDate
|
||||
from orgmode.liborgmode.orgdate import OrgDateTime
|
||||
|
||||
|
||||
class TestHeadingRecognizeDatesInHeading(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.allowed_todo_states = ["TODO"]
|
||||
|
||||
tmp = ["* This heading is earlier <2011-08-24 Wed>"]
|
||||
self.h1 = Heading.parse_heading_from_data(tmp, self.allowed_todo_states)
|
||||
|
||||
tmp = ["* This heading is later <2011-08-25 Thu>"]
|
||||
self.h2 = Heading.parse_heading_from_data(tmp, self.allowed_todo_states)
|
||||
|
||||
tmp = ["* This heading is later <2011-08-25 Thu 10:20>"]
|
||||
self.h2_datetime = Heading.parse_heading_from_data(tmp, self.allowed_todo_states)
|
||||
|
||||
tmp = ["* This heading is later <2011-08-26 Fri 10:20>"]
|
||||
self.h3 = Heading.parse_heading_from_data(tmp, self.allowed_todo_states)
|
||||
|
||||
tmp = ["* This heading has no date and should be later than the rest"]
|
||||
self.h_no_date = Heading.parse_heading_from_data(tmp,
|
||||
self.allowed_todo_states)
|
||||
|
||||
def test_heading_parsing_no_date(self):
|
||||
"""""
|
||||
'text' doesn't contain any valid date.
|
||||
"""
|
||||
text = ["* TODO This is a test :hallo:"]
|
||||
h = Heading.parse_heading_from_data(text, self.allowed_todo_states)
|
||||
self.assertEqual(None, h.active_date)
|
||||
|
||||
text = ["* TODO This is a test <2011-08-25>"]
|
||||
h = Heading.parse_heading_from_data(text, self.allowed_todo_states)
|
||||
self.assertEqual(None, h.active_date)
|
||||
|
||||
text = ["* TODO This is a test <2011-08-25 Wednesday>"]
|
||||
h = Heading.parse_heading_from_data(text, self.allowed_todo_states)
|
||||
self.assertEqual(None, h.active_date)
|
||||
|
||||
text = ["* TODO This is a test <20110825>"]
|
||||
h = Heading.parse_heading_from_data(text, self.allowed_todo_states)
|
||||
self.assertEqual(None, h.active_date)
|
||||
|
||||
def test_heading_parsing_with_date(self):
|
||||
"""""
|
||||
'text' does contain valid dates.
|
||||
"""
|
||||
# orgdate
|
||||
text = ["* TODO This is a test <2011-08-24 Wed> :hallo:"]
|
||||
odate = OrgDate(True, 2011, 8, 24)
|
||||
h = Heading.parse_heading_from_data(text, self.allowed_todo_states)
|
||||
self.assertEqual(odate, h.active_date)
|
||||
|
||||
# orgdatetime
|
||||
text = ["* TODO This is a test <2011-08-25 Thu 10:10> :hallo:"]
|
||||
odate = OrgDateTime(True, 2011, 8, 25, 10, 10)
|
||||
h = Heading.parse_heading_from_data(text, self.allowed_todo_states)
|
||||
self.assertEqual(odate, h.active_date)
|
||||
|
||||
def test_heading_parsing_with_date_and_body(self):
|
||||
"""""
|
||||
'text' contains valid dates (in the body).
|
||||
"""
|
||||
# orgdatetime
|
||||
text = ["* TODO This is a test <2011-08-25 Thu 10:10> :hallo:",
|
||||
"some body text",
|
||||
"some body text"]
|
||||
h = Heading.parse_heading_from_data(text, self.allowed_todo_states)
|
||||
self.assertTrue(isinstance(h.active_date, OrgDateTime))
|
||||
self.assertEqual("<2011-08-25 Thu 10:10>", str(h.active_date))
|
||||
|
||||
text = ["* TODO This is a test :hallo:",
|
||||
"some body text",
|
||||
"some body text<2011-08-25 Thu 10:10>"]
|
||||
h = Heading.parse_heading_from_data(text, self.allowed_todo_states)
|
||||
self.assertTrue(isinstance(h.active_date, OrgDateTime))
|
||||
self.assertEqual("<2011-08-25 Thu 10:10>", str(h.active_date))
|
||||
|
||||
text = ["* TODO This is a test :hallo:",
|
||||
"some body text <2011-08-24 Wed>",
|
||||
"some body text<2011-08-25 Thu 10:10>"]
|
||||
h = Heading.parse_heading_from_data(text, self.allowed_todo_states)
|
||||
odate = OrgDate(True, 2011, 8, 24)
|
||||
self.assertEqual(odate, h.active_date)
|
||||
|
||||
def test_less_than_for_dates_in_heading(self):
|
||||
self.assertTrue(self.h1 < self.h2)
|
||||
self.assertTrue(self.h1 < self.h3)
|
||||
self.assertTrue(self.h1 < self.h_no_date)
|
||||
self.assertTrue(self.h2 < self.h_no_date)
|
||||
self.assertTrue(self.h2 < self.h3)
|
||||
self.assertTrue(self.h3 < self.h_no_date)
|
||||
|
||||
self.assertFalse(self.h2 < self.h1)
|
||||
self.assertFalse(self.h3 < self.h2)
|
||||
|
||||
def test_less_equal_for_dates_in_heading(self):
|
||||
self.assertTrue(self.h1 <= self.h2)
|
||||
self.assertTrue(self.h1 <= self.h_no_date)
|
||||
self.assertTrue(self.h2 <= self.h_no_date)
|
||||
self.assertTrue(self.h2 <= self.h2_datetime)
|
||||
self.assertTrue(self.h2 <= self.h3)
|
||||
|
||||
def test_greate_than_for_dates_in_heading(self):
|
||||
self.assertTrue(self.h2 > self.h1)
|
||||
self.assertTrue(self.h_no_date > self.h1)
|
||||
self.assertTrue(self.h_no_date > self.h2)
|
||||
|
||||
self.assertFalse(self.h2 > self.h2_datetime)
|
||||
|
||||
def test_greate_equal_for_dates_in_heading(self):
|
||||
self.assertTrue(self.h2 >= self.h1)
|
||||
self.assertTrue(self.h_no_date >= self.h1)
|
||||
self.assertTrue(self.h_no_date >= self.h2)
|
||||
self.assertTrue(self.h2 >= self.h2_datetime)
|
||||
|
||||
def test_sorting_of_headings(self):
|
||||
"""Headings should be sortable."""
|
||||
self.assertEqual([self.h1, self.h2], sorted([self.h2, self.h1]))
|
||||
|
||||
self.assertEqual([self.h1, self.h2_datetime],
|
||||
sorted([self.h2_datetime, self.h1]))
|
||||
|
||||
self.assertEqual([self.h2_datetime, self.h2],
|
||||
sorted([self.h2_datetime, self.h2]))
|
||||
|
||||
self.assertEqual([self.h1, self.h2], sorted([self.h1, self.h2]))
|
||||
|
||||
self.assertEqual([self.h1, self.h_no_date],
|
||||
sorted([self.h1, self.h_no_date]))
|
||||
|
||||
self.assertEqual([self.h1, self.h_no_date],
|
||||
sorted([self.h_no_date, self.h1]))
|
||||
|
||||
self.assertEqual([self.h1, self.h2, self.h_no_date],
|
||||
sorted([self.h2, self.h_no_date, self.h1]))
|
||||
|
||||
self.assertEqual(
|
||||
[self.h1, self.h2_datetime, self.h2, self.h3, self.h_no_date],
|
||||
sorted([self.h2_datetime, self.h3, self.h2, self.h_no_date, self.h1]))
|
||||
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(
|
||||
TestHeadingRecognizeDatesInHeading)
|
||||
51
dot_vim/plugged/vim-orgmode/tests/test_liborgdate.py
Normal file
51
dot_vim/plugged/vim-orgmode/tests/test_liborgdate.py
Normal file
@@ -0,0 +1,51 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import date
|
||||
|
||||
sys.path.append(u'../ftplugin')
|
||||
from orgmode.liborgmode.orgdate import OrgDate
|
||||
|
||||
from orgmode.py3compat.unicode_compatibility import *
|
||||
|
||||
class OrgDateTestCase(unittest.TestCase):
|
||||
u"""
|
||||
Tests all the functionality of the OrgDate
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
self.date = date(2011, 8, 29)
|
||||
self.year = 2011
|
||||
self.month = 8
|
||||
self.day = 29
|
||||
self.text = u'<2011-08-29 Mon>'
|
||||
self.textinactive = u'[2011-08-29 Mon]'
|
||||
|
||||
def test_OrgDate_ctor_active(self):
|
||||
u"""OrdDate should be created."""
|
||||
today = date.today()
|
||||
od = OrgDate(True, today.year, today.month, today.day)
|
||||
self.assertTrue(isinstance(od, OrgDate))
|
||||
self.assertTrue(od.active)
|
||||
|
||||
def test_OrgDate_ctor_inactive(self):
|
||||
u"""OrdDate should be created."""
|
||||
today = date.today()
|
||||
od = OrgDate(False, today.year, today.month, today.day)
|
||||
self.assertTrue(isinstance(od, OrgDate))
|
||||
self.assertFalse(od.active)
|
||||
|
||||
def test_OrdDate_str_active(self):
|
||||
u"""Representation of OrgDates"""
|
||||
od = OrgDate(True, self.year, self.month, self.day)
|
||||
self.assertEqual(self.text, unicode(od))
|
||||
|
||||
def test_OrdDate_str_inactive(self):
|
||||
od = OrgDate(False, self.year, self.month, self.day)
|
||||
self.assertEqual(self.textinactive, unicode(od))
|
||||
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(OrgDateTestCase)
|
||||
246
dot_vim/plugged/vim-orgmode/tests/test_liborgdate_parsing.py
Normal file
246
dot_vim/plugged/vim-orgmode/tests/test_liborgdate_parsing.py
Normal file
@@ -0,0 +1,246 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
sys.path.append(u'../ftplugin')
|
||||
from orgmode.liborgmode.orgdate import get_orgdate
|
||||
from orgmode.liborgmode.orgdate import OrgDate
|
||||
from orgmode.liborgmode.orgdate import OrgDateTime
|
||||
from orgmode.liborgmode.orgdate import OrgTimeRange
|
||||
|
||||
from orgmode.py3compat.unicode_compatibility import *
|
||||
|
||||
class OrgDateParsingTestCase(unittest.TestCase):
|
||||
u"""
|
||||
Tests the functionality of the parsing function of OrgDate.
|
||||
|
||||
Mostly function get_orgdate().
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
self.text = u'<2011-08-29 Mon>'
|
||||
self.textinactive = u'[2011-08-29 Mon]'
|
||||
|
||||
def test_get_orgdate_parsing_active(self):
|
||||
u"""
|
||||
get_orgdate should recognize all orgdates in a given text
|
||||
"""
|
||||
result = get_orgdate(self.text)
|
||||
self.assertNotEqual(result, None)
|
||||
self.assertTrue(isinstance(result, OrgDate))
|
||||
self.assertTrue(isinstance(get_orgdate(u"<2011-08-30 Tue>"), OrgDate))
|
||||
self.assertEqual(get_orgdate(u"<2011-08-30 Tue>").year, 2011)
|
||||
self.assertEqual(get_orgdate(u"<2011-08-30 Tue>").month, 8)
|
||||
self.assertEqual(get_orgdate(u"<2011-08-30 Tue>").day, 30)
|
||||
self.assertTrue(get_orgdate(u"<2011-08-30 Tue>").active)
|
||||
|
||||
datestr = u"This date <2011-08-30 Tue> is embedded"
|
||||
self.assertTrue(isinstance(get_orgdate(datestr), OrgDate))
|
||||
|
||||
|
||||
def test_get_orgdatetime_parsing_active(self):
|
||||
u"""
|
||||
get_orgdate should recognize all orgdatetimes in a given text
|
||||
"""
|
||||
result = get_orgdate(u"<2011-09-12 Mon 10:20>")
|
||||
self.assertNotEqual(result, None)
|
||||
self.assertTrue(isinstance(result, OrgDateTime))
|
||||
self.assertEqual(result.year, 2011)
|
||||
self.assertEqual(result.month, 9)
|
||||
self.assertEqual(result.day, 12)
|
||||
self.assertEqual(result.hour, 10)
|
||||
self.assertEqual(result.minute, 20)
|
||||
self.assertTrue(result.active)
|
||||
|
||||
result = get_orgdate(u"some datetime <2011-09-12 Mon 10:20> stuff")
|
||||
self.assertTrue(isinstance(result, OrgDateTime))
|
||||
|
||||
|
||||
def test_get_orgtimerange_parsing_active(self):
|
||||
u"""
|
||||
get_orgdate should recognize all orgtimeranges in a given text
|
||||
"""
|
||||
daterangestr = u"<2011-09-12 Mon>--<2011-09-13 Tue>"
|
||||
result = get_orgdate(daterangestr)
|
||||
self.assertNotEqual(result, None)
|
||||
self.assertTrue(isinstance(result, OrgTimeRange))
|
||||
self.assertEqual(unicode(result), daterangestr)
|
||||
self.assertTrue(result.active)
|
||||
|
||||
daterangestr = u"<2011-09-12 Mon 10:20>--<2011-09-13 Tue 13:20>"
|
||||
result = get_orgdate(daterangestr)
|
||||
self.assertNotEqual(result, None)
|
||||
self.assertTrue(isinstance(result, OrgTimeRange))
|
||||
self.assertEqual(unicode(result), daterangestr)
|
||||
self.assertTrue(result.active)
|
||||
|
||||
daterangestr = u"<2011-09-12 Mon 10:20-13:20>"
|
||||
result = get_orgdate(daterangestr)
|
||||
self.assertNotEqual(result, None)
|
||||
self.assertTrue(isinstance(result, OrgTimeRange))
|
||||
self.assertEqual(unicode(result), daterangestr)
|
||||
self.assertTrue(result.active)
|
||||
|
||||
def test_get_orgdate_parsing_inactive(self):
|
||||
u"""
|
||||
get_orgdate should recognize all inactive orgdates in a given text
|
||||
"""
|
||||
result = get_orgdate(self.textinactive)
|
||||
self.assertNotEqual(result, None)
|
||||
self.assertTrue(isinstance(result, OrgDate))
|
||||
self.assertTrue(isinstance(get_orgdate(u"[2011-08-30 Tue]"), OrgDate))
|
||||
self.assertEqual(get_orgdate(u"[2011-08-30 Tue]").year, 2011)
|
||||
self.assertEqual(get_orgdate(u"[2011-08-30 Tue]").month, 8)
|
||||
self.assertEqual(get_orgdate(u"[2011-08-30 Tue]").day, 30)
|
||||
self.assertFalse(get_orgdate(u"[2011-08-30 Tue]").active)
|
||||
|
||||
datestr = u"This date [2011-08-30 Tue] is embedded"
|
||||
self.assertTrue(isinstance(get_orgdate(datestr), OrgDate))
|
||||
|
||||
def test_get_orgdatetime_parsing_passive(self):
|
||||
u"""
|
||||
get_orgdate should recognize all orgdatetimes in a given text
|
||||
"""
|
||||
result = get_orgdate(u"[2011-09-12 Mon 10:20]")
|
||||
self.assertNotEqual(result, None)
|
||||
self.assertTrue(isinstance(result, OrgDateTime))
|
||||
self.assertEqual(result.year, 2011)
|
||||
self.assertEqual(result.month, 9)
|
||||
self.assertEqual(result.day, 12)
|
||||
self.assertEqual(result.hour, 10)
|
||||
self.assertEqual(result.minute, 20)
|
||||
self.assertFalse(result.active)
|
||||
|
||||
result = get_orgdate(u"some datetime [2011-09-12 Mon 10:20] stuff")
|
||||
self.assertTrue(isinstance(result, OrgDateTime))
|
||||
|
||||
def test_get_orgdate_parsing_with_list_of_texts(self):
|
||||
u"""
|
||||
get_orgdate should return the first date in the list.
|
||||
"""
|
||||
datelist = [u"<2011-08-29 Mon>"]
|
||||
result = get_orgdate(datelist)
|
||||
self.assertNotEquals(result, None)
|
||||
self.assertTrue(isinstance(result, OrgDate))
|
||||
self.assertEqual(result.year, 2011)
|
||||
self.assertEqual(result.month, 8)
|
||||
self.assertEqual(result.day, 29)
|
||||
|
||||
datelist = [u"<2011-08-29 Mon>",
|
||||
u"<2012-03-30 Fri>"]
|
||||
result = get_orgdate(datelist)
|
||||
self.assertNotEquals(result, None)
|
||||
self.assertTrue(isinstance(result, OrgDate))
|
||||
self.assertEqual(result.year, 2011)
|
||||
self.assertEqual(result.month, 8)
|
||||
self.assertEqual(result.day, 29)
|
||||
|
||||
datelist = [u"some <2011-08-29 Mon>text",
|
||||
u"<2012-03-30 Fri> is here"]
|
||||
result = get_orgdate(datelist)
|
||||
self.assertNotEquals(result, None)
|
||||
self.assertTrue(isinstance(result, OrgDate))
|
||||
self.assertEqual(result.year, 2011)
|
||||
self.assertEqual(result.month, 8)
|
||||
self.assertEqual(result.day, 29)
|
||||
|
||||
datelist = [u"here is no date",
|
||||
u"some <2011-08-29 Mon>text",
|
||||
u"<2012-03-30 Fri> is here"]
|
||||
result = get_orgdate(datelist)
|
||||
self.assertNotEquals(result, None)
|
||||
self.assertTrue(isinstance(result, OrgDate))
|
||||
self.assertEqual(result.year, 2011)
|
||||
self.assertEqual(result.month, 8)
|
||||
self.assertEqual(result.day, 29)
|
||||
|
||||
datelist = [u"here is no date",
|
||||
u"some <2011-08-29 Mon 20:10> text",
|
||||
u"<2012-03-30 Fri> is here"]
|
||||
result = get_orgdate(datelist)
|
||||
self.assertNotEquals(result, None)
|
||||
self.assertTrue(isinstance(result, OrgDateTime))
|
||||
self.assertEqual(result.year, 2011)
|
||||
self.assertEqual(result.month, 8)
|
||||
self.assertEqual(result.day, 29)
|
||||
self.assertEqual(result.hour, 20)
|
||||
self.assertEqual(result.minute, 10)
|
||||
|
||||
def test_get_orgdate_parsing_with_invalid_input(self):
|
||||
self.assertEquals(get_orgdate(u"NONSENSE"), None)
|
||||
self.assertEquals(get_orgdate(u"No D<2011- Date 08-29 Mon>"), None)
|
||||
self.assertEquals(get_orgdate(u"2011-08-r9 Mon]"), None)
|
||||
self.assertEquals(get_orgdate(u"<2011-08-29 Mon"), None)
|
||||
self.assertEquals(get_orgdate(u"<2011-08-29 Mon]"), None)
|
||||
self.assertEquals(get_orgdate(u"2011-08-29 Mon"), None)
|
||||
self.assertEquals(get_orgdate(u"2011-08-29"), None)
|
||||
self.assertEquals(get_orgdate(u"2011-08-29 mon"), None)
|
||||
self.assertEquals(get_orgdate(u"<2011-08-29 mon>"), None)
|
||||
|
||||
self.assertEquals(get_orgdate(u"wrong date embedded <2011-08-29 mon>"), None)
|
||||
self.assertEquals(get_orgdate(u"wrong date <2011-08-29 mon>embedded "), None)
|
||||
|
||||
def test_get_orgdate_parsing_with_invalid_dates(self):
|
||||
u"""
|
||||
Something like <2011-14-29 Mon> (invalid dates, they don't exist)
|
||||
should not be parsed
|
||||
"""
|
||||
datestr = u"<2011-14-30 Tue>"
|
||||
self.assertEqual(get_orgdate(datestr), None)
|
||||
|
||||
datestr = u"<2012-03-40 Tue>"
|
||||
self.assertEqual(get_orgdate(datestr), None)
|
||||
|
||||
datestr = u"<2012-03-40 Tue 24:70>"
|
||||
self.assertEqual(get_orgdate(datestr), None)
|
||||
|
||||
def test_get_orgdate_parsing_with_utf8(self):
|
||||
u"""
|
||||
get_orgdate should recognize all orgdates within a given utf-8 text
|
||||
"""
|
||||
result = get_orgdate(u'<2016-05-07 Sáb>')
|
||||
self.assertNotEqual(result, None)
|
||||
self.assertTrue(isinstance(result, OrgDate))
|
||||
self.assertEqual(result.year, 2016)
|
||||
self.assertEqual(result.month, 5)
|
||||
self.assertEqual(result.day, 7)
|
||||
self.assertTrue(result.active)
|
||||
|
||||
datestr = u"This date <2016-05-07 Sáb> is embedded"
|
||||
self.assertTrue(isinstance(get_orgdate(datestr), OrgDate))
|
||||
|
||||
result = get_orgdate(u'[2016-05-07 Sáb]')
|
||||
self.assertFalse(result.active)
|
||||
|
||||
datestr = u"This date [2016-05-07 Sáb] is embedded"
|
||||
self.assertTrue(isinstance(get_orgdate(datestr), OrgDate))
|
||||
|
||||
def test_get_orgdatetime_parsing_with_utf8(self):
|
||||
u"""
|
||||
get_orgdate should recognize all orgdatetimes in a given utf-8 text
|
||||
"""
|
||||
result = get_orgdate(u"<2016-05-07 Sáb 10:20>")
|
||||
self.assertNotEqual(result, None)
|
||||
self.assertTrue(isinstance(result, OrgDateTime))
|
||||
self.assertEqual(result.year, 2016)
|
||||
self.assertEqual(result.month, 5)
|
||||
self.assertEqual(result.day, 7)
|
||||
self.assertEqual(result.hour, 10)
|
||||
self.assertEqual(result.minute, 20)
|
||||
self.assertTrue(result.active)
|
||||
|
||||
result = get_orgdate(u"some datetime <2016-05-07 Sáb 10:20> stuff")
|
||||
self.assertTrue(isinstance(result, OrgDateTime))
|
||||
|
||||
result = get_orgdate(u"[2016-05-07 Sáb 10:20]")
|
||||
self.assertFalse(result.active)
|
||||
|
||||
result = get_orgdate(u"some datetime [2016-05-07 Sáb 10:20] stuff")
|
||||
self.assertTrue(isinstance(result, OrgDateTime))
|
||||
|
||||
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(OrgDateParsingTestCase)
|
||||
50
dot_vim/plugged/vim-orgmode/tests/test_liborgdate_utf8.py
Normal file
50
dot_vim/plugged/vim-orgmode/tests/test_liborgdate_utf8.py
Normal file
@@ -0,0 +1,50 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import sys
|
||||
import unittest
|
||||
import locale
|
||||
import threading
|
||||
|
||||
from datetime import date
|
||||
from contextlib import contextmanager
|
||||
|
||||
from orgmode.py3compat.unicode_compatibility import *
|
||||
|
||||
sys.path.append(u'../ftplugin')
|
||||
from orgmode.liborgmode.orgdate import OrgDate
|
||||
|
||||
class OrgDateUtf8TestCase(unittest.TestCase):
|
||||
u"""
|
||||
Tests OrgDate with utf-8 enabled locales
|
||||
"""
|
||||
LOCALE_LOCK = threading.Lock()
|
||||
UTF8_LOCALE = "fr_FR.utf-8"
|
||||
|
||||
@contextmanager
|
||||
def setlocale(self, name):
|
||||
with self.LOCALE_LOCK:
|
||||
saved = locale.setlocale(locale.LC_ALL)
|
||||
try:
|
||||
yield locale.setlocale(locale.LC_ALL, name)
|
||||
finally:
|
||||
locale.setlocale(locale.LC_ALL, saved)
|
||||
|
||||
def setUp(self):
|
||||
self.year = 2016
|
||||
self.month = 5
|
||||
self.day = 7
|
||||
self.text = u'<2016-05-07 sam.>'
|
||||
self.textinactive = u'[2016-05-07 sam.]'
|
||||
|
||||
def test_OrdDate_str_unicode_active(self):
|
||||
with self.setlocale(self.UTF8_LOCALE):
|
||||
od = OrgDate(True, self.year, self.month, self.day)
|
||||
self.assertEqual(self.text, unicode(od))
|
||||
|
||||
def test_OrdDate_str_unicode_inactive(self):
|
||||
with self.setlocale(self.UTF8_LOCALE):
|
||||
od = OrgDate(False, self.year, self.month, self.day)
|
||||
self.assertEqual(self.textinactive, unicode(od))
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(OrgDateUtf8TestCase)
|
||||
47
dot_vim/plugged/vim-orgmode/tests/test_liborgdatetime.py
Normal file
47
dot_vim/plugged/vim-orgmode/tests/test_liborgdatetime.py
Normal file
@@ -0,0 +1,47 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
sys.path.append(u'../ftplugin')
|
||||
from orgmode.liborgmode.orgdate import OrgDateTime
|
||||
|
||||
from orgmode.py3compat.unicode_compatibility import *
|
||||
|
||||
class OrgDateTimeTestCase(unittest.TestCase):
|
||||
u"""
|
||||
Tests all the functionality of the OrgDateTime
|
||||
"""
|
||||
|
||||
def test_OrgDateTime_ctor_active(self):
|
||||
u"""OrdDateTime should be created."""
|
||||
today = datetime.today()
|
||||
odt = OrgDateTime(True, today.year, today.month, today.day, today.hour,
|
||||
today.minute)
|
||||
self.assertTrue(isinstance(odt, OrgDateTime))
|
||||
self.assertTrue(odt.active)
|
||||
|
||||
def test_OrgDateTime_ctor_inactive(self):
|
||||
u"""OrdDateTime should be created."""
|
||||
today = datetime.today()
|
||||
odt = OrgDateTime(False, today.year, today.month, today.day, today.hour,
|
||||
today.minute)
|
||||
self.assertTrue(isinstance(odt, OrgDateTime))
|
||||
self.assertFalse(odt.active)
|
||||
|
||||
def test_OrdDateTime_str_active(self):
|
||||
u"""Representation of OrgDateTime"""
|
||||
t = 2011, 9, 8, 10, 20
|
||||
odt = OrgDateTime(False, t[0], t[1], t[2], t[3], t[4])
|
||||
self.assertEqual(u"[2011-09-08 Thu 10:20]", unicode(odt))
|
||||
|
||||
def test_OrdDateTime_str_inactive(self):
|
||||
u"""Representation of OrgDateTime"""
|
||||
t = 2011, 9, 8, 10, 20
|
||||
odt = OrgDateTime(True, t[0], t[1], t[2], t[3], t[4])
|
||||
self.assertEqual(u"<2011-09-08 Thu 10:20>", unicode(odt))
|
||||
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(OrgDateTimeTestCase)
|
||||
83
dot_vim/plugged/vim-orgmode/tests/test_liborgtimerange.py
Normal file
83
dot_vim/plugged/vim-orgmode/tests/test_liborgtimerange.py
Normal file
@@ -0,0 +1,83 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import date
|
||||
from datetime import datetime
|
||||
|
||||
sys.path.append(u'../ftplugin')
|
||||
from orgmode.liborgmode.orgdate import OrgTimeRange
|
||||
|
||||
|
||||
class OrgTimeRangeTestCase(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.date = date(2011, 8, 29)
|
||||
self.year = 2011
|
||||
self.month = 8
|
||||
self.day = 29
|
||||
self.text = '<2011-08-29 Mon>'
|
||||
self.textinactive = '[2011-08-29 Mon]'
|
||||
|
||||
def test_OrgTimeRange_ctor_active(self):
|
||||
u"""
|
||||
timerange should be created.
|
||||
"""
|
||||
start = date(2011, 9 , 12)
|
||||
end = date(2011, 9 , 13)
|
||||
timerange = OrgTimeRange(True, start, end)
|
||||
self.assertTrue(isinstance(timerange, OrgTimeRange))
|
||||
self.assertTrue(timerange.active)
|
||||
|
||||
def test_OrgTimeRange_ctor_inactive(self):
|
||||
u"""
|
||||
timerange should be created.
|
||||
"""
|
||||
start = date(2011, 9 , 12)
|
||||
end = date(2011, 9 , 13)
|
||||
timerange = OrgTimeRange(False, start, end)
|
||||
self.assertTrue(isinstance(timerange, OrgTimeRange))
|
||||
self.assertFalse(timerange.active)
|
||||
|
||||
def test_OrdDate_str_active(self):
|
||||
u"""Representation of OrgDates"""
|
||||
start = date(2011, 9 , 12)
|
||||
end = date(2011, 9 , 13)
|
||||
timerange = OrgTimeRange(True, start, end)
|
||||
expected = "<2011-09-12 Mon>--<2011-09-13 Tue>"
|
||||
self.assertEqual(str(timerange), expected)
|
||||
|
||||
start = datetime(2011, 9 , 12, 20, 00)
|
||||
end = datetime(2011, 9 , 13, 21, 59)
|
||||
timerange = OrgTimeRange(True, start, end)
|
||||
expected = "<2011-09-12 Mon 20:00>--<2011-09-13 Tue 21:59>"
|
||||
self.assertEqual(str(timerange), expected)
|
||||
|
||||
start = datetime(2011, 9 , 12, 20, 00)
|
||||
end = datetime(2011, 9 , 12, 21, 00)
|
||||
timerange = OrgTimeRange(True, start, end)
|
||||
expected = "<2011-09-12 Mon 20:00-21:00>"
|
||||
self.assertEqual(str(timerange), expected)
|
||||
|
||||
def test_OrdDate_str_inactive(self):
|
||||
u"""Representation of OrgDates"""
|
||||
start = date(2011, 9 , 12)
|
||||
end = date(2011, 9 , 13)
|
||||
timerange = OrgTimeRange(False, start, end)
|
||||
expected = "[2011-09-12 Mon]--[2011-09-13 Tue]"
|
||||
self.assertEqual(str(timerange), expected)
|
||||
|
||||
start = datetime(2011, 9 , 12, 20, 00)
|
||||
end = datetime(2011, 9 , 13, 21, 59)
|
||||
timerange = OrgTimeRange(False, start, end)
|
||||
expected = "[2011-09-12 Mon 20:00]--[2011-09-13 Tue 21:59]"
|
||||
self.assertEqual(str(timerange), expected)
|
||||
|
||||
start = datetime(2011, 9 , 12, 20, 00)
|
||||
end = datetime(2011, 9 , 12, 21, 00)
|
||||
timerange = OrgTimeRange(False, start, end)
|
||||
expected = "[2011-09-12 Mon 20:00-21:00]"
|
||||
self.assertEqual(str(timerange), expected)
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(OrgTimeRangeTestCase)
|
||||
172
dot_vim/plugged/vim-orgmode/tests/test_plugin_date.py
Normal file
172
dot_vim/plugged/vim-orgmode/tests/test_plugin_date.py
Normal file
@@ -0,0 +1,172 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
from datetime import date
|
||||
from datetime import datetime
|
||||
|
||||
from orgmode.plugins.Date import Date
|
||||
|
||||
|
||||
class DateTestCase(unittest.TestCase):
|
||||
u"""Tests all the functionality of the Date plugin.
|
||||
|
||||
Also see:
|
||||
http://orgmode.org/manual/The-date_002ftime-prompt.html#The-date_002ftime-prompt
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
self.d = date(2011, 5, 22)
|
||||
|
||||
def test_modify_time_with_None(self):
|
||||
# no modification should happen
|
||||
res = Date._modify_time(self.d, None)
|
||||
self.assertEquals(self.d, res)
|
||||
|
||||
def test_modify_time_with_dot(self):
|
||||
# no modification should happen
|
||||
res = Date._modify_time(self.d, u'.')
|
||||
self.assertEquals(self.d, res)
|
||||
|
||||
def test_modify_time_with_given_relative_days(self):
|
||||
# modifier and expected result
|
||||
test_data = [(u'+0d', self.d),
|
||||
(u'+1d', date(2011, 5, 23)),
|
||||
(u'+2d', date(2011, 5, 24)),
|
||||
(u'+7d', date(2011, 5, 29)),
|
||||
(u'+9d', date(2011, 5, 31)),
|
||||
(u'+10d', date(2011, 6, 1)),
|
||||
(u'7d', self.d)] # wrong format: plus is missing
|
||||
|
||||
for modifier, expected in test_data:
|
||||
self.assertEquals(expected, Date._modify_time(self.d, modifier))
|
||||
|
||||
def test_modify_time_with_given_relative_days_without_d(self):
|
||||
# modifier and expected result
|
||||
test_data = [(u'+0', self.d),
|
||||
(u'+1', date(2011, 5, 23)),
|
||||
(u'+2', date(2011, 5, 24)),
|
||||
(u'+7', date(2011, 5, 29)),
|
||||
(u'+9', date(2011, 5, 31)),
|
||||
(u'+10', date(2011, 6, 1))]
|
||||
|
||||
for modifier, expected in test_data:
|
||||
result = Date._modify_time(self.d, modifier)
|
||||
self.assertEquals(expected, result)
|
||||
|
||||
def test_modify_time_with_given_relative_weeks(self):
|
||||
# modifier and expected result
|
||||
test_data = [(u'+1w', date(2011, 5, 29)),
|
||||
(u'+2w', date(2011, 6, 5)),
|
||||
(u'+3w', date(2011, 6, 12)),
|
||||
(u'+3w', date(2011, 6, 12)),
|
||||
(u'+0w', self.d),
|
||||
(u'3w', self.d), # wrong format
|
||||
(u'+w', self.d)] # wrong format
|
||||
|
||||
for modifier, expected in test_data:
|
||||
self.assertEquals(expected, Date._modify_time(self.d, modifier))
|
||||
|
||||
def test_modify_time_with_given_relative_months(self):
|
||||
test_data = [(u'+0m', self.d),
|
||||
(u'+1m', date(2011, 6, 22)),
|
||||
(u'+2m', date(2011, 7, 22))]
|
||||
|
||||
for modifier, expected in test_data:
|
||||
self.assertEquals(expected, Date._modify_time(self.d, modifier))
|
||||
|
||||
def test_modify_time_with_given_relative_years(self):
|
||||
test_data = [(u'+1y', date(2012, 5, 22)),
|
||||
(u'+10y', date(2021, 5, 22)),
|
||||
(u'+0y', self.d)]
|
||||
|
||||
for modifier, expected in test_data:
|
||||
self.assertEquals(expected, Date._modify_time(self.d, modifier))
|
||||
|
||||
|
||||
def test_modify_time_with_given_weekday(self):
|
||||
# use custom day instead of self.d to ease testing
|
||||
cust_day = date(2011, 5, 25) # it's a Wednesday
|
||||
#print(cust_day.weekday()) # 2
|
||||
test_data = [(u'Thu', date(2011, 5, 26)),
|
||||
(u'thu', date(2011, 5, 26)),
|
||||
(u'tHU', date(2011, 5, 26)),
|
||||
(u'THU', date(2011, 5, 26)),
|
||||
(u'Fri', date(2011, 5, 27)),
|
||||
(u'sat', date(2011, 5, 28)),
|
||||
(u'sun', date(2011, 5, 29)),
|
||||
(u'mon', date(2011, 5, 30)),
|
||||
(u'tue', date(2011, 5, 31)),
|
||||
(u'wed', date(2011, 6, 1))]
|
||||
|
||||
for modifier, expected in test_data:
|
||||
self.assertEquals(expected, Date._modify_time(cust_day, modifier))
|
||||
|
||||
def test_modify_time_with_month_and_day(self):
|
||||
cust_date = date(2006, 6, 13)
|
||||
test_data = [(u'sep 15', date(2006, 9, 15)),
|
||||
(u'Sep 15', date(2006, 9, 15)),
|
||||
(u'SEP 15', date(2006, 9, 15)),
|
||||
(u'feb 15', date(2007, 2, 15)),
|
||||
(u'jan 1', date(2007, 1, 1)),
|
||||
(u'7/5', date(2006, 7, 5)),
|
||||
(u'2/5', date(2007, 2, 5)),]
|
||||
|
||||
for modifier, expected in test_data:
|
||||
self.assertEquals(expected, Date._modify_time(cust_date, modifier))
|
||||
|
||||
def test_modify_time_with_time(self):
|
||||
cust_date = date(2006, 6, 13)
|
||||
test_data = [(u'12:45', datetime(2006, 6, 13, 12, 45)),
|
||||
(u'1:45', datetime(2006, 6, 13, 1, 45)),
|
||||
(u'1:05', datetime(2006, 6, 13, 1, 5)),]
|
||||
|
||||
for modifier, expected in test_data:
|
||||
res = Date._modify_time(cust_date, modifier)
|
||||
self.assertTrue(isinstance(res, datetime))
|
||||
self.assertEquals(expected, res)
|
||||
|
||||
def test_modify_time_with_full_dates(self):
|
||||
result = Date._modify_time(self.d, u'2011-01-12')
|
||||
expected = date(2011, 1, 12)
|
||||
self.assertEquals(expected, result)
|
||||
|
||||
reults = Date._modify_time(self.d, u'2015-03-12')
|
||||
expected = date(2015, 3, 12)
|
||||
self.assertEquals(expected, reults)
|
||||
|
||||
cust_date = date(2006, 6, 13)
|
||||
test_data = [(u'3-2-5', date(2003, 2, 5)),
|
||||
(u'12-2-28', date(2012, 2, 28)),
|
||||
(u'2/5/3', date(2003, 2, 5)),
|
||||
(u'sep 12 9', date(2009, 9, 12)),
|
||||
(u'jan 2 99', date(2099, 1, 2)),]
|
||||
|
||||
for modifier, expected in test_data:
|
||||
self.assertEquals(expected, Date._modify_time(cust_date, modifier))
|
||||
|
||||
def test_modify_time_with_only_days(self):
|
||||
cust_date = date(2006, 6, 13)
|
||||
test_data = [(u'14', date(2006, 6, 14)),
|
||||
(u'12', date(2006, 7, 12)),
|
||||
(u'1', date(2006, 7, 1)),
|
||||
(u'29', date(2006, 6, 29)),]
|
||||
for modifier, expected in test_data:
|
||||
self.assertEquals(expected, Date._modify_time(cust_date, modifier))
|
||||
|
||||
def test_modify_time_with_day_and_time(self):
|
||||
cust_date = date(2006, 6, 13)
|
||||
test_data = [(u'+1 10:20', datetime(2006, 6, 14, 10, 20)),
|
||||
(u'+1w 10:20', datetime(2006, 6, 20, 10, 20)),
|
||||
(u'+2 10:30', datetime(2006, 6, 15, 10, 30)),
|
||||
(u'+2d 10:30', datetime(2006, 6, 15, 10, 30))]
|
||||
for modifier, expected in test_data:
|
||||
result = Date._modify_time(cust_date, modifier)
|
||||
self.assertEquals(expected, result)
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(DateTestCase)
|
||||
239
dot_vim/plugged/vim-orgmode/tests/test_plugin_edit_checkbox.py
Normal file
239
dot_vim/plugged/vim-orgmode/tests/test_plugin_edit_checkbox.py
Normal file
@@ -0,0 +1,239 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
import vim
|
||||
|
||||
from orgmode._vim import ORGMODE
|
||||
|
||||
from orgmode.py3compat.encode_compatibility import *
|
||||
|
||||
PLUGIN_NAME = u'EditCheckbox'
|
||||
|
||||
bufnr = 10
|
||||
|
||||
def set_vim_buffer(buf=None, cursor=(2, 0), bufnr=0):
|
||||
if buf is None:
|
||||
buf = []
|
||||
vim.current.buffer[:] = buf
|
||||
vim.current.window.cursor = cursor
|
||||
vim.current.buffer.number = bufnr
|
||||
|
||||
|
||||
counter = 0
|
||||
class EditCheckboxTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
if PLUGIN_NAME not in ORGMODE.plugins:
|
||||
ORGMODE.register_plugin(PLUGIN_NAME)
|
||||
self.editcheckbox = ORGMODE.plugins[PLUGIN_NAME]
|
||||
vim.EVALRESULTS = {
|
||||
# no org_todo_keywords for b
|
||||
u_encode(u'exists("b:org_todo_keywords")'): u_encode('0'),
|
||||
# global values for org_todo_keywords
|
||||
u_encode(u'exists("g:org_todo_keywords")'): u_encode('1'),
|
||||
u_encode(u'g:org_todo_keywords'): [u_encode(u'TODO'), u_encode(u'|'), u_encode(u'DONE')],
|
||||
u_encode(u'exists("g:org_improve_split_heading")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_improve_split_heading")'): u_encode(u'0'),
|
||||
u_encode(u'exists("g:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("*repeat#set()")'): u_encode(u'0'),
|
||||
u_encode(u'b:changedtick'): u_encode(u'%d' % counter),
|
||||
u_encode(u'&ts'): u_encode(u'8'),
|
||||
u_encode(u'exists("g:org_tag_column")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_tag_column")'): u_encode(u'0'),
|
||||
u_encode(u"v:count"): u_encode(u'0'),
|
||||
# jump to insert mode after adding heading/checkbox
|
||||
u_encode(u'exists("g:org_prefer_insert_mode")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_prefer_insert_mode")'): u_encode(u'0')}
|
||||
|
||||
self.c1 = u"""
|
||||
* heading1 [%]
|
||||
- [ ] checkbox1 [/]
|
||||
- [ ] checkbox2
|
||||
- [ ] checkbox3
|
||||
- [ ] checkbox4
|
||||
- [ ] checkbox5
|
||||
- [ ] checkbox6
|
||||
- [ ] checkbox7
|
||||
- [ ] checkbox8
|
||||
""".split(u'\n')
|
||||
|
||||
self.c2 = u"""
|
||||
* a checkbox list [%]
|
||||
- checkbox [0%]
|
||||
- [ ] test1
|
||||
- [ ] test2
|
||||
- [ ] test3
|
||||
""".split(u'\n')
|
||||
|
||||
self.c3 = u"""
|
||||
* heading
|
||||
1. [ ] another main task [%]
|
||||
- [ ] sub task 1
|
||||
- [ ] sub task 2
|
||||
2. [ ] another main task
|
||||
""".split(u'\n')
|
||||
|
||||
self.c4 = u"""
|
||||
* heading
|
||||
""".split(u'\n')
|
||||
|
||||
self.c5 = u"""
|
||||
* heading1
|
||||
1. item
|
||||
9. item
|
||||
}. item
|
||||
a. item
|
||||
z. item
|
||||
A. item
|
||||
Z. item
|
||||
aa. item
|
||||
""".split("\n")
|
||||
|
||||
def test_toggle(self):
|
||||
global bufnr
|
||||
bufnr += 1
|
||||
# test on self.c1
|
||||
set_vim_buffer(buf=self.c1, cursor=(6, 0), bufnr=bufnr)
|
||||
# update_checkboxes_status
|
||||
self.editcheckbox.update_checkboxes_status()
|
||||
self.assertEqual(vim.current.buffer[1], u"* heading1 [0%]")
|
||||
# toggle
|
||||
self.editcheckbox.toggle()
|
||||
self.assertEqual(vim.current.buffer[5], u" - [X] checkbox4")
|
||||
|
||||
bufnr += 1
|
||||
set_vim_buffer(buf=self.c1, cursor=(9, 0), bufnr=bufnr)
|
||||
# toggle and check checkbox status
|
||||
self.editcheckbox.toggle()
|
||||
self.assertEqual(vim.current.buffer[8], u" - [X] checkbox7")
|
||||
self.assertEqual(vim.current.buffer[7], u" - [-] checkbox6")
|
||||
self.assertEqual(vim.current.buffer[6], u" - [-] checkbox5")
|
||||
|
||||
# new_checkbox
|
||||
bufnr += 1
|
||||
set_vim_buffer(buf=self.c1, cursor=(9, 0), bufnr=bufnr)
|
||||
vim.current.window.cursor = (9, 0)
|
||||
self.assertEqual(vim.current.buffer[9], u' - [ ] checkbox8')
|
||||
self.editcheckbox.new_checkbox(below=True)
|
||||
# vim's buffer behave just opposite to Python's list when inserting a
|
||||
# new item. The new entry is appended in vim put prepended in Python!
|
||||
self.assertEqual(vim.current.buffer[10], u' - [ ] checkbox8')
|
||||
self.assertEqual(vim.current.buffer[9], u' - [ ] ')
|
||||
self.editcheckbox.update_checkboxes_status()
|
||||
|
||||
def test_no_status_checkbox(self):
|
||||
global bufnr
|
||||
bufnr += 1
|
||||
# test on self.c2
|
||||
set_vim_buffer(buf=self.c2, bufnr=bufnr)
|
||||
self.assertEqual(vim.current.buffer[2], u" - checkbox [0%]")
|
||||
# toggle
|
||||
vim.current.window.cursor = (4, 0)
|
||||
self.editcheckbox.toggle()
|
||||
self.assertEqual(vim.current.buffer[3], u" - [X] test1")
|
||||
|
||||
# self.editcheckbox.update_checkboxes_status()
|
||||
# see if the no status checkbox update its status
|
||||
self.assertEqual(vim.current.buffer[2], u" - checkbox [33%]")
|
||||
|
||||
def test_number_list(self):
|
||||
global bufnr
|
||||
bufnr += 1
|
||||
set_vim_buffer(buf=self.c3, bufnr=bufnr)
|
||||
vim.current.window.cursor = (6, 0)
|
||||
self.editcheckbox.toggle()
|
||||
self.assertEqual(vim.current.buffer[5], u" 2. [X] another main task")
|
||||
|
||||
def test_new_checkbox(self):
|
||||
global bufnr
|
||||
bufnr += 1
|
||||
set_vim_buffer(buf=self.c4, bufnr=bufnr)
|
||||
vim.current.window.cursor = (2, 1)
|
||||
self.editcheckbox.new_checkbox(below=True)
|
||||
self.assertEqual(vim.current.buffer[2], u" - [ ] ")
|
||||
|
||||
def test_item_decrement(self):
|
||||
global bufnr
|
||||
bufnr += 1
|
||||
set_vim_buffer(buf=self.c5, bufnr=bufnr)
|
||||
|
||||
vim.current.window.cursor = (3, 1)
|
||||
self.editcheckbox.new_checkbox(below=False, plain=True)
|
||||
self.assertEqual(vim.current.buffer[2], u" 0. ")
|
||||
self.assertEqual(vim.current.buffer[3], u" 1. item")
|
||||
|
||||
vim.current.window.cursor = (3, 1)
|
||||
self.editcheckbox.new_checkbox(below=False, plain=True)
|
||||
self.assertEqual(vim.current.buffer[1], u"* heading1")
|
||||
self.assertEqual(vim.current.buffer[2], u" 0. ")
|
||||
self.assertEqual(vim.current.buffer[3], u" 1. item")
|
||||
|
||||
vim.current.window.cursor = (5, 1)
|
||||
self.editcheckbox.new_checkbox(below=False, plain=True)
|
||||
self.assertEqual(vim.current.buffer[4], u" 8. ")
|
||||
self.assertEqual(vim.current.buffer[5], u" 9. item")
|
||||
|
||||
vim.current.window.cursor = (8, 1)
|
||||
self.editcheckbox.new_checkbox(below=False, plain=True)
|
||||
# no further decrement than a
|
||||
self.assertEqual(vim.current.buffer[6], u" }. item")
|
||||
self.assertEqual(vim.current.buffer[7], u" a. item")
|
||||
self.assertEqual(vim.current.buffer[8], u" z. item")
|
||||
|
||||
def test_item_decrementA(self):
|
||||
global bufnr
|
||||
bufnr += 1
|
||||
set_vim_buffer(buf=self.c5, bufnr=bufnr)
|
||||
vim.current.window.cursor = (8, 1)
|
||||
self.editcheckbox.new_checkbox(below=False, plain=True)
|
||||
# decrement from A to z
|
||||
self.assertEqual(vim.current.buffer[7], u" z. ")
|
||||
self.assertEqual(vim.current.buffer[8], u" A. item")
|
||||
|
||||
def test_item_increment(self):
|
||||
global bufnr
|
||||
bufnr += 1
|
||||
set_vim_buffer(buf=self.c5, bufnr=bufnr)
|
||||
|
||||
vim.current.window.cursor = (3, 1)
|
||||
self.editcheckbox.new_checkbox(below=True, plain=True)
|
||||
self.assertEqual(vim.current.buffer[2], u" 1. item")
|
||||
self.assertEqual(vim.current.buffer[3], u" 2. ")
|
||||
|
||||
vim.current.window.cursor = (5, 1)
|
||||
self.editcheckbox.new_checkbox(below=True, plain=True)
|
||||
self.assertEqual(vim.current.buffer[4], u" 9. item")
|
||||
self.assertEqual(vim.current.buffer[5], u" }. item")
|
||||
self.assertEqual(vim.current.buffer[6], u" 10. ")
|
||||
|
||||
def test_item_incrementz(self):
|
||||
global bufnr
|
||||
bufnr += 1
|
||||
set_vim_buffer(buf=self.c5, bufnr=bufnr)
|
||||
|
||||
vim.current.window.cursor = (6, 1)
|
||||
self.editcheckbox.new_checkbox(below=True, plain=True)
|
||||
self.assertEqual(vim.current.buffer[5], u" a. item")
|
||||
self.assertEqual(vim.current.buffer[6], u" b. ")
|
||||
|
||||
vim.current.window.cursor = (8, 1)
|
||||
self.editcheckbox.new_checkbox(below=True, plain=True)
|
||||
self.assertEqual(vim.current.buffer[7], u" z. item")
|
||||
self.assertEqual(vim.current.buffer[8], u" A. ")
|
||||
|
||||
vim.current.window.cursor = (11, 1)
|
||||
self.editcheckbox.new_checkbox(below=True, plain=True)
|
||||
self.assertEqual(vim.current.buffer[10], u" Z. item")
|
||||
self.assertEqual(vim.current.buffer[11], u" aa. item")
|
||||
self.assertEqual(vim.current.buffer[12], u"")
|
||||
|
||||
vim.current.window.cursor = (12, 1)
|
||||
self.editcheckbox.new_checkbox(below=True, plain=True)
|
||||
self.assertEqual(vim.current.buffer[11], u" aa. item")
|
||||
self.assertEqual(vim.current.buffer[12], u"")
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(EditCheckboxTestCase)
|
||||
387
dot_vim/plugged/vim-orgmode/tests/test_plugin_edit_structure.py
Normal file
387
dot_vim/plugged/vim-orgmode/tests/test_plugin_edit_structure.py
Normal file
@@ -0,0 +1,387 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
import vim
|
||||
|
||||
from orgmode._vim import ORGMODE
|
||||
|
||||
from orgmode.py3compat.encode_compatibility import *
|
||||
|
||||
counter = 0
|
||||
class EditStructureTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
global counter
|
||||
counter += 1
|
||||
vim.CMDHISTORY = []
|
||||
vim.CMDRESULTS = {}
|
||||
vim.EVALHISTORY = []
|
||||
vim.EVALRESULTS = {
|
||||
# no org_todo_keywords for b
|
||||
u_encode(u'exists("b:org_todo_keywords")'): u_encode('0'),
|
||||
# global values for org_todo_keywords
|
||||
u_encode(u'exists("g:org_todo_keywords")'): u_encode('1'),
|
||||
u_encode(u'g:org_todo_keywords'): [u_encode(u'TODO'), u_encode(u'|'), u_encode(u'DONE')],
|
||||
u_encode(u'exists("g:org_improve_split_heading")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_improve_split_heading")'): u_encode(u'0'),
|
||||
u_encode(u'exists("g:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("*repeat#set()")'): u_encode(u'0'),
|
||||
u_encode(u'b:changedtick'): u_encode(u'%d' % counter),
|
||||
u_encode(u'&ts'): u_encode(u'8'),
|
||||
u_encode(u'exists("g:org_tag_column")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_tag_column")'): u_encode(u'0'),
|
||||
u_encode(u"v:count"): u_encode(u'0'),
|
||||
# jump to insert mode after adding heading/checkbox
|
||||
u_encode(u'exists("g:org_prefer_insert_mode")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_prefer_insert_mode")'): u_encode(u'0')}
|
||||
if not u'EditStructure' in ORGMODE.plugins:
|
||||
ORGMODE.register_plugin(u'EditStructure')
|
||||
self.editstructure = ORGMODE.plugins[u'EditStructure']
|
||||
vim.current.buffer[:] = [ u_encode(i) for i in u"""
|
||||
* Überschrift 1
|
||||
Text 1
|
||||
|
||||
Bla bla
|
||||
** Überschrift 1.1
|
||||
Text 2
|
||||
|
||||
Bla Bla bla
|
||||
** Überschrift 1.2
|
||||
Text 3
|
||||
|
||||
**** Überschrift 1.2.1.falsch
|
||||
|
||||
Bla Bla bla bla
|
||||
*** Überschrift 1.2.1
|
||||
* Überschrift 2
|
||||
* Überschrift 3
|
||||
asdf sdf
|
||||
""".split(u'\n')]
|
||||
|
||||
def test_new_heading_below_normal_behavior(self):
|
||||
vim.current.window.cursor = (1, 0)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=True), None)
|
||||
self.assertEqual(vim.current.buffer[0], u_encode(u'* '))
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1'))
|
||||
|
||||
def test_new_heading_above_normal_behavior(self):
|
||||
vim.current.window.cursor = (1, 1)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=False), None)
|
||||
self.assertEqual(vim.current.buffer[0], u_encode(u'* '))
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1'))
|
||||
|
||||
def test_new_heading_below(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.current.buffer[5] = u_encode(u'** Überschrift 1.1 :Tag:')
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=True, insert_mode=False), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 6gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[4], u_encode(u'Bla bla'))
|
||||
self.assertEqual(vim.current.buffer[5], u_encode(u'* '))
|
||||
self.assertEqual(vim.current.buffer[6], u_encode(u'** Überschrift 1.1 :Tag:'))
|
||||
self.assertEqual(vim.current.buffer[10], u_encode(u'** Überschrift 1.2'))
|
||||
self.assertEqual(vim.current.buffer[13], u_encode(u'**** Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'*** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[17], u_encode(u'* Überschrift 2'))
|
||||
|
||||
def test_new_heading_below_insert_mode(self):
|
||||
vim.current.window.cursor = (2, 1)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=True, insert_mode=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 3gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[2], u_encode(u'* Überschrift 1'))
|
||||
self.assertEqual(vim.current.buffer[5], u_encode(u'Bla bla'))
|
||||
self.assertEqual(vim.current.buffer[6], u_encode(u'** Überschrift 1.1'))
|
||||
self.assertEqual(vim.current.buffer[10], u_encode(u'** Überschrift 1.2'))
|
||||
self.assertEqual(vim.current.buffer[13], u_encode(u'**** Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'*** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[17], u_encode(u'* Überschrift 2'))
|
||||
|
||||
def test_new_heading_below_split_text_at_the_end(self):
|
||||
vim.current.buffer[1] = u_encode(u'* Überschriftx1')
|
||||
vim.current.window.cursor = (2, 14)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=True, insert_mode=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 3gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[2], u_encode(u'* '))
|
||||
self.assertEqual(vim.current.buffer[5], u_encode(u'Bla bla'))
|
||||
self.assertEqual(vim.current.buffer[6], u_encode(u'** Überschrift 1.1'))
|
||||
self.assertEqual(vim.current.buffer[10], u_encode(u'** Überschrift 1.2'))
|
||||
self.assertEqual(vim.current.buffer[13], u_encode(u'**** Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'*** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[17], u_encode(u'* Überschrift 2'))
|
||||
|
||||
def test_new_heading_below_split_text_at_the_end_insert_parts(self):
|
||||
vim.current.window.cursor = (2, 14)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=True, insert_mode=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 3gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[2], u_encode(u'* 1'))
|
||||
self.assertEqual(vim.current.buffer[5], u_encode(u'Bla bla'))
|
||||
self.assertEqual(vim.current.buffer[6], u_encode(u'** Überschrift 1.1'))
|
||||
self.assertEqual(vim.current.buffer[10], u_encode(u'** Überschrift 1.2'))
|
||||
self.assertEqual(vim.current.buffer[13], u_encode(u'**** Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'*** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[17], u_encode(u'* Überschrift 2'))
|
||||
|
||||
def test_new_heading_below_in_the_middle(self):
|
||||
vim.current.window.cursor = (10, 0)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=True, insert_mode=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 13gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[11], u_encode(u''))
|
||||
self.assertEqual(vim.current.buffer[12], u_encode(u'** '))
|
||||
self.assertEqual(vim.current.buffer[13], u_encode(u'**** Überschrift 1.2.1.falsch'))
|
||||
|
||||
def test_new_heading_below_in_the_middle2(self):
|
||||
vim.current.window.cursor = (13, 0)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=True, insert_mode=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 16gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[14], u_encode(u'Bla Bla bla bla'))
|
||||
self.assertEqual(vim.current.buffer[15], u_encode(u'**** '))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'*** Überschrift 1.2.1'))
|
||||
|
||||
def test_new_heading_below_in_the_middle3(self):
|
||||
vim.current.window.cursor = (16, 0)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=True, insert_mode=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 17gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[15], u_encode(u'*** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'*** '))
|
||||
self.assertEqual(vim.current.buffer[17], u_encode(u'* Überschrift 2'))
|
||||
|
||||
def test_new_heading_below_at_the_end(self):
|
||||
vim.current.window.cursor = (18, 0)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=True, insert_mode=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 21gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[19], u_encode(u''))
|
||||
self.assertEqual(vim.current.buffer[20], u_encode(u'* '))
|
||||
self.assertEqual(len(vim.current.buffer), 21)
|
||||
|
||||
def test_new_heading_above(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=False, insert_mode=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 2gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[0], u_encode(u''))
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* '))
|
||||
self.assertEqual(vim.current.buffer[2], u_encode(u'* Überschrift 1'))
|
||||
|
||||
def test_new_heading_above_in_the_middle(self):
|
||||
vim.current.window.cursor = (10, 0)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=False, insert_mode=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 10gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[8], u_encode(u'Bla Bla bla'))
|
||||
self.assertEqual(vim.current.buffer[9], u_encode(u'** '))
|
||||
self.assertEqual(vim.current.buffer[10], u_encode(u'** Überschrift 1.2'))
|
||||
|
||||
def test_new_heading_above_in_the_middle2(self):
|
||||
vim.current.window.cursor = (13, 0)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=False, insert_mode=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 13gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[11], u_encode(u''))
|
||||
self.assertEqual(vim.current.buffer[12], u_encode(u'**** '))
|
||||
self.assertEqual(vim.current.buffer[13], u_encode(u'**** Überschrift 1.2.1.falsch'))
|
||||
|
||||
def test_new_heading_above_in_the_middle3(self):
|
||||
vim.current.window.cursor = (16, 0)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=False, insert_mode=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 16gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[14], u_encode(u'Bla Bla bla bla'))
|
||||
self.assertEqual(vim.current.buffer[15], u_encode(u'*** '))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'*** Überschrift 1.2.1'))
|
||||
|
||||
def test_new_heading_above_at_the_end(self):
|
||||
vim.current.window.cursor = (18, 0)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=False, insert_mode=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 18gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'* Überschrift 2'))
|
||||
self.assertEqual(vim.current.buffer[17], u_encode(u'* '))
|
||||
self.assertEqual(vim.current.buffer[18], u_encode(u'* Überschrift 3'))
|
||||
|
||||
def test_new_heading_below_split_heading_title(self):
|
||||
vim.current.buffer[:] = [ u_encode(i) for i in u"""
|
||||
* Überschrift 1 :Tag:
|
||||
Text 1
|
||||
|
||||
Bla bla
|
||||
** Überschrift 1.1
|
||||
Text 2
|
||||
|
||||
Bla Bla bla
|
||||
** Überschrift 1.2
|
||||
Text 3
|
||||
|
||||
**** Überschrift 1.2.1.falsch
|
||||
|
||||
Bla Bla bla bla
|
||||
*** Überschrift 1.2.1
|
||||
* Überschrift 2
|
||||
* Überschrift 3
|
||||
asdf sdf
|
||||
""".split(u'\n')]
|
||||
vim.current.window.cursor = (2, 6)
|
||||
self.assertNotEqual(self.editstructure.new_heading(insert_mode=True), None)
|
||||
self.assertEqual(vim.current.buffer[0], u_encode(u''))
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Über :Tag:'))
|
||||
self.assertEqual(vim.current.buffer[2], u_encode(u'* schrift 1'))
|
||||
self.assertEqual(vim.current.buffer[3], u_encode(u'Text 1'))
|
||||
|
||||
def test_new_heading_below_split_heading_title_with_todo(self):
|
||||
vim.current.buffer[:] = [ u_encode(i) for i in u"""
|
||||
* TODO Überschrift 1 :Tag:
|
||||
Text 1
|
||||
|
||||
Bla bla
|
||||
** Überschrift 1.1
|
||||
Text 2
|
||||
|
||||
Bla Bla bla
|
||||
** Überschrift 1.2
|
||||
Text 3
|
||||
|
||||
**** Überschrift 1.2.1.falsch
|
||||
|
||||
Bla Bla bla bla
|
||||
*** Überschrift 1.2.1
|
||||
* Überschrift 2
|
||||
* Überschrift 3
|
||||
asdf sdf
|
||||
""".split(u'\n')]
|
||||
vim.current.window.cursor = (2, 5)
|
||||
self.assertNotEqual(self.editstructure.new_heading(insert_mode=True), None)
|
||||
self.assertEqual(vim.current.buffer[0], u_encode(u''))
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* TODO :Tag:'))
|
||||
self.assertEqual(vim.current.buffer[2], u_encode(u'* Überschrift 1'))
|
||||
self.assertEqual(vim.current.buffer[3], u_encode(u'Text 1'))
|
||||
|
||||
def test_demote_heading(self):
|
||||
vim.current.window.cursor = (13, 0)
|
||||
self.assertNotEqual(self.editstructure.demote_heading(), None)
|
||||
self.assertEqual(vim.current.buffer[10], u_encode(u'Text 3'))
|
||||
self.assertEqual(vim.current.buffer[11], u_encode(u''))
|
||||
self.assertEqual(vim.current.buffer[12], u_encode(u'***** Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[13], u_encode(u''))
|
||||
# actually the indentation comes through vim, just the heading is updated
|
||||
self.assertEqual(vim.current.buffer[14], u_encode(u'Bla Bla bla bla'))
|
||||
self.assertEqual(vim.current.buffer[15], u_encode(u'*** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.window.cursor, (13, 1))
|
||||
|
||||
def test_demote_newly_created_level_one_heading(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=True), None)
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1'))
|
||||
self.assertEqual(vim.current.buffer[5], u_encode(u'* '))
|
||||
self.assertEqual(vim.current.buffer[6], u_encode(u'** Überschrift 1.1'))
|
||||
self.assertEqual(vim.current.buffer[10], u_encode(u'** Überschrift 1.2'))
|
||||
self.assertEqual(vim.current.buffer[13], u_encode(u'**** Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'*** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[17], u_encode(u'* Überschrift 2'))
|
||||
|
||||
vim.current.window.cursor = (6, 2)
|
||||
self.assertNotEqual(self.editstructure.demote_heading(), None)
|
||||
self.assertEqual(vim.current.buffer[5], u_encode(u'** '))
|
||||
self.assertEqual(vim.current.buffer[6], u_encode(u'*** Überschrift 1.1'))
|
||||
self.assertEqual(vim.current.buffer[10], u_encode(u'*** Überschrift 1.2'))
|
||||
self.assertEqual(vim.current.buffer[13], u_encode(u'***** Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'**** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[17], u_encode(u'* Überschrift 2'))
|
||||
|
||||
def test_demote_newly_created_level_two_heading(self):
|
||||
vim.current.window.cursor = (10, 0)
|
||||
self.assertNotEqual(self.editstructure.new_heading(below=True), None)
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1'))
|
||||
self.assertEqual(vim.current.buffer[5], u_encode(u'** Überschrift 1.1'))
|
||||
self.assertEqual(vim.current.buffer[9], u_encode(u'** Überschrift 1.2'))
|
||||
self.assertEqual(vim.current.buffer[12], u_encode(u'** '))
|
||||
self.assertEqual(vim.current.buffer[13], u_encode(u'**** Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'*** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[17], u_encode(u'* Überschrift 2'))
|
||||
|
||||
vim.current.window.cursor = (13, 3)
|
||||
self.assertNotEqual(self.editstructure.demote_heading(including_children=False, on_heading=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'exe "normal 13gg"|startinsert!'))
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1'))
|
||||
self.assertEqual(vim.current.buffer[5], u_encode(u'** Überschrift 1.1'))
|
||||
self.assertEqual(vim.current.buffer[9], u_encode(u'** Überschrift 1.2'))
|
||||
self.assertEqual(vim.current.buffer[12], u_encode(u'*** '))
|
||||
self.assertEqual(vim.current.buffer[13], u_encode(u'**** Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'*** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[17], u_encode(u'* Überschrift 2'))
|
||||
|
||||
def test_demote_last_heading(self):
|
||||
vim.current.buffer[:] = [ u_encode(i) for i in u"""
|
||||
* Überschrift 2
|
||||
* Überschrift 3""".split('\n')]
|
||||
vim.current.window.cursor = (3, 0)
|
||||
h = ORGMODE.get_document().current_heading()
|
||||
self.assertNotEqual(self.editstructure.demote_heading(), None)
|
||||
self.assertEqual(h.end, 2)
|
||||
self.assertFalse(vim.CMDHISTORY)
|
||||
self.assertEqual(vim.current.buffer[2], u_encode(u'** Überschrift 3'))
|
||||
self.assertEqual(vim.current.window.cursor, (3, 1))
|
||||
|
||||
def test_promote_heading(self):
|
||||
vim.current.window.cursor = (13, 0)
|
||||
self.assertNotEqual(self.editstructure.promote_heading(), None)
|
||||
self.assertEqual(vim.current.buffer[10], u_encode(u'Text 3'))
|
||||
self.assertEqual(vim.current.buffer[11], u_encode(u''))
|
||||
self.assertEqual(vim.current.buffer[12], u_encode(u'*** Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[13], u_encode(u''))
|
||||
# actually the indentation comes through vim, just the heading is updated
|
||||
self.assertEqual(vim.current.buffer[14], u_encode(u'Bla Bla bla bla'))
|
||||
self.assertEqual(vim.current.buffer[15], u_encode(u'*** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.window.cursor, (13, -1))
|
||||
|
||||
def test_promote_level_one_heading(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
self.assertEqual(self.editstructure.promote_heading(), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 0)
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_demote_parent_heading(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
self.assertNotEqual(self.editstructure.demote_heading(), None)
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'** Überschrift 1'))
|
||||
self.assertEqual(vim.current.buffer[5], u_encode(u'*** Überschrift 1.1'))
|
||||
self.assertEqual(vim.current.buffer[9], u_encode(u'*** Überschrift 1.2'))
|
||||
self.assertEqual(vim.current.buffer[12], u_encode(u'***** Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[15], u_encode(u'**** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'* Überschrift 2'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 1))
|
||||
|
||||
def test_promote_parent_heading(self):
|
||||
vim.current.window.cursor = (10, 0)
|
||||
self.assertNotEqual(self.editstructure.promote_heading(), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal 10ggV16gg='))
|
||||
self.assertEqual(vim.current.buffer[5], u_encode(u'** Überschrift 1.1'))
|
||||
self.assertEqual(vim.current.buffer[9], u_encode(u'* Überschrift 1.2'))
|
||||
self.assertEqual(vim.current.buffer[12], u_encode(u'*** Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[15], u_encode(u'** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'* Überschrift 2'))
|
||||
self.assertEqual(vim.current.window.cursor, (10, -1))
|
||||
|
||||
# run tests with count
|
||||
def test_demote_parent_heading_count(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u"v:count"] = u_encode(u'3')
|
||||
self.assertNotEqual(self.editstructure.demote_heading(), None)
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'**** Überschrift 1'))
|
||||
self.assertEqual(vim.current.buffer[5], u_encode(u'***** Überschrift 1.1'))
|
||||
self.assertEqual(vim.current.buffer[9], u_encode(u'***** Überschrift 1.2'))
|
||||
self.assertEqual(vim.current.buffer[12], u_encode(u'******* Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[15], u_encode(u'****** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'* Überschrift 2'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'* Überschrift 2'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 3))
|
||||
|
||||
def test_promote_parent_heading(self):
|
||||
vim.current.window.cursor = (13, 0)
|
||||
vim.EVALRESULTS[u"v:count"] = u_encode(u'3')
|
||||
self.assertNotEqual(self.editstructure.promote_heading(), None)
|
||||
self.assertEqual(vim.current.buffer[5], u_encode(u'** Überschrift 1.1'))
|
||||
self.assertEqual(vim.current.buffer[9], u_encode(u'** Überschrift 1.2'))
|
||||
self.assertEqual(vim.current.buffer[12], u_encode(u'* Überschrift 1.2.1.falsch'))
|
||||
self.assertEqual(vim.current.buffer[15], u_encode(u'** Überschrift 1.2.1'))
|
||||
self.assertEqual(vim.current.buffer[16], u_encode(u'* Überschrift 2'))
|
||||
self.assertEqual(vim.current.window.cursor, (13, -3))
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(EditStructureTestCase)
|
||||
66
dot_vim/plugged/vim-orgmode/tests/test_plugin_mappings.py
Normal file
66
dot_vim/plugged/vim-orgmode/tests/test_plugin_mappings.py
Normal file
@@ -0,0 +1,66 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
import unittest
|
||||
import orgmode.settings
|
||||
from orgmode.exceptions import PluginError
|
||||
from orgmode._vim import ORGMODE
|
||||
from orgmode.keybinding import MODE_ALL, Plug
|
||||
|
||||
import vim
|
||||
|
||||
from orgmode.py3compat.encode_compatibility import *
|
||||
|
||||
ORG_PLUGINS = ['ShowHide', '|', 'Navigator', 'EditStructure', '|', 'Hyperlinks', '|', 'Todo', 'TagsProperties', 'Date', 'Agenda', 'Misc', '|', 'Export']
|
||||
|
||||
|
||||
class MappingTestCase(unittest.TestCase):
|
||||
u"""Tests all plugins for overlapping mappings."""
|
||||
def test_non_overlapping_plug_mappings(self):
|
||||
def find_overlapping_mappings(kb, all_keybindings):
|
||||
found_overlapping_mapping = False
|
||||
for tkb in all_keybindings:
|
||||
if kb.mode == tkb.mode or MODE_ALL in (kb.mode, tkb.mode):
|
||||
if isinstance(kb._action, Plug) and isinstance(tkb._action, Plug):
|
||||
akb = kb.action
|
||||
atkb = tkb.action
|
||||
if (akb.startswith(atkb) or atkb.startswith(akb)) and akb != atkb:
|
||||
print(u'\nERROR: Found overlapping mapping: %s (%s), %s (%s)' % (kb.key, akb, tkb.key, atkb))
|
||||
found_overlapping_mapping = True
|
||||
|
||||
if all_keybindings:
|
||||
res = find_overlapping_mappings(all_keybindings[0], all_keybindings[1:])
|
||||
if not found_overlapping_mapping:
|
||||
return res
|
||||
return found_overlapping_mapping
|
||||
|
||||
if self.keybindings:
|
||||
self.assertFalse(find_overlapping_mappings(self.keybindings[0], self.keybindings[1:]))
|
||||
|
||||
def setUp(self):
|
||||
self.keybindings = []
|
||||
|
||||
vim.EVALRESULTS = {
|
||||
u'exists("g:org_debug")': 0,
|
||||
u'exists("b:org_debug")': 0,
|
||||
u'exists("*repeat#set()")': 0,
|
||||
u'b:changedtick': 0,
|
||||
u_encode(u'exists("b:org_plugins")'): 0,
|
||||
u_encode(u'exists("g:org_plugins")'): 1,
|
||||
u_encode(u'g:org_plugins'): ORG_PLUGINS,
|
||||
}
|
||||
for plugin in filter(lambda p: p != '|', ORG_PLUGINS):
|
||||
try:
|
||||
ORGMODE.register_plugin(plugin)
|
||||
except PluginError:
|
||||
pass
|
||||
if plugin in ORGMODE._plugins:
|
||||
self.keybindings.extend(ORGMODE._plugins[plugin].keybindings)
|
||||
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(MappingTestCase)
|
||||
164
dot_vim/plugged/vim-orgmode/tests/test_plugin_misc.py
Normal file
164
dot_vim/plugged/vim-orgmode/tests/test_plugin_misc.py
Normal file
@@ -0,0 +1,164 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
import vim
|
||||
|
||||
from orgmode._vim import indent_orgmode, fold_orgmode, ORGMODE
|
||||
|
||||
from orgmode.py3compat.encode_compatibility import *
|
||||
|
||||
ORGMODE.debug = True
|
||||
|
||||
START = True
|
||||
END = False
|
||||
|
||||
counter = 0
|
||||
class MiscTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
global counter
|
||||
counter += 1
|
||||
vim.CMDHISTORY = []
|
||||
vim.CMDRESULTS = {}
|
||||
vim.EVALHISTORY = []
|
||||
vim.EVALRESULTS = {
|
||||
# no org_todo_keywords for b
|
||||
u_encode(u'exists("b:org_todo_keywords")'): u_encode('0'),
|
||||
# global values for org_todo_keywords
|
||||
u_encode(u'exists("g:org_todo_keywords")'): u_encode('1'),
|
||||
u_encode(u'g:org_todo_keywords'): [u_encode(u'TODO'), u_encode(u'|'), u_encode(u'DONE')],
|
||||
u_encode(u'exists("g:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("g:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("*repeat#set()")'): u_encode(u'0'),
|
||||
u_encode(u"v:count"): u_encode(u'0'),
|
||||
u_encode(u'b:changedtick'): u_encode(u'%d' % counter),
|
||||
u_encode(u"v:lnum"): u_encode(u'0')}
|
||||
vim.current.buffer[:] = [ u_encode(i) for i in u"""
|
||||
* Überschrift 1
|
||||
Text 1
|
||||
|
||||
Bla bla
|
||||
** Überschrift 1.1
|
||||
Text 2
|
||||
|
||||
Bla Bla bla
|
||||
** Überschrift 1.2
|
||||
Text 3
|
||||
|
||||
**** Überschrift 1.2.1.falsch
|
||||
|
||||
Bla Bla bla bla
|
||||
*** Überschrift 1.2.1
|
||||
* Überschrift 2
|
||||
* Überschrift 3
|
||||
asdf sdf
|
||||
""".split(u'\n') ]
|
||||
|
||||
def test_indent_noheading(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (1, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'1')
|
||||
indent_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 0)
|
||||
|
||||
def test_indent_heading(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'2')
|
||||
indent_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 0)
|
||||
|
||||
def test_indent_heading_middle(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (3, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'3')
|
||||
indent_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'let b:indent_level = 2'))
|
||||
|
||||
def test_indent_heading_middle2(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (4, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'4')
|
||||
indent_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'let b:indent_level = 2'))
|
||||
|
||||
def test_indent_heading_end(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (5, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'5')
|
||||
indent_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'let b:indent_level = 2'))
|
||||
|
||||
def test_fold_heading_start(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'2')
|
||||
fold_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'let b:fold_expr = ">1"'))
|
||||
|
||||
def test_fold_heading_middle(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (3, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'3')
|
||||
fold_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'let b:fold_expr = 1'))
|
||||
|
||||
def test_fold_heading_end(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (5, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'5')
|
||||
fold_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'let b:fold_expr = 1'))
|
||||
|
||||
def test_fold_heading_end_of_last_child(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (16, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'16')
|
||||
fold_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
# which is also end of the parent heading <1
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'let b:fold_expr = ">3"'))
|
||||
|
||||
def test_fold_heading_end_of_last_child_next_heading(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (17, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'17')
|
||||
fold_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'let b:fold_expr = ">1"'))
|
||||
|
||||
def test_fold_middle_subheading(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (13, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'13')
|
||||
fold_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'let b:fold_expr = ">4"'))
|
||||
|
||||
def test_fold_middle_subheading2(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (14, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'14')
|
||||
fold_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'let b:fold_expr = 4'))
|
||||
|
||||
def test_fold_middle_subheading3(self):
|
||||
# test first heading
|
||||
vim.current.window.cursor = (15, 0)
|
||||
vim.EVALRESULTS[u_encode(u'v:lnum')] = u_encode(u'15')
|
||||
fold_orgmode()
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'let b:fold_expr = 4'))
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(MiscTestCase)
|
||||
633
dot_vim/plugged/vim-orgmode/tests/test_plugin_navigator.py
Normal file
633
dot_vim/plugged/vim-orgmode/tests/test_plugin_navigator.py
Normal file
@@ -0,0 +1,633 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
import vim
|
||||
|
||||
from orgmode._vim import ORGMODE
|
||||
|
||||
from orgmode.py3compat.encode_compatibility import *
|
||||
|
||||
START = True
|
||||
END = False
|
||||
|
||||
def set_visual_selection(visualmode, line_start, line_end, col_start=1,
|
||||
col_end=1, cursor_pos=START):
|
||||
|
||||
if visualmode not in (u'', u'V', u'v'):
|
||||
raise ValueError(u'Illegal value for visualmode, must be in , V, v')
|
||||
|
||||
vim.EVALRESULTS['visualmode()'] = visualmode
|
||||
|
||||
# getpos results [bufnum, lnum, col, off]
|
||||
vim.EVALRESULTS['getpos("\'<")'] = ('', '%d' % line_start, '%d' %
|
||||
col_start, '')
|
||||
vim.EVALRESULTS['getpos("\'>")'] = ('', '%d' % line_end, '%d' %
|
||||
col_end, '')
|
||||
if cursor_pos == START:
|
||||
vim.current.window.cursor = (line_start, col_start)
|
||||
else:
|
||||
vim.current.window.cursor = (line_end, col_end)
|
||||
|
||||
|
||||
counter = 0
|
||||
class NavigatorTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
global counter
|
||||
counter += 1
|
||||
vim.CMDHISTORY = []
|
||||
vim.CMDRESULTS = {}
|
||||
vim.EVALHISTORY = []
|
||||
vim.EVALRESULTS = {
|
||||
# no org_todo_keywords for b
|
||||
u_encode(u'exists("b:org_todo_keywords")'): u_encode('0'),
|
||||
# global values for org_todo_keywords
|
||||
u_encode(u'exists("g:org_todo_keywords")'): u_encode('1'),
|
||||
u_encode(u'g:org_todo_keywords'): [u_encode(u'TODO'), u_encode(u'|'), u_encode(u'DONE')],
|
||||
u_encode(u'exists("g:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("g:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("*repeat#set()")'): u_encode(u'0'),
|
||||
u_encode(u'b:changedtick'): u_encode(u'%d' % counter),
|
||||
u_encode(u"v:count"): u_encode(u'0'),
|
||||
}
|
||||
vim.current.buffer[:] = [ u_encode(i) for i in u"""
|
||||
* Überschrift 1
|
||||
Text 1
|
||||
|
||||
Bla bla
|
||||
** Überschrift 1.1
|
||||
Text 2
|
||||
|
||||
Bla Bla bla
|
||||
** Überschrift 1.2
|
||||
Text 3
|
||||
|
||||
**** Überschrift 1.2.1.falsch
|
||||
|
||||
Bla Bla bla bla
|
||||
*** Überschrift 1.2.1
|
||||
* Überschrift 2
|
||||
* Überschrift 3
|
||||
asdf sdf
|
||||
""".split(u'\n') ]
|
||||
|
||||
if not u'Navigator' in ORGMODE.plugins:
|
||||
ORGMODE.register_plugin(u'Navigator')
|
||||
self.navigator = ORGMODE.plugins[u'Navigator']
|
||||
|
||||
def test_movement(self):
|
||||
# test movement outside any heading
|
||||
vim.current.window.cursor = (1, 0)
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (1, 0))
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (2, 2))
|
||||
|
||||
def test_forward_movement(self):
|
||||
# test forward movement
|
||||
vim.current.window.cursor = (2, 0)
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (6, 3))
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (10, 3))
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (13, 5))
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (16, 4))
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (17, 2))
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (18, 2))
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (18, 2))
|
||||
|
||||
## don't move cursor if last heading is already focussed
|
||||
vim.current.window.cursor = (19, 6)
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (19, 6))
|
||||
|
||||
## test movement with count
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'-1')
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (6, 3))
|
||||
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'0')
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (6, 3))
|
||||
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'1')
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (6, 3))
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'3')
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (16, 4))
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (18, 2))
|
||||
self.navigator.next(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (18, 2))
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'0')
|
||||
|
||||
def test_backward_movement(self):
|
||||
# test backward movement
|
||||
vim.current.window.cursor = (19, 6)
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (18, 2))
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (17, 2))
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (16, 4))
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (13, 5))
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (10, 3))
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (6, 3))
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (2, 2))
|
||||
|
||||
## test movement with count
|
||||
vim.current.window.cursor = (19, 6)
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'-1')
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (18, 2))
|
||||
|
||||
vim.current.window.cursor = (19, 6)
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'0')
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (18, 2))
|
||||
|
||||
vim.current.window.cursor = (19, 6)
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'3')
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (16, 4))
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'4')
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (2, 2))
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'4')
|
||||
self.navigator.previous(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (2, 2))
|
||||
|
||||
def test_parent_movement(self):
|
||||
# test movement to parent
|
||||
vim.current.window.cursor = (2, 0)
|
||||
self.assertEqual(self.navigator.parent(mode=u'normal'), None)
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
vim.current.window.cursor = (3, 4)
|
||||
self.navigator.parent(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (3, 4))
|
||||
|
||||
vim.current.window.cursor = (16, 4)
|
||||
self.navigator.parent(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (10, 3))
|
||||
self.navigator.parent(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (2, 2))
|
||||
|
||||
vim.current.window.cursor = (15, 6)
|
||||
self.navigator.parent(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (10, 3))
|
||||
self.navigator.parent(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (2, 2))
|
||||
|
||||
## test movement with count
|
||||
vim.current.window.cursor = (16, 4)
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'-1')
|
||||
self.navigator.parent(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (10, 3))
|
||||
|
||||
vim.current.window.cursor = (16, 4)
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'0')
|
||||
self.navigator.parent(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (10, 3))
|
||||
|
||||
vim.current.window.cursor = (16, 4)
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'1')
|
||||
self.navigator.parent(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (10, 3))
|
||||
|
||||
vim.current.window.cursor = (16, 4)
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'2')
|
||||
self.navigator.parent(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (2, 2))
|
||||
|
||||
vim.current.window.cursor = (16, 4)
|
||||
vim.EVALRESULTS[u_encode(u"v:count")] = u_encode(u'3')
|
||||
self.navigator.parent(mode=u'normal')
|
||||
self.assertEqual(vim.current.window.cursor, (2, 2))
|
||||
|
||||
def test_next_parent_movement(self):
|
||||
# test movement to parent
|
||||
vim.current.window.cursor = (6, 0)
|
||||
self.assertNotEqual(self.navigator.parent_next_sibling(mode=u'normal'), None)
|
||||
self.assertEqual(vim.current.window.cursor, (17, 2))
|
||||
|
||||
def test_forward_movement_visual(self):
|
||||
# selection start: <<
|
||||
# selection end: >>
|
||||
# cursor position: |
|
||||
|
||||
# << text
|
||||
# text| >>
|
||||
# text
|
||||
# heading
|
||||
set_visual_selection(u'V', 2, 4, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV5gg'))
|
||||
|
||||
# << text
|
||||
# text
|
||||
# text| >>
|
||||
# heading
|
||||
set_visual_selection(u'V', 2, 5, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV9gg'))
|
||||
|
||||
# << text
|
||||
# x. heading
|
||||
# text| >>
|
||||
# heading
|
||||
set_visual_selection(u'V', 12, 14, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 12ggV15gg'))
|
||||
|
||||
set_visual_selection(u'V', 12, 15, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 12ggV16gg'))
|
||||
|
||||
set_visual_selection(u'V', 12, 16, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 12ggV17gg'))
|
||||
|
||||
# << text
|
||||
# text
|
||||
# text| >>
|
||||
# heading
|
||||
# EOF
|
||||
set_visual_selection(u'V', 15, 17, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 15ggV20gg'))
|
||||
|
||||
# << text >>
|
||||
# heading
|
||||
set_visual_selection(u'V', 1, 1, cursor_pos=START)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 1ggV5gg'))
|
||||
|
||||
# << heading >>
|
||||
# text
|
||||
# heading
|
||||
set_visual_selection(u'V', 2, 2, cursor_pos=START)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV5gg'))
|
||||
|
||||
# << text >>
|
||||
# heading
|
||||
set_visual_selection(u'V', 1, 1, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 1ggV5gg'))
|
||||
|
||||
# << |text
|
||||
# heading
|
||||
# text
|
||||
# heading
|
||||
# text >>
|
||||
set_visual_selection(u'V', 1, 8, cursor_pos=START)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV8ggo'))
|
||||
|
||||
# << |heading
|
||||
# text
|
||||
# heading
|
||||
# text >>
|
||||
set_visual_selection(u'V', 2, 8, cursor_pos=START)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 6ggV8ggo'))
|
||||
|
||||
# << |heading
|
||||
# text >>
|
||||
# heading
|
||||
set_visual_selection(u'V', 6, 8, cursor_pos=START)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 8ggV9gg'))
|
||||
|
||||
# << |x. heading
|
||||
# text >>
|
||||
# heading
|
||||
set_visual_selection(u'V', 13, 15, cursor_pos=START)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 15ggV15gg'))
|
||||
|
||||
set_visual_selection(u'V', 13, 16, cursor_pos=START)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 16ggV16ggo'))
|
||||
|
||||
set_visual_selection(u'V', 16, 16, cursor_pos=START)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 16ggV17gg'))
|
||||
|
||||
# << |x. heading
|
||||
# text >>
|
||||
# heading
|
||||
# EOF
|
||||
set_visual_selection(u'V', 17, 17, cursor_pos=START)
|
||||
self.assertNotEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 17ggV20gg'))
|
||||
|
||||
# << |heading
|
||||
# text>>
|
||||
# text
|
||||
# EOF
|
||||
set_visual_selection(u'V', 18, 19, cursor_pos=START)
|
||||
self.assertEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 19ggV20gg'))
|
||||
|
||||
# << heading
|
||||
# text|>>
|
||||
# text
|
||||
# EOF
|
||||
set_visual_selection(u'V', 18, 19, cursor_pos=END)
|
||||
self.assertEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 18ggV20gg'))
|
||||
|
||||
# << heading
|
||||
# text|>>
|
||||
# EOF
|
||||
set_visual_selection(u'V', 18, 20, cursor_pos=END)
|
||||
self.assertEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 18ggV20gg'))
|
||||
|
||||
# << |heading
|
||||
# text>>
|
||||
# EOF
|
||||
set_visual_selection(u'V', 20, 20, cursor_pos=START)
|
||||
self.assertEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 20ggV20gg'))
|
||||
|
||||
def test_forward_movement_visual_to_the_end_of_the_file(self):
|
||||
vim.current.buffer[:] = [ u_encode(i) for i in u"""
|
||||
* Überschrift 1
|
||||
Text 1
|
||||
|
||||
Bla bla
|
||||
** Überschrift 1.1
|
||||
Text 2
|
||||
|
||||
Bla Bla bla
|
||||
** Überschrift 1.2
|
||||
Text 3
|
||||
|
||||
**** Überschrift 1.2.1.falsch
|
||||
|
||||
Bla Bla bla bla
|
||||
test
|
||||
""".split(u'\n') ]
|
||||
# << |heading
|
||||
# text>>
|
||||
# EOF
|
||||
set_visual_selection(u'V', 15, 15, cursor_pos=START)
|
||||
self.assertEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 15ggV17gg'))
|
||||
|
||||
set_visual_selection(u'V', 15, 17, cursor_pos=END)
|
||||
self.assertEqual(self.navigator.next(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 15ggV17gg'))
|
||||
|
||||
def test_backward_movement_visual(self):
|
||||
# selection start: <<
|
||||
# selection end: >>
|
||||
# cursor position: |
|
||||
|
||||
# << text | >>
|
||||
# text
|
||||
# heading
|
||||
set_visual_selection(u'V', 1, 1, cursor_pos=START)
|
||||
self.assertEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! gv'))
|
||||
|
||||
set_visual_selection(u'V', 1, 1, cursor_pos=END)
|
||||
self.assertEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! gv'))
|
||||
|
||||
# << heading| >>
|
||||
# text
|
||||
# heading
|
||||
set_visual_selection(u'V', 2, 2, cursor_pos=START)
|
||||
self.assertEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV2ggo'))
|
||||
|
||||
set_visual_selection(u'V', 2, 2, cursor_pos=END)
|
||||
self.assertEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV2ggo'))
|
||||
|
||||
# heading
|
||||
# text
|
||||
# << |text
|
||||
# text >>
|
||||
set_visual_selection(u'V', 3, 5, cursor_pos=START)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV5ggo'))
|
||||
|
||||
# heading
|
||||
# text
|
||||
# << text
|
||||
# text| >>
|
||||
set_visual_selection(u'V', 3, 5, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV3ggo'))
|
||||
|
||||
# heading
|
||||
# text
|
||||
# << text
|
||||
# text| >>
|
||||
set_visual_selection(u'V', 8, 9, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 6ggV8ggo'))
|
||||
|
||||
# heading
|
||||
# << text
|
||||
# x. heading
|
||||
# text| >>
|
||||
set_visual_selection(u'V', 12, 14, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 12ggV12gg'))
|
||||
|
||||
set_visual_selection(u'V', 12, 15, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 12ggV12gg'))
|
||||
|
||||
# heading
|
||||
# << |text
|
||||
# x. heading
|
||||
# text >>
|
||||
set_visual_selection(u'V', 12, 15, cursor_pos=START)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 10ggV15ggo'))
|
||||
|
||||
# heading
|
||||
# << text
|
||||
# x. heading| >>
|
||||
set_visual_selection(u'V', 12, 13, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 12ggV12gg'))
|
||||
|
||||
# heading
|
||||
# << text
|
||||
# heading
|
||||
# text
|
||||
# x. heading| >>
|
||||
set_visual_selection(u'V', 12, 16, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 12ggV15gg'))
|
||||
|
||||
# << text
|
||||
# heading
|
||||
# text
|
||||
# heading| >>
|
||||
set_visual_selection(u'V', 15, 17, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 15ggV16gg'))
|
||||
|
||||
# heading
|
||||
# << |text
|
||||
# text
|
||||
# heading
|
||||
# text >>
|
||||
set_visual_selection(u'V', 4, 8, cursor_pos=START)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV8ggo'))
|
||||
|
||||
# heading
|
||||
# << text
|
||||
# text
|
||||
# heading
|
||||
# text| >>
|
||||
set_visual_selection(u'V', 4, 8, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 4ggV5gg'))
|
||||
|
||||
# heading
|
||||
# << text
|
||||
# text
|
||||
# heading
|
||||
# text| >>
|
||||
set_visual_selection(u'V', 4, 5, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV4ggo'))
|
||||
|
||||
# BOF
|
||||
# << |heading
|
||||
# text
|
||||
# heading
|
||||
# text >>
|
||||
set_visual_selection(u'V', 2, 8, cursor_pos=START)
|
||||
self.assertEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV8ggo'))
|
||||
|
||||
# BOF
|
||||
# heading
|
||||
# << text
|
||||
# text| >>
|
||||
set_visual_selection(u'V', 3, 4, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV3ggo'))
|
||||
|
||||
# BOF
|
||||
# << heading
|
||||
# text
|
||||
# text| >>
|
||||
set_visual_selection(u'V', 2, 4, cursor_pos=END)
|
||||
self.assertNotEqual(self.navigator.previous(mode=u'visual'), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV2ggo'))
|
||||
|
||||
# << text
|
||||
# heading
|
||||
# text
|
||||
# x. heading
|
||||
# text| >>
|
||||
set_visual_selection(u'V', 8, 14, cursor_pos=END)
|
||||
self.navigator.previous(mode=u'visual')
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 8ggV12gg'))
|
||||
|
||||
def test_parent_movement_visual(self):
|
||||
# selection start: <<
|
||||
# selection end: >>
|
||||
# cursor position: |
|
||||
|
||||
# heading
|
||||
# << text|
|
||||
# text
|
||||
# text >>
|
||||
set_visual_selection(u'V', 4, 8, cursor_pos=START)
|
||||
self.navigator.parent(mode=u'visual')
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! gv'))
|
||||
|
||||
# heading
|
||||
# << text|
|
||||
# text
|
||||
# text >>
|
||||
set_visual_selection(u'V', 6, 8, cursor_pos=START)
|
||||
self.navigator.parent(mode=u'visual')
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV8ggo'))
|
||||
|
||||
# heading
|
||||
# << text
|
||||
# text
|
||||
# text| >>
|
||||
set_visual_selection(u'V', 6, 8, cursor_pos=END)
|
||||
self.navigator.parent(mode=u'visual')
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 6ggV5gg'))
|
||||
|
||||
# << |heading
|
||||
# text
|
||||
# text
|
||||
# text >>
|
||||
set_visual_selection(u'V', 2, 8, cursor_pos=START)
|
||||
self.assertEqual(self.navigator.parent(mode=u'visual'), None)
|
||||
|
||||
# << heading
|
||||
# text
|
||||
# heading
|
||||
# text| >>
|
||||
set_visual_selection(u'V', 2, 8, cursor_pos=END)
|
||||
self.navigator.parent(mode=u'visual')
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV5gg'))
|
||||
|
||||
set_visual_selection(u'V', 7, 8, cursor_pos=START)
|
||||
self.navigator.parent(mode=u'visual')
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV8ggo'))
|
||||
|
||||
# heading
|
||||
# heading
|
||||
# << text
|
||||
# text| >>
|
||||
set_visual_selection(u'V', 12, 13, cursor_pos=END)
|
||||
self.navigator.parent(mode=u'visual')
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 12ggV12gg'))
|
||||
|
||||
set_visual_selection(u'V', 10, 12, cursor_pos=START)
|
||||
self.navigator.parent(mode=u'visual')
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggV12ggo'))
|
||||
|
||||
# heading
|
||||
# << text
|
||||
# text
|
||||
# heading| >>
|
||||
set_visual_selection(u'V', 11, 17, cursor_pos=END)
|
||||
self.assertEqual(self.navigator.parent(mode=u'visual'), None)
|
||||
|
||||
# << text
|
||||
# heading
|
||||
# text
|
||||
# x. heading
|
||||
# text| >>
|
||||
set_visual_selection(u'V', 8, 14, cursor_pos=END)
|
||||
self.navigator.parent(mode=u'visual')
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 8ggV12gg'))
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(NavigatorTestCase)
|
||||
385
dot_vim/plugged/vim-orgmode/tests/test_plugin_show_hide.py
Normal file
385
dot_vim/plugged/vim-orgmode/tests/test_plugin_show_hide.py
Normal file
@@ -0,0 +1,385 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
import vim
|
||||
|
||||
from orgmode._vim import ORGMODE
|
||||
|
||||
from orgmode.py3compat.encode_compatibility import *
|
||||
|
||||
counter = 0
|
||||
class ShowHideTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
global counter
|
||||
counter += 1
|
||||
vim.CMDHISTORY = []
|
||||
vim.CMDRESULTS = {}
|
||||
vim.EVALHISTORY = []
|
||||
vim.EVALRESULTS = {
|
||||
# no org_todo_keywords for b
|
||||
u_encode(u'exists("b:org_todo_keywords")'): u_encode('0'),
|
||||
# global values for org_todo_keywords
|
||||
u_encode(u'exists("g:org_todo_keywords")'): u_encode('1'),
|
||||
u_encode(u'g:org_todo_keywords'): [u_encode(u'TODO'), u_encode(u'|'), u_encode(u'DONE')],
|
||||
u_encode(u'exists("g:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("*repeat#set()")'): u_encode(u'0'),
|
||||
u_encode(u'b:changedtick'): u_encode(u'%d' % counter),
|
||||
u_encode(u"v:count"): u_encode(u'0')}
|
||||
if not u'ShowHide' in ORGMODE.plugins:
|
||||
ORGMODE.register_plugin(u'ShowHide')
|
||||
self.showhide = ORGMODE.plugins[u'ShowHide']
|
||||
vim.current.buffer[:] = [ u_encode(i) for i in u"""
|
||||
* Überschrift 1
|
||||
Text 1
|
||||
|
||||
Bla bla
|
||||
** Überschrift 1.1
|
||||
Text 2
|
||||
|
||||
Bla Bla bla
|
||||
** Überschrift 1.2
|
||||
Text 3
|
||||
|
||||
**** Überschrift 1.2.1.falsch
|
||||
|
||||
Bla Bla bla bla
|
||||
*** Überschrift 1.2.1
|
||||
* Überschrift 2
|
||||
* Überschrift 3
|
||||
asdf sdf
|
||||
""".split(u'\n') ]
|
||||
|
||||
def test_no_heading_toggle_folding(self):
|
||||
vim.current.window.cursor = (1, 0)
|
||||
self.assertEqual(self.showhide.toggle_folding(), None)
|
||||
self.assertEqual(vim.EVALHISTORY[-1], u_encode(u'feedkeys("<Tab>", "n")'))
|
||||
self.assertEqual(vim.current.window.cursor, (1, 0))
|
||||
|
||||
def test_toggle_folding_first_heading_with_no_children(self):
|
||||
vim.current.buffer[:] = [ u_encode(i) for i in u"""
|
||||
* Überschrift 1
|
||||
Text 1
|
||||
|
||||
Bla bla
|
||||
* Überschrift 2
|
||||
* Überschrift 3
|
||||
asdf sdf
|
||||
""".split(u'\n') ]
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'2'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(7)'): u_encode(u'-1'),
|
||||
})
|
||||
vim.current.window.cursor = (2, 0)
|
||||
|
||||
self.assertNotEqual(self.showhide.toggle_folding(), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 1zo'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_close_one(self):
|
||||
vim.current.window.cursor = (13, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'-1'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 2)
|
||||
self.assertEqual(vim.CMDHISTORY[-2], u_encode(u'13,15foldclose!'))
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2zo'))
|
||||
self.assertEqual(vim.current.window.cursor, (13, 0))
|
||||
|
||||
def test_toggle_folding_open_one(self):
|
||||
vim.current.window.cursor = (10, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'10'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 1zo'))
|
||||
self.assertEqual(vim.current.window.cursor, (10, 0))
|
||||
|
||||
def test_toggle_folding_close_multiple_all_open(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'-1'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'2,16foldclose!'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_all_closed(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'2'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 1zo'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_first_level_open(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'6'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'10'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'13'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'16'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 2)
|
||||
self.assertEqual(vim.CMDHISTORY[-2], u_encode(u'normal! 6gg1zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 10gg1zo'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_second_level_half_open(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'10'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'13'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'16'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 4)
|
||||
self.assertEqual(vim.CMDHISTORY[-4], u_encode(u'normal! 6gg2zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-3], u_encode(u'normal! 10gg2zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-2], u_encode(u'normal! 13gg2zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 16gg2zo'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_other_second_level_half_open(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'6'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'13'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'16'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 4)
|
||||
self.assertEqual(vim.CMDHISTORY[-4], u_encode(u'normal! 6gg2zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-3], u_encode(u'normal! 10gg2zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-2], u_encode(u'normal! 13gg2zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 16gg2zo'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_third_level_half_open(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'16'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 4)
|
||||
self.assertEqual(vim.CMDHISTORY[-4], u_encode(u'normal! 6gg3zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-3], u_encode(u'normal! 10gg3zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-2], u_encode(u'normal! 13gg3zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 16gg3zo'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_other_third_level_half_open(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'13'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'-1'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 4)
|
||||
self.assertEqual(vim.CMDHISTORY[-4], u_encode(u'normal! 6gg3zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-3], u_encode(u'normal! 10gg3zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-2], u_encode(u'normal! 13gg3zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 16gg3zo'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_other_third_level_half_open_second_level_half_closed(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'6'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'13'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'-1'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 4)
|
||||
self.assertEqual(vim.CMDHISTORY[-4], u_encode(u'normal! 6gg3zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-3], u_encode(u'normal! 10gg3zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-2], u_encode(u'normal! 13gg3zo'))
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 16gg3zo'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_no_heading_toggle_folding_reverse(self):
|
||||
vim.current.window.cursor = (1, 0)
|
||||
self.assertEqual(self.showhide.toggle_folding(reverse=True), None)
|
||||
self.assertEqual(vim.EVALHISTORY[-1], u_encode(u'feedkeys("<Tab>", "n")'))
|
||||
self.assertEqual(vim.current.window.cursor, (1, 0))
|
||||
|
||||
def test_toggle_folding_first_heading_with_no_children_reverse(self):
|
||||
vim.current.buffer[:] = [ u_encode(i) for i in u"""
|
||||
* Überschrift 1
|
||||
Text 1
|
||||
|
||||
Bla bla
|
||||
* Überschrift 2
|
||||
* Überschrift 3
|
||||
asdf sdf
|
||||
""".split(u'\n') ]
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'2'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(7)'): u_encode(u'-1'),
|
||||
})
|
||||
vim.current.window.cursor = (2, 0)
|
||||
|
||||
self.assertNotEqual(self.showhide.toggle_folding(reverse=True), None)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'2,5foldopen!'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_close_one_reverse(self):
|
||||
vim.current.window.cursor = (13, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'-1'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(reverse=True), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 13ggzc'))
|
||||
self.assertEqual(vim.current.window.cursor, (13, 0))
|
||||
|
||||
def test_toggle_folding_open_one_reverse(self):
|
||||
vim.current.window.cursor = (10, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'10'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(reverse=True), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'10,16foldopen!'))
|
||||
self.assertEqual(vim.current.window.cursor, (10, 0))
|
||||
|
||||
def test_toggle_folding_close_multiple_all_open_reverse(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'-1'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(reverse=True), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 2)
|
||||
self.assertEqual(vim.CMDHISTORY[-2], u_encode(u'normal! 13ggzc'))
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 16ggzc'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_all_closed_reverse(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'2'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(reverse=True), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'2,16foldopen!'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_first_level_open_reverse(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'6'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'10'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'13'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'16'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(reverse=True), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 2ggzc'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_second_level_half_open_reverse(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'10'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'13'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'16'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(reverse=True), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 6ggzc'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_other_second_level_half_open_reverse(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'6'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'13'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'16'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(reverse=True), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 10ggzc'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_third_level_half_open_reverse(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'16'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(reverse=True), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 13ggzc'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_other_third_level_half_open_reverse(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'13'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'-1'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(reverse=True), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 16ggzc'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def test_toggle_folding_open_multiple_other_third_level_half_open_second_level_half_closed_reverse(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS.update({
|
||||
u_encode(u'foldclosed(2)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(6)'): u_encode(u'6'),
|
||||
u_encode(u'foldclosed(10)'): u_encode(u'-1'),
|
||||
u_encode(u'foldclosed(13)'): u_encode(u'13'),
|
||||
u_encode(u'foldclosed(16)'): u_encode(u'-1'),
|
||||
})
|
||||
self.assertNotEqual(self.showhide.toggle_folding(reverse=True), None)
|
||||
self.assertEqual(len(vim.CMDHISTORY), 1)
|
||||
self.assertEqual(vim.CMDHISTORY[-1], u_encode(u'normal! 16ggzc'))
|
||||
self.assertEqual(vim.current.window.cursor, (2, 0))
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(ShowHideTestCase)
|
||||
176
dot_vim/plugged/vim-orgmode/tests/test_plugin_tags_properties.py
Normal file
176
dot_vim/plugged/vim-orgmode/tests/test_plugin_tags_properties.py
Normal file
@@ -0,0 +1,176 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import unittest
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
import vim
|
||||
|
||||
from orgmode._vim import indent_orgmode, fold_orgmode, ORGMODE
|
||||
|
||||
from orgmode.py3compat.encode_compatibility import *
|
||||
|
||||
ORGMODE.debug = True
|
||||
|
||||
START = True
|
||||
END = False
|
||||
|
||||
counter = 0
|
||||
class TagsPropertiesTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
global counter
|
||||
counter += 1
|
||||
vim.CMDHISTORY = []
|
||||
vim.CMDRESULTS = {}
|
||||
vim.EVALHISTORY = []
|
||||
vim.EVALRESULTS = {
|
||||
# no org_todo_keywords for b
|
||||
u_encode(u'exists("b:org_todo_keywords")'): u_encode('0'),
|
||||
# global values for org_todo_keywords
|
||||
u_encode(u'exists("g:org_todo_keywords")'): u_encode('1'),
|
||||
u_encode(u'g:org_todo_keywords'): [u_encode(u'TODO'), u_encode(u'|'), u_encode(u'DONE')],
|
||||
u_encode(u'&ts'): u_encode(u'6'),
|
||||
u_encode(u'exists("b:org_tag_column")'): u_encode(u'0'),
|
||||
u_encode(u'exists("g:org_tag_column")'): u_encode(u'0'),
|
||||
u_encode(u'exists("g:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("*repeat#set()")'): u_encode(u'0'),
|
||||
u_encode(u'b:changedtick'): (u_encode(u'%d' % counter)),
|
||||
u_encode(u"v:count"): u_encode(u'0')}
|
||||
if not u'TagsProperties' in ORGMODE.plugins:
|
||||
ORGMODE.register_plugin(u'TagsProperties')
|
||||
self.tagsproperties = ORGMODE.plugins[u'TagsProperties']
|
||||
vim.current.buffer[:] = [ u_encode(i) for i in u"""
|
||||
* Überschrift 1
|
||||
Text 1
|
||||
|
||||
Bla bla
|
||||
** Überschrift 1.1
|
||||
Text 2
|
||||
|
||||
Bla Bla bla
|
||||
** Überschrift 1.2
|
||||
Text 3
|
||||
|
||||
**** Überschrift 1.2.1.falsch
|
||||
|
||||
Bla Bla bla bla
|
||||
*** Überschrift 1.2.1
|
||||
* Überschrift 2
|
||||
* Überschrift 3
|
||||
asdf sdf
|
||||
""".split(u'\n') ]
|
||||
|
||||
def test_new_property(self):
|
||||
u""" TODO: Docstring for test_new_property
|
||||
|
||||
:returns: TODO
|
||||
"""
|
||||
pass
|
||||
|
||||
def test_set_tags(self):
|
||||
# set first tag
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", "", "customlist,Org_complete_tags")')] = u_encode(u':hello:')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t\t :hello:'))
|
||||
|
||||
# set second tag
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", ":hello:", "customlist,Org_complete_tags")')] = u_encode(u':hello:world:')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t :hello:world:'))
|
||||
|
||||
def test_parse_tags_no_colons_single_tag(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", "", "customlist,Org_complete_tags")')] = u_encode(u'hello')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t\t :hello:'))
|
||||
|
||||
def test_parse_tags_no_colons_multiple_tags(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", "", "customlist,Org_complete_tags")')] = u_encode(u'hello:world')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t :hello:world:'))
|
||||
|
||||
def test_parse_tags_single_colon_left_single_tag(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", "", "customlist,Org_complete_tags")')] = u_encode(u':hello')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t\t :hello:'))
|
||||
|
||||
def test_parse_tags_single_colon_left_multiple_tags(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", "", "customlist,Org_complete_tags")')] = u_encode(u':hello:world')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t :hello:world:'))
|
||||
|
||||
def test_parse_tags_single_colon_right_single_tag(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", "", "customlist,Org_complete_tags")')] = u_encode(u'hello:')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t\t :hello:'))
|
||||
|
||||
def test_parse_tags_single_colon_right_multiple_tags(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", "", "customlist,Org_complete_tags")')] = u_encode(u'hello:world:')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t :hello:world:'))
|
||||
|
||||
def test_filter_empty_tags(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", "", "customlist,Org_complete_tags")')] = u_encode(u'::hello::')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t\t :hello:'))
|
||||
|
||||
def test_delete_tags(self):
|
||||
# set up
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", "", "customlist,Org_complete_tags")')] = u_encode(u':hello:world:')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t :hello:world:'))
|
||||
|
||||
# delete second of two tags
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", ":hello:world:", "customlist,Org_complete_tags")')] = u_encode(u':hello:')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t\t :hello:'))
|
||||
|
||||
# delete last tag
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", ":hello:", "customlist,Org_complete_tags")')] = u_encode(u'')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1'))
|
||||
|
||||
def test_realign_tags_noop(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
self.tagsproperties.realign_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1'))
|
||||
|
||||
def test_realign_tags_remove_spaces(self):
|
||||
# remove spaces in multiple locations
|
||||
vim.current.buffer[1] = u_encode(u'* Überschrift 1 ')
|
||||
vim.current.window.cursor = (2, 0)
|
||||
self.tagsproperties.realign_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1'))
|
||||
|
||||
# remove tabs and spaces in multiple locations
|
||||
vim.current.buffer[1] = u_encode(u'*\t \tÜberschrift 1 \t')
|
||||
vim.current.window.cursor = (2, 0)
|
||||
self.tagsproperties.realign_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1'))
|
||||
|
||||
def test_realign_tags(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.EVALRESULTS[u_encode(u'input("Tags: ", "", "customlist,Org_complete_tags")')] = u_encode(u':hello:world:')
|
||||
self.tagsproperties.set_tags()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t :hello:world:'))
|
||||
|
||||
d = ORGMODE.get_document()
|
||||
heading = d.find_current_heading()
|
||||
self.assertEqual(str(heading), u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t :hello:world:'))
|
||||
self.tagsproperties.realign_tags()
|
||||
heading = d.find_current_heading()
|
||||
self.assertEqual(str(heading), u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t :hello:world:'))
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'* Überschrift 1\t\t\t\t\t\t\t\t :hello:world:'))
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(TagsPropertiesTestCase)
|
||||
422
dot_vim/plugged/vim-orgmode/tests/test_plugin_todo.py
Normal file
422
dot_vim/plugged/vim-orgmode/tests/test_plugin_todo.py
Normal file
@@ -0,0 +1,422 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
|
||||
import sys
|
||||
sys.path.append(u'../ftplugin')
|
||||
|
||||
import unittest
|
||||
from orgmode.liborgmode.base import Direction
|
||||
from orgmode.vimbuffer import VimBuffer
|
||||
from orgmode.plugins.Todo import Todo
|
||||
|
||||
import vim
|
||||
|
||||
from orgmode.py3compat.encode_compatibility import *
|
||||
|
||||
counter = 0
|
||||
|
||||
class TodoTestCase(unittest.TestCase):
|
||||
u"""Tests all the functionality of the TODO module."""
|
||||
|
||||
def setUp(self):
|
||||
# set content of the buffer
|
||||
global counter
|
||||
counter += 1
|
||||
vim.EVALHISTORY = []
|
||||
vim.EVALRESULTS = {
|
||||
# no org_todo_keywords for b
|
||||
u_encode(u'exists("b:org_todo_keywords")'): u_encode('0'),
|
||||
# global values for org_todo_keywords
|
||||
u_encode(u'exists("g:org_todo_keywords")'): u_encode('1'),
|
||||
u_encode(u'g:org_todo_keywords'): [u_encode(u'TODO'), u_encode(u'|'), u_encode(u'DONE')],
|
||||
u_encode(u'exists("g:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("b:org_debug")'): u_encode(u'0'),
|
||||
u_encode(u'exists("*repeat#set()")'): u_encode(u'0'),
|
||||
u_encode(u'b:changedtick'): u_encode(u'%d' % counter),
|
||||
u_encode(u"v:count"): u_encode(u'0')
|
||||
}
|
||||
|
||||
vim.current.buffer[:] = [ u_encode(i) for i in u"""
|
||||
* Heading 1
|
||||
** Text 1
|
||||
*** Text 2
|
||||
* Text 1
|
||||
** Text 1
|
||||
some text that is
|
||||
no heading
|
||||
|
||||
""".split(u'\n') ]
|
||||
|
||||
# toggle
|
||||
def test_toggle_todo_with_no_heading(self):
|
||||
# nothing should happen
|
||||
vim.current.window.cursor = (1, 0)
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[0], u'')
|
||||
# and repeat it -> it should not change
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[0], u'')
|
||||
|
||||
def test_todo_toggle_NOTODO(self):
|
||||
vim.current.window.cursor = (2, 0)
|
||||
vim.current.buffer[1] = u_encode(u'** NOTODO Überschrift 1.1')
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[1], u_encode(u'** TODO NOTODO Überschrift 1.1'))
|
||||
|
||||
def test_toggle_todo_in_heading_with_no_todo_state_different_levels(self):
|
||||
# level 1
|
||||
vim.current.window.cursor = (2, 0)
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[1], u'* TODO Heading 1')
|
||||
self.assertEqual((2, 0), vim.current.window.cursor)
|
||||
|
||||
# level 2
|
||||
vim.current.window.cursor = (3, 0)
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[2], u'** TODO Text 1')
|
||||
|
||||
# level 2
|
||||
vim.current.window.cursor = (4, 4)
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[3], u'*** TODO Text 2')
|
||||
self.assertEqual((4, 9), vim.current.window.cursor)
|
||||
|
||||
def test_circle_through_todo_states(self):
|
||||
# * Heading 1 -->
|
||||
# * TODO Heading 1 -->
|
||||
# * DONE Heading 1 -->
|
||||
# * Heading 1 -->
|
||||
# * TODO Heading 1 -->
|
||||
# * DONE Heading 1
|
||||
vim.current.window.cursor = (2, 6)
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[1], u'* TODO Heading 1')
|
||||
self.assertEqual((2, 11), vim.current.window.cursor)
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[1], u'* DONE Heading 1')
|
||||
self.assertEqual((2, 11), vim.current.window.cursor)
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[1], u'* Heading 1')
|
||||
self.assertEqual((2, 6), vim.current.window.cursor)
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[1], u'* TODO Heading 1')
|
||||
self.assertEqual((2, 11), vim.current.window.cursor)
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[1], u'* DONE Heading 1')
|
||||
self.assertEqual((2, 11), vim.current.window.cursor)
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[1], u'* Heading 1')
|
||||
self.assertEqual((2, 6), vim.current.window.cursor)
|
||||
|
||||
def test_circle_through_todo_states_with_more_states(self):
|
||||
# * Heading 1 -->
|
||||
# * TODO Heading 1 -->
|
||||
# * STARTED Heading 1 -->
|
||||
# * DONE Heading 1 -->
|
||||
# * Heading 1 -->
|
||||
vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = [u_encode(u'TODO'), u_encode(u'STARTED'), u_encode(u'DONE'),
|
||||
u_encode(u'|')]
|
||||
vim.current.window.cursor = (2, 0)
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[1], u'* TODO Heading 1')
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[1], u'* STARTED Heading 1')
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[1], u'* DONE Heading 1')
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[1], u'* Heading 1')
|
||||
|
||||
def test_toggle_todo_with_cursor_in_text_not_heading(self):
|
||||
# nothing should happen
|
||||
vim.current.window.cursor = (7, 0)
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[5], u'** TODO Text 1')
|
||||
self.assertEqual(vim.current.window.cursor, (7, 0))
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[5], u'** DONE Text 1')
|
||||
self.assertEqual(vim.current.window.cursor, (7, 0))
|
||||
|
||||
Todo.toggle_todo_state()
|
||||
self.assertEqual(vim.current.buffer[5], u'** Text 1')
|
||||
self.assertEqual(vim.current.window.cursor, (7, 0))
|
||||
|
||||
# get_states
|
||||
def test_get_states_without_seperator(self):
|
||||
u"""The last element in the todostates shouold be used as DONE-state when no sperator is given"""
|
||||
vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = [u_encode(u'TODO'), u_encode(u'DONE')]
|
||||
states_todo, states_done = VimBuffer().get_todo_states()[0]
|
||||
expected_todo, expected_done = [u'TODO'], [u'DONE']
|
||||
self.assertEqual(states_todo, expected_todo)
|
||||
self.assertEqual(states_done, expected_done)
|
||||
|
||||
vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = [u_encode(u'TODO'), u_encode(u'INPROGRESS'), u_encode(u'DONE')]
|
||||
states_todo, states_done = VimBuffer().get_todo_states()[0]
|
||||
expected_todo = [u'TODO', u'INPROGRESS']
|
||||
expected_done = [u'DONE']
|
||||
self.assertEqual(states_todo, expected_todo)
|
||||
self.assertEqual(states_done, expected_done)
|
||||
|
||||
vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = [u_encode(u'TODO'), u_encode(u'INPROGRESS'),
|
||||
u_encode(u'DUMMY'), u_encode(u'DONE')]
|
||||
states_todo, states_done = VimBuffer().get_todo_states()[0]
|
||||
expected_todo = [u'TODO', u'INPROGRESS', u'DUMMY']
|
||||
expected_done = [u'DONE']
|
||||
self.assertEqual(states_todo, expected_todo)
|
||||
self.assertEqual(states_done, expected_done)
|
||||
|
||||
def test_get_states_with_seperator(self):
|
||||
vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = [u_encode(u'TODO'), u_encode(u'|'), u_encode(u'DONE')]
|
||||
states_todo, states_done = VimBuffer().get_todo_states()[0]
|
||||
expected_todo = [u'TODO']
|
||||
expected_done = [u'DONE']
|
||||
self.assertEqual(states_todo, expected_todo)
|
||||
self.assertEqual(states_done, expected_done)
|
||||
|
||||
vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = [u_encode(u'TODO'), u_encode(u'INPROGRESS'), u_encode(u'|'),
|
||||
u_encode(u'DONE')]
|
||||
states_todo, states_done = VimBuffer().get_todo_states()[0]
|
||||
expected_todo = [u'TODO', u'INPROGRESS']
|
||||
expected_done = [u'DONE']
|
||||
self.assertEqual(states_todo, expected_todo)
|
||||
self.assertEqual(states_done, expected_done)
|
||||
|
||||
vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = [u_encode(u'TODO'), u_encode(u'INPROGRESS'),
|
||||
u_encode(u'DUMMY'), u_encode(u'|'), u_encode(u'DONE')]
|
||||
states_todo, states_done = VimBuffer().get_todo_states()[0]
|
||||
expected_todo = [u'TODO', u'INPROGRESS', u'DUMMY']
|
||||
expected_done = [u'DONE']
|
||||
self.assertEqual(states_todo, expected_todo)
|
||||
self.assertEqual(states_done, expected_done)
|
||||
|
||||
vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = [u_encode(u'TODO'), u_encode(u'INPROGRESS'),
|
||||
u_encode(u'DUMMY'), u_encode(u'|'), u_encode(u'DELEGATED'), u_encode(u'DONE')]
|
||||
states_todo, states_done = VimBuffer().get_todo_states()[0]
|
||||
expected_todo =[u'TODO', u'INPROGRESS', u'DUMMY']
|
||||
expected_done = [u'DELEGATED', u'DONE']
|
||||
self.assertEqual(states_todo, expected_todo)
|
||||
self.assertEqual(states_done, expected_done)
|
||||
|
||||
vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = [u_encode(u'TODO'), u_encode(u'|'), u_encode(u'DONEX'),
|
||||
u_encode(u'DUMMY'), u_encode(u'DELEGATED'), u_encode(u'DONE')]
|
||||
states_todo, states_done = VimBuffer().get_todo_states()[0]
|
||||
expected_todo = [u'TODO']
|
||||
expected_done = [u'DONEX', u'DUMMY', u'DELEGATED', u'DONE']
|
||||
self.assertEqual(states_todo, expected_todo)
|
||||
self.assertEqual(states_done, expected_done)
|
||||
|
||||
vim.EVALRESULTS[u_encode(u'g:org_todo_keywords')] = [[u_encode(u'TODO(t)'), u_encode(u'|'), u_encode(u'DONEX')],
|
||||
[u_encode(u'DUMMY'), u_encode(u'DELEGATED'), u_encode(u'DONE')]]
|
||||
states_todo, states_done = VimBuffer().get_todo_states()[0]
|
||||
expected_todo = [u'TODO']
|
||||
expected_done = [u'DONEX']
|
||||
self.assertEqual(states_todo, expected_todo)
|
||||
self.assertEqual(states_done, expected_done)
|
||||
|
||||
# get_next_state
|
||||
def test_get_next_state_with_no_current_state(self):
|
||||
states = [((u'TODO', ), (u'DONE', ))]
|
||||
current_state = u''
|
||||
self.assertEquals(Todo._get_next_state(current_state, states), u'TODO')
|
||||
|
||||
states = [((u'TODO', u'NEXT'), (u'DELEGATED', u'DONE'))]
|
||||
self.assertEquals(Todo._get_next_state(current_state, states), u'TODO')
|
||||
|
||||
states = [((u'NEXT', ), (u'DELEGATED', u'DONE'))]
|
||||
self.assertEquals(Todo._get_next_state(current_state, states), u'NEXT')
|
||||
|
||||
def test_get_next_state_backward_with_no_current_state(self):
|
||||
states = [((u'TODO', ), (u'DONE', ))]
|
||||
current_state = u''
|
||||
self.assertEquals(Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD), u'DONE')
|
||||
|
||||
states = [((u'TODO', u'NEXT'), (u'DELEGATED', u'DONE'))]
|
||||
self.assertEquals(Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD), u'DONE')
|
||||
|
||||
states = [((u'NEXT', ), (u'DELEGATED', u'DONE'))]
|
||||
self.assertEquals(Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD), u'DONE')
|
||||
|
||||
def test_get_next_state_with_invalid_current_state(self):
|
||||
states = [((u'TODO', ), (u'DONE', ))]
|
||||
current_state = u'STI'
|
||||
self.assertEquals(Todo._get_next_state(current_state, states), u'TODO')
|
||||
|
||||
states = [((u'TODO', u'NEXT'), (u'DELEGATED', u'DONE'))]
|
||||
self.assertEquals(Todo._get_next_state(current_state, states), u'TODO')
|
||||
|
||||
states = [((u'NEXT', ), (u'DELEGATED', u'DONE'))]
|
||||
self.assertEquals(Todo._get_next_state(current_state, states), u'NEXT')
|
||||
|
||||
def test_get_next_state_backward_with_invalid_current_state(self):
|
||||
states = [((u'TODO', ), (u'DONE', ))]
|
||||
current_state = u'STI'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD)
|
||||
self.assertEquals(result, u'DONE')
|
||||
|
||||
states = [((u'TODO', u'NEXT'), (u'DELEGATED', u'DONE'))]
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD)
|
||||
self.assertEquals(result, u'DONE')
|
||||
|
||||
states = [((u'NEXT', ), (u'DELEGATED', u'DONE'))]
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD)
|
||||
self.assertEquals(result, u'DONE')
|
||||
|
||||
def test_get_next_state_with_current_state_equals_todo_state(self):
|
||||
states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE'))]
|
||||
current_state = u'TODO'
|
||||
self.assertEquals(Todo._get_next_state(current_state, states), u'NEXT')
|
||||
|
||||
current_state = u'NEXT'
|
||||
self.assertEquals(Todo._get_next_state(current_state, states), u'NOW')
|
||||
|
||||
def test_get_next_state_backward_with_current_state_equals_todo_state(self):
|
||||
states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE'))]
|
||||
current_state = u'TODO'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD)
|
||||
self.assertEquals(result, None)
|
||||
|
||||
def test_get_next_state_backward_misc(self):
|
||||
states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE'))]
|
||||
current_state = u'DONE'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD)
|
||||
self.assertEquals(result, u'DELEGATED')
|
||||
|
||||
current_state = u'DELEGATED'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD)
|
||||
self.assertEquals(result, u'NOW')
|
||||
|
||||
current_state = u'NOW'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD)
|
||||
self.assertEquals(result, u'NEXT')
|
||||
|
||||
current_state = u'NEXT'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD)
|
||||
self.assertEquals(result, u'TODO')
|
||||
|
||||
current_state = u'TODO'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD)
|
||||
self.assertEquals(result, None)
|
||||
|
||||
current_state = None
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD)
|
||||
self.assertEquals(result, u'DONE')
|
||||
|
||||
def test_get_next_state_with_jump_from_todo_to_done(self):
|
||||
states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE'))]
|
||||
current_state = u'NOW'
|
||||
self.assertEquals(Todo._get_next_state(current_state, states), u'DELEGATED')
|
||||
|
||||
def test_get_next_state_with_jump_from_done_to_todo(self):
|
||||
states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE'))]
|
||||
current_state = u'DONE'
|
||||
self.assertEquals(Todo._get_next_state(current_state, states), None)
|
||||
|
||||
def test_get_next_state_in_current_sequence(self):
|
||||
states = [((u'TODO', u'NEXT', u'NOW'), (u'DELEGATED', u'DONE')), ((u'QA', ), (u'RELEASED', ))]
|
||||
current_state = u'QA'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.FORWARD)
|
||||
self.assertEquals(result, u'RELEASED')
|
||||
|
||||
def test_get_next_state_in_current_sequence_with_access_keys(self):
|
||||
states = [((u'TODO(t)', u'NEXT(n)', u'NOW(w)'), (u'DELEGATED(g)', u'DONE(d)')), ((u'QA(q)', ), (u'RELEASED(r)', ))]
|
||||
current_state = u'QA'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.FORWARD)
|
||||
self.assertEquals(result, u'RELEASED')
|
||||
|
||||
current_state = u'NEXT'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.FORWARD)
|
||||
self.assertEquals(result, u'NOW')
|
||||
|
||||
current_state = u'TODO'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD)
|
||||
self.assertEquals(result, None)
|
||||
|
||||
current_state = None
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD)
|
||||
self.assertEquals(result, u'RELEASED')
|
||||
|
||||
def test_get_next_keyword_sequence(self):
|
||||
states = [((u'TODO(t)', u'NEXT(n)', u'NOW(w)'), (u'DELEGATED(g)', u'DONE(d)')), ((u'QA(q)', ), (u'RELEASED(r)', ))]
|
||||
current_state = None
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.FORWARD, next_set=True)
|
||||
self.assertEquals(result, u'TODO')
|
||||
|
||||
current_state = None
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD, next_set=True)
|
||||
self.assertEquals(result, u'QA')
|
||||
|
||||
current_state = u'TODO'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD, next_set=True)
|
||||
self.assertEquals(result, None)
|
||||
|
||||
current_state = u'TODO'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.FORWARD, next_set=True)
|
||||
self.assertEquals(result, u'QA')
|
||||
|
||||
current_state = u'NOW'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.FORWARD, next_set=True)
|
||||
self.assertEquals(result, u'QA')
|
||||
|
||||
current_state = u'DELEGATED'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.FORWARD, next_set=True)
|
||||
self.assertEquals(result, u'QA')
|
||||
|
||||
current_state = u'QA'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD, next_set=True)
|
||||
self.assertEquals(result, u'TODO')
|
||||
|
||||
current_state = u'QA'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.FORWARD, next_set=True)
|
||||
self.assertEquals(result, None)
|
||||
|
||||
current_state = u'RELEASED'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.FORWARD, next_set=True)
|
||||
self.assertEquals(result, None)
|
||||
|
||||
current_state = u'RELEASED'
|
||||
result = Todo._get_next_state(current_state, states,
|
||||
Direction.BACKWARD, next_set=True)
|
||||
self.assertEquals(result, u'TODO')
|
||||
|
||||
|
||||
def suite():
|
||||
return unittest.TestLoader().loadTestsFromTestCase(TodoTestCase)
|
||||
1257
dot_vim/plugged/vim-orgmode/tests/test_vimbuffer.py
Normal file
1257
dot_vim/plugged/vim-orgmode/tests/test_vimbuffer.py
Normal file
File diff suppressed because it is too large
Load Diff
88
dot_vim/plugged/vim-orgmode/tests/vim.py
Normal file
88
dot_vim/plugged/vim-orgmode/tests/vim.py
Normal file
@@ -0,0 +1,88 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
|
||||
class VimWindow(object):
|
||||
u""" Docstring for VimWindow """
|
||||
|
||||
def __init__(self, test):
|
||||
object.__init__(self)
|
||||
self._test = test
|
||||
self.cursor = (1, 0)
|
||||
|
||||
def buffer():
|
||||
def fget(self):
|
||||
return self._test.buffer
|
||||
|
||||
def fset(self, value):
|
||||
self._test.buffer = value
|
||||
return locals()
|
||||
buffer = property(**buffer())
|
||||
|
||||
|
||||
class VimBuffer(list):
|
||||
def __init__(self, iterable=None):
|
||||
self.number = 0
|
||||
if iterable is not None:
|
||||
list.__init__(self, iterable)
|
||||
else:
|
||||
list.__init__(self)
|
||||
|
||||
def append(self, o):
|
||||
u"""
|
||||
mimic the specific behavior of vim.current.buffer
|
||||
"""
|
||||
if isinstance(o, list) or isinstance(o, tuple):
|
||||
for i in o:
|
||||
list.append(self, i)
|
||||
else:
|
||||
list.append(self, o)
|
||||
|
||||
|
||||
class VimTest(object):
|
||||
u""" Replacement for vim API """
|
||||
|
||||
def __init__(self):
|
||||
object.__init__(self)
|
||||
self._buffer = VimBuffer()
|
||||
self.window = VimWindow(self)
|
||||
|
||||
def buffer():
|
||||
def fget(self):
|
||||
return self._buffer
|
||||
|
||||
def fset(self, value):
|
||||
self._buffer = VimBuffer(value)
|
||||
return locals()
|
||||
buffer = property(**buffer())
|
||||
|
||||
|
||||
EVALHISTORY = []
|
||||
EVALRESULTS = {
|
||||
u'exists("g:org_debug")': 0,
|
||||
u'exists("b:org_debug")': 0,
|
||||
u'exists("*repeat#set()")': 0,
|
||||
u'exists("b:org_plugins")': 0,
|
||||
u'exists("g:org_plugins")': 0,
|
||||
u'b:changedtick': 0,
|
||||
}
|
||||
|
||||
|
||||
def eval(cmd):
|
||||
u""" evaluate command
|
||||
|
||||
:returns: results stored in EVALRESULTS
|
||||
"""
|
||||
EVALHISTORY.append(cmd)
|
||||
return EVALRESULTS.get(cmd, None)
|
||||
|
||||
|
||||
CMDHISTORY = []
|
||||
CMDRESULTS = {}
|
||||
|
||||
|
||||
def command(cmd):
|
||||
CMDHISTORY.append(cmd)
|
||||
return CMDRESULTS.get(cmd, None)
|
||||
|
||||
|
||||
current = VimTest()
|
||||
Reference in New Issue
Block a user