def runTest(self):
if os.name == 'posix':
# There is an upper limit to lenght of a socket name for AF_UNIX
# (107 characters ?). On OS X the path to TMPDIR already consumes
# 50 chars, and we use "zim-$USER" -- so can still give errors for
# user names > 20 chars. But basename should be limitted.
from zim.main.ipc import SERVER_ADDRESS
self.assertLessEqual(
len(os.path.basename(SERVER_ADDRESS)), 25,
"name too long: %s" % os.path.basename(SERVER_ADDRESS))
inbox = [None]
def handler(*args):
inbox[0] = args
zim.main.ipc.start_listening(handler)
self.addCleanup(zim.main.ipc._close_listener)
self.assertRaises(AssertionError, zim.main.ipc.dispatch, 'test', '123')
# raises due to sanity check same process
zim.main.ipc.set_in_main_process(False) # overrule sanity check
t = threading.Thread(target=zim.main.ipc.dispatch,
args=('test', '123'))
t.start()
while t.is_alive():
tests.gtk_process_events()
tests.gtk_process_events()
self.assertEqual(inbox[0], ('test', '123'))
def runTest(self):
notebook = self.setUpNotebook(content=tests.FULL_NOTEBOOK)
notebook.index.flush()
self.assertFalse(notebook.index.is_uptodate)
notebook.index.start_background_check(notebook)
while notebook.index.background_check.running:
tests.gtk_process_events()
self.assertTrue(notebook.index.is_uptodate)
self.assertTrue(notebook.pages.n_all_pages() > 10)
notebook.index.stop_background_check()
def runTest(self):
counter = tests.Counter()
callback = DelayedCallback(500, lambda o: counter())
for i in range(3):
callback('foo')
for i in range(10):
time.sleep(1)
tests.gtk_process_events()
if callback.timer_id is None:
break
self.assertEqual(counter.count, 1)
def runTest(self):
counter = tests.Counter()
callback = DelayedCallback(500, lambda o: counter())
for i in range(3):
callback('foo')
for i in range(10):
time.sleep(1)
tests.gtk_process_events()
if callback.timer_id is None:
break
self.assertEqual(counter.count, 1)
def runTest(self):
cb = tests.CallBackLogger()
callback = DelayedCallback(500, lambda o: cb())
for i in range(3):
callback('foo')
for i in range(10):
time.sleep(1)
tests.gtk_process_events()
if callback.timer_id is None:
break
self.assertTrue(cb.hasBeenCalled)
def runTest(self):
inbox = [None]
def handler(*args):
inbox[0] = args
zim.main.ipc.start_listening(handler)
self.addCleanup(zim.main.ipc._close_listener)
self.assertRaises(AssertionError, zim.main.ipc.dispatch, '--manual')
zim.main.ipc.set_in_main_process(False) # overrule sanity check
zim.main.ipc.dispatch('test', '123')
tests.gtk_process_events()
self.assertEqual(inbox[0], ('test', '123'))
def runTest(self):
notebook = self.setUpNotebook()
page = notebook.get_page(Path('Page1'))
tree = WikiParser().parse('test 123\n')
signals = tests.SignalLogger(notebook)
op = notebook.store_page_async(page, tree)
thread = op._thread
while thread.is_alive():
tests.gtk_process_events()
tests.gtk_process_events()
self.assertFalse(op.error_event.is_set())
text = page.dump('wiki')
self.assertEqual(text[-1], 'test 123\n')
self.assertEqual(signals['stored-page'], [(page,)]) # post handler happened as well
def testTreeView(self):
ui = MockUI()
ui.notebook = self.notebook
ui.page = Path('foobar')
self.assertTrue(self.notebook.get_page(ui.page).exists())
self.notebook.index.flush() # we want to index ourselves
treestore = self.storeclass(self.notebook.index, self.tags)
treeview = self.viewclass(ui, treestore)
# Process signals on by one
self.assertEqual(self.notebook.pages.n_all_pages(), 0) # assert we start blank
for p in self.notebook.index.update_iter():
tests.gtk_process_events()
tests.gtk_process_events()
# Try some TreeView methods
path = Path('foobar')
treepath = treeview.get_model().find(path)
self.assertEqual(treeview.set_current_page(path), treepath)
col = treeview.get_column(0)
treeview.row_activated(treepath, col)
#~ treeview.emit('popup-menu')
treeview.emit('insert-link', path)
treeview.emit('copy')
# Check signals for page change
page = self.notebook.get_page(Path('Foo'))
page.parse('wiki', 'Fooo @tag1 @tag2\n')
self.notebook.store_page(page)
tests.gtk_process_events()
page.parse('wiki', 'Fooo @foo @bar @tag2\n')
self.notebook.store_page(page)
tests.gtk_process_events()
# Check if all the signals go OK in delete
for page in reversed(list(self.notebook.pages.walk())): # delete bottom up
self.notebook.delete_page(page)
tests.gtk_process_events()
def testAttachFileDialog(self):
'''Test AttachFileDialog'''
tmp_dir = self.create_tmp_dir('testAttachFileDialog')
file = File((tmp_dir, 'file_to_be_attached'))
file.write('Test 1 2 3\n')
newfile = File(
(tmp_dir, 'attachments', 'Test', 'foo', 'file_to_be_attached'))
self.assertTrue(file.exists())
self.assertFalse(newfile.exists())
mainwindow = tests.MockObject()
mainwindow.pageview = tests.MockObject()
mainwindow.ui = self.ui
dialog = zim.gui.AttachFileDialog(mainwindow,
self.ui.notebook,
path=Path('Test:foo'))
dialog.set_file(file)
tests.gtk_process_events()
dialog.assert_response_ok()
self.assertTrue(file.exists()) # No move or delete happened
self.assertTrue(newfile.exists())
self.assertTrue(newfile.compare(file))
def runTest(self):
'''Test TaggedPageTreeStore index interface'''
# This is one big test instead of seperate sub tests because in the
# subclass we generate a file based notebook in setUp, and we do not
# want to do that many times.
# Hooking up the treeview as well just to see if we get any errors
# From the order the signals are generated.
ui = MockUI()
ui.notebook = self.notebook
ui.page = Path('Test:foo')
self.assertTrue(self.notebook.get_page(ui.page).exists())
treestore = self.storeclass(self.index)
self.assertEqual(treestore.get_flags(), 0)
self.assertEqual(treestore.get_n_columns(), 8)
treeview = self.viewclass(ui, treestore)
model = treeview.get_model()
if isinstance(model, gtk.TreeModelFilter):
model = model.get_model() # look inside filtered model
self.assertEqual(model, treestore)
self.assertEqual(treestore.get_flags(), 0)
self.assertEqual(treestore.get_n_columns(), 8)
self.index.update(callback=tests.gtk_process_events)
tests.gtk_process_events()
#~ treeview = PageTreeView(None) # just run hidden to check errors
#~ treeview.set_model(treestore)
n = treestore.on_iter_n_children(None)
self.assertTrue(n > 0)
n = treestore.iter_n_children(None)
self.assertTrue(n > 0)
for i in range(treestore.get_n_columns()):
self.assertTrue(not treestore.get_column_type(i) is None)
# Quick check for basic methods
iter = treestore.on_get_iter((0,))
self.assertTrue(isinstance(iter, (PageTreeIter, PageTreeTagIter)))
if self.storeclass is TaggedPageTreeStore:
self.assertTrue(isinstance(iter, PageTreeIter))
self.assertTrue(isinstance(iter.indexpath, IndexPath))
self.assertFalse(iter.indexpath.isroot)
else:
self.assertTrue(isinstance(iter, PageTreeTagIter))
self.assertTrue(isinstance(iter.indextag, IndexTag))
basename = treestore.on_get_value(iter, 0)
self.assertTrue(len(basename) > 0)
self.assertEqual(iter.treepath, (0,))
self.assertEqual(treestore.on_get_path(iter), (0,))
if self.storeclass is TaggedPageTreeStore:
self.assertEqual(treestore.get_treepath(iter.indexpath), (0,))
self.assertEqual(treestore.get_treepath(Path(iter.indexpath.name)), (0,))
else:
self.assertEqual(treestore.get_treepath(iter.indextag), (0,))
iter2 = treestore.on_iter_children(None)
if self.storeclass is TaggedPageTreeStore:
self.assertEqual(iter2.indexpath, iter.indexpath)
else:
self.assertEqual(iter2.indextag, iter.indextag)
self.assertTrue(treestore.on_get_iter((20,20,20,20,20)) is None)
self.assertTrue(treestore.get_treepath(Path('nonexisting')) is None)
self.assertRaises(ValueError, treestore.get_treepath, Path(':'))
# Now walk through the whole tree testing the API
nitems = 0
path = (0,)
prevpath = None
while path:
#~ print 'PATH', path
assert path != prevpath, 'Prevent infinite loop'
nitems += 1
prevpath = path
iter = treestore.get_iter(path)
self.assertEqual(treestore.get_path(iter), tuple(path))
if isinstance(treestore.on_get_iter(path), PageTreeIter):
self._check_indexpath_iter(treestore, iter, path)
else:
self._check_indextag_iter(treestore, iter, path)
# Determine how to continue
if treestore.iter_has_child(iter):
path = path + (0,)
else:
path = path[:-1] + (path[-1]+1,) # increase last member
while path:
try:
treestore.get_iter(path)
except ValueError:
path = path[:-1]
if len(path):
path = path[:-1] + (path[-1]+1,) # increase last member
else:
break
self.assertTrue(nitems > 10) # double check sanity of loop
# Check if all the signals go OK
treestore.disconnect_index()
del treestore
self.index.flush()
treestore = self.storeclass(self.index)
treeview = TagsPageTreeView(ui, treestore)
self.index.update(callback=tests.gtk_process_events)
# Try some TreeView methods
path = Path('Test:foo')
self.assertTrue(treeview.select_page(path))
self.assertEqual(treeview.get_selected_path(), path)
treepath = treeview.get_model().get_treepath(path)
self.assertTrue(not treepath is None)
col = treeview.get_column(0)
treeview.row_activated(treepath, col)
#~ treeview.emit('popup-menu')
treeview.emit('insert-link', path)
treeview.emit('copy')
# Check if all the signals go OK in delete
for page in reversed(list(self.notebook.walk())): # delete bottom up
self.notebook.delete_page(page)
tests.gtk_process_events()
def runTest(self):
plugin = VersionControlPlugin()
dir = get_tmp_dir('versioncontrol_TestMainWindowExtension')
notebook = self.setUpNotebook(mock=tests.MOCK_ALWAYS_REAL,
content=('Test', ),
folder=LocalFolder(dir.path))
mainwindow = setUpMainWindow(notebook)
plugin.extend(notebook)
plugin.extend(mainwindow)
notebook_ext = find_extension(notebook, NotebookExtension)
window_ext = find_extension(mainwindow,
VersionControlMainWindowExtension)
op = ongoing_operation(notebook)
assert op is None # check no opperation ongoing
## init & save version
self.assertIsNone(notebook_ext.vcs)
def init(dialog):
self.assertIsInstance(dialog, VersionControlInitDialog)
choice = dialog.combobox.get_active_text()
self.assertTrue(choice and not choice.isspace())
dialog.answer_yes()
with tests.DialogContext(init, SaveVersionDialog):
window_ext.save_version()
self.assertIsNotNone(notebook_ext.vcs)
self.assertFalse(notebook_ext.vcs.is_modified())
## save version again
page = notebook.get_page(Path('Foo'))
page.parse('wiki', 'foo!')
notebook.store_page(page)
self.assertTrue(notebook_ext.vcs.is_modified())
with tests.DialogContext(SaveVersionDialog):
window_ext.save_version()
self.assertFalse(notebook_ext.vcs.is_modified())
## show versions
with tests.DialogContext(VersionsDialog):
window_ext.show_versions()
## auto-save
plugin.preferences['autosave'] = True
page = notebook.get_page(Path('Fooooo'))
page.parse('wiki', 'foo!')
notebook.store_page(page)
self.assertTrue(notebook_ext.vcs.is_modified())
mainwindow.emit('close')
self.assertFalse(notebook_ext.vcs.is_modified())
tests.gtk_process_events()
assert ongoing_operation(notebook) is None
def runTest(self):
tmp_dir = Dir(self.create_tmp_dir())
for name in ('test1.txt', 'test2.txt', 'test3.txt'):
tmp_dir.file(name).write('test 123')
tmp_dir.subdir('folder1').touch()
# Single file
file = tmp_dir.file('test1.txt')
self.assertTrue(file.exists())
dialog = FileDialog(None, 'Test')
self.assertIsNone(dialog.get_file())
dialog.set_file(file)
tests.gtk_process_events()
dialog.set_file(file)
tests.gtk_process_events()
dialog.set_file(file)
tests.gtk_process_events()
myfile = dialog.get_file()
self.assertIsInstance(myfile, File)
self.assertEqual(myfile.uri, file.uri)
dialog.assert_response_ok()
self.assertIsInstance(dialog.result, File)
self.assertEqual(dialog.result.uri, file.uri)
# Multiple files
file1 = tmp_dir.file('test1.txt')
file2 = tmp_dir.file('test2.txt')
self.assertTrue(file1.exists())
self.assertTrue(file2.exists())
dialog = FileDialog(None, 'Test', multiple=True)
assert dialog.filechooser.select_uri(file1.uri)
assert dialog.filechooser.select_uri(file2.uri)
tests.gtk_process_events()
self.assertRaises(AssertionError, dialog.get_file)
files = dialog.get_files()
self.assertTrue(all(isinstance(f, File) for f in files))
#~ self.assertEqual([f.uri for f in files], [file1.uri, file2.uri]) -- TODO
## FIXME, fails for unclear reason on windows under msys
#dialog.assert_response_ok()
#self.assertIsInstance(dialog.result, list)
# Select folder
folder = tmp_dir.subdir('folder1')
self.assertTrue(folder.exists())
dialog = FileDialog(None,
'Test',
action=Gtk.FileChooserAction.SELECT_FOLDER)
assert dialog.filechooser.select_uri(folder.uri)
tests.gtk_process_events()
assert dialog.filechooser.select_uri(folder.uri)
tests.gtk_process_events()
assert dialog.filechooser.select_uri(folder.uri)
tests.gtk_process_events()
myfolder = dialog.get_dir()
self.assertIsInstance(myfolder, Dir)
self.assertEqual(myfolder.uri, folder.uri)
dialog.assert_response_ok()
self.assertIsInstance(dialog.result, Dir)
def runTest(self):
'''Test TaggedPageTreeStore index interface'''
# This is one big test instead of seperate sub tests because in the
# subclass we generate a file based notebook in setUp, and we do not
# want to do that many times.
# Hooking up the treeview as well just to see if we get any errors
# From the order the signals are generated.
ui = MockUI()
ui.notebook = self.notebook
ui.page = Path('Test:foo')
self.assertTrue(self.notebook.get_page(ui.page).exists())
treestore = self.storeclass(self.index)
self.assertEqual(treestore.get_flags(), 0)
self.assertEqual(treestore.get_n_columns(), 8)
treeview = self.viewclass(ui, treestore)
model = treeview.get_model()
if isinstance(model, gtk.TreeModelFilter):
model = model.get_model() # look inside filtered model
self.assertEqual(model, treestore)
self.assertEqual(treestore.get_flags(), 0)
self.assertEqual(treestore.get_n_columns(), 8)
self.index.update(callback=tests.gtk_process_events)
tests.gtk_process_events()
#~ treeview = PageTreeView(None) # just run hidden to check errors
#~ treeview.set_model(treestore)
n = treestore.on_iter_n_children(None)
self.assertTrue(n > 0)
n = treestore.iter_n_children(None)
self.assertTrue(n > 0)
for i in range(treestore.get_n_columns()):
self.assertTrue(not treestore.get_column_type(i) is None)
# Quick check for basic methods
iter = treestore.on_get_iter((0, ))
self.assertTrue(isinstance(iter, (PageTreeIter, PageTreeTagIter)))
if self.storeclass is TaggedPageTreeStore:
self.assertTrue(isinstance(iter, PageTreeIter))
self.assertTrue(isinstance(iter.indexpath, IndexPath))
self.assertFalse(iter.indexpath.isroot)
else:
self.assertTrue(isinstance(iter, PageTreeTagIter))
self.assertTrue(isinstance(iter.indextag, IndexTag))
basename = treestore.on_get_value(iter, 0)
self.assertTrue(len(basename) > 0)
self.assertEqual(iter.treepath, (0, ))
self.assertEqual(treestore.on_get_path(iter), (0, ))
if self.storeclass is TaggedPageTreeStore:
self.assertEqual(treestore.get_treepath(iter.indexpath), (0, ))
self.assertEqual(treestore.get_treepath(Path(iter.indexpath.name)),
(0, ))
else:
self.assertEqual(treestore.get_treepath(iter.indextag), (0, ))
iter2 = treestore.on_iter_children(None)
if self.storeclass is TaggedPageTreeStore:
self.assertEqual(iter2.indexpath, iter.indexpath)
else:
self.assertEqual(iter2.indextag, iter.indextag)
self.assertTrue(treestore.on_get_iter((20, 20, 20, 20, 20)) is None)
self.assertTrue(treestore.get_treepath(Path('nonexisting')) is None)
self.assertRaises(ValueError, treestore.get_treepath, Path(':'))
# Now walk through the whole tree testing the API
nitems = 0
path = (0, )
prevpath = None
while path:
#~ print 'PATH', path
assert path != prevpath, 'Prevent infinite loop'
nitems += 1
prevpath = path
iter = treestore.get_iter(path)
self.assertEqual(treestore.get_path(iter), tuple(path))
if isinstance(treestore.on_get_iter(path), PageTreeIter):
self._check_indexpath_iter(treestore, iter, path)
else:
self._check_indextag_iter(treestore, iter, path)
# Determine how to continue
if treestore.iter_has_child(iter):
path = path + (0, )
else:
path = path[:-1] + (path[-1] + 1, ) # increase last member
while path:
try:
treestore.get_iter(path)
except ValueError:
path = path[:-1]
if len(path):
path = path[:-1] + (path[-1] + 1,
) # increase last member
else:
break
self.assertTrue(nitems > 10) # double check sanity of loop
# Check if all the signals go OK
treestore.disconnect_index()
del treestore
self.index.flush()
treestore = self.storeclass(self.index)
treeview = TagsPageTreeView(ui, treestore)
self.index.update(callback=tests.gtk_process_events)
# Try some TreeView methods
path = Path('Test:foo')
self.assertTrue(treeview.set_current_page(path))
# TODO assert something
treepath = treeview.get_model().get_treepath(path)
self.assertTrue(not treepath is None)
col = treeview.get_column(0)
treeview.row_activated(treepath, col)
#~ treeview.emit('popup-menu')
treeview.emit('insert-link', path)
treeview.emit('copy')
# Check if all the signals go OK in delete
for page in reversed(list(self.notebook.walk())): # delete bottom up
self.notebook.delete_page(page)
tests.gtk_process_events()
def runTest(self):
'''Test PageTreeStore index interface'''
# This is one big test instead of seperate sub tests because in the
# subclass we generate a file based notebook in setUp, and we do not
# want to do that many times.
# Hooking up the treeview as well just to see if we get any errors
# From the order the signals are generated.
ui = MockUI()
ui.notebook = self.notebook
ui.page = Path('Test:foo')
self.assertTrue(self.notebook.get_page(ui.page).exists())
treeview = PageTreeView(ui)
treestore = PageTreeStore(self.index)
self.assertEqual(treestore.get_flags(), 0)
self.assertEqual(treestore.get_n_columns(), 7)
treeview.set_model(treestore)
self.index.update(callback=tests.gtk_process_events)
tests.gtk_process_events()
treeview = PageTreeView(ui) # just run hidden to check errors
treeview.set_model(treestore)
n = treestore.on_iter_n_children(None)
self.assertTrue(n > 0)
n = treestore.iter_n_children(None)
self.assertTrue(n > 0)
for i in range(treestore.get_n_columns()):
self.assertTrue(not treestore.get_column_type(i) is None)
# Quick check for basic methods
iter = treestore.on_get_iter((0,))
self.assertTrue(isinstance(iter, PageTreeIter))
self.assertFalse(iter.indexpath.isroot)
basename = treestore.on_get_value(iter, 0)
self.assertTrue(len(basename) > 0)
self.assertEqual(iter.treepath, (0,))
self.assertEqual(treestore.on_get_path(iter), (0,))
self.assertEqual(treestore.get_treepath(iter.indexpath), (0,))
self.assertEqual(treestore.get_treepath(Path(iter.indexpath.name)), (0,))
iter2 = treestore.on_iter_children(None)
self.assertEqual(iter2.indexpath, iter.indexpath)
self.assertTrue(treestore.on_get_iter((20,20,20,20,20)) is None)
self.assertTrue(treestore.get_treepath(Path('nonexisting')) is None)
self.assertRaises(ValueError, treestore.get_treepath, Path(':'))
# Now walk through the whole notebook testing the API
# with nested pages and stuff
npages = 0
path = []
for page in self.notebook.walk():
#~ print '>>', page
npages += 1
names = page.name.split(':')
if len(names) > len(path):
path.append(0) # always increment by one
elif len(names) < len(path):
while len(names) < len(path):
path.pop()
path[-1] += 1
else:
path[-1] += 1
#~ print '>>', page, path
iter = treestore.get_iter(tuple(path))
indexpath = treestore.get_indexpath(iter)
#~ print '>>>', indexpath
self.assertEqual(indexpath, page)
self.assertEqual(treestore.get_value(iter, NAME_COL), page.basename)
self.assertEqual(treestore.get_value(iter, PATH_COL), page)
if page.hascontent or page.haschildren:
self.assertEqual(treestore.get_value(iter, EMPTY_COL), False)
self.assertEqual(treestore.get_value(iter, STYLE_COL), pango.STYLE_NORMAL)
self.assertEqual(treestore.get_value(iter, FGCOLOR_COL), treestore.NORMAL_COLOR)
else:
self.assertEqual(treestore.get_value(iter, EMPTY_COL), True)
self.assertEqual(treestore.get_value(iter, STYLE_COL), pango.STYLE_ITALIC)
self.assertEqual(treestore.get_value(iter, FGCOLOR_COL), treestore.EMPTY_COLOR)
self.assertEqual(treestore.get_path(iter), tuple(path))
if indexpath.haschildren:
self.assertTrue(treestore.iter_has_child(iter))
child = treestore.iter_children(iter)
self.assertTrue(not child is None)
child = treestore.iter_nth_child(iter, 0)
self.assertTrue(not child is None)
parent = treestore.iter_parent(child)
self.assertEqual(
treestore.get_indexpath(parent), page)
childpath = treestore.get_path(child)
self.assertEqual(
childpath, tuple(path) + (0,))
n = treestore.iter_n_children(iter)
for i in range(1, n):
child = treestore.iter_next(child)
childpath = treestore.get_path(child)
self.assertEqual(
childpath, tuple(path) + (i,))
child = treestore.iter_next(child)
self.assertTrue(child is None)
else:
self.assertTrue(not treestore.iter_has_child(iter))
child = treestore.iter_children(iter)
self.assertTrue(child is None)
child = treestore.iter_nth_child(iter, 0)
self.assertTrue(child is None)
self.assertTrue(npages > 10) # double check sanity of walk() method
# Check if all the signals go OK
treestore.disconnect_index()
del treestore
self.index.flush()
treestore = PageTreeStore(self.index)
treeview = PageTreeView(ui, treestore)
self.index.update(callback=tests.gtk_process_events)
# Try some TreeView methods
path = Path('Test:foo')
self.assertTrue(treeview.select_page(path))
self.assertEqual(treeview.get_selected_path(), path)
treepath = treeview.get_model().get_treepath(path)
self.assertTrue(not treepath is None)
col = treeview.get_column(0)
treeview.row_activated(treepath, col)
#~ treeview.emit('popup-menu')
treeview.emit('insert-link', path)
treeview.emit('copy')
# Check if all the signals go OK in delete
for page in reversed(list(self.notebook.walk())): # delete bottom up
self.notebook.delete_page(page)
tests.gtk_process_events()
def runTest(self):
'''Test PageTreeStore index interface'''
# This is one big test instead of seperate sub tests because in the
# subclass we generate a file based notebook in setUp, and we do not
# want to do that many times.
# Hooking up the treeview as well just to see if we get any errors
# From the order the signals are generated.
ui = MockUI()
ui.notebook = self.notebook
ui.page = Path('Test:foo')
self.assertTrue(self.notebook.get_page(ui.page).exists())
treeview = PageTreeView(ui)
treestore = PageTreeStore(self.index)
self.assertEqual(treestore.get_flags(), 0)
self.assertEqual(treestore.get_n_columns(), 8)
treeview.set_model(treestore)
self.index.update(callback=tests.gtk_process_events)
tests.gtk_process_events()
treeview = PageTreeView(ui) # just run hidden to check errors
treeview.set_model(treestore)
n = treestore.on_iter_n_children(None)
self.assertTrue(n > 0)
n = treestore.iter_n_children(None)
self.assertTrue(n > 0)
for i in range(treestore.get_n_columns()):
self.assertTrue(not treestore.get_column_type(i) is None)
# Quick check for basic methods
iter = treestore.on_get_iter((0, ))
self.assertTrue(isinstance(iter, PageTreeIter))
self.assertFalse(iter.indexpath.isroot)
basename = treestore.on_get_value(iter, 0)
self.assertTrue(len(basename) > 0)
self.assertEqual(iter.treepath, (0, ))
self.assertEqual(treestore.on_get_path(iter), (0, ))
self.assertEqual(treestore.get_treepath(iter.indexpath), (0, ))
self.assertEqual(treestore.get_treepath(Path(iter.indexpath.name)),
(0, ))
iter2 = treestore.on_iter_children(None)
self.assertEqual(iter2.indexpath, iter.indexpath)
self.assertTrue(treestore.on_get_iter((20, 20, 20, 20, 20)) is None)
self.assertTrue(treestore.get_treepath(Path('nonexisting')) is None)
self.assertRaises(ValueError, treestore.get_treepath, Path(':'))
# Now walk through the whole notebook testing the API
# with nested pages and stuff
npages = 0
path = []
for page in self.notebook.walk():
#~ print '>>', page
npages += 1
names = page.name.split(':')
if len(names) > len(path):
path.append(0) # always increment by one
elif len(names) < len(path):
while len(names) < len(path):
path.pop()
path[-1] += 1
else:
path[-1] += 1
#~ print '>>', page, path
iter = treestore.get_iter(tuple(path))
indexpath = treestore.get_indexpath(iter)
#~ print '>>>', indexpath
self.assertEqual(indexpath, page)
self.assertEqual(treestore.get_value(iter, NAME_COL),
page.basename)
self.assertEqual(treestore.get_value(iter, PATH_COL), page)
if page.hascontent or page.haschildren:
self.assertEqual(treestore.get_value(iter, EMPTY_COL), False)
self.assertEqual(treestore.get_value(iter, STYLE_COL),
pango.STYLE_NORMAL)
self.assertEqual(treestore.get_value(iter, FGCOLOR_COL),
treestore.NORMAL_COLOR)
else:
self.assertEqual(treestore.get_value(iter, EMPTY_COL), True)
self.assertEqual(treestore.get_value(iter, STYLE_COL),
pango.STYLE_ITALIC)
self.assertEqual(treestore.get_value(iter, FGCOLOR_COL),
treestore.EMPTY_COLOR)
self.assertEqual(treestore.get_path(iter), tuple(path))
if indexpath.haschildren:
self.assertTrue(treestore.iter_has_child(iter))
child = treestore.iter_children(iter)
self.assertTrue(not child is None)
child = treestore.iter_nth_child(iter, 0)
self.assertTrue(not child is None)
parent = treestore.iter_parent(child)
self.assertEqual(treestore.get_indexpath(parent), page)
childpath = treestore.get_path(child)
self.assertEqual(childpath, tuple(path) + (0, ))
n = treestore.iter_n_children(iter)
for i in range(1, n):
child = treestore.iter_next(child)
childpath = treestore.get_path(child)
self.assertEqual(childpath, tuple(path) + (i, ))
child = treestore.iter_next(child)
self.assertTrue(child is None)
else:
self.assertTrue(not treestore.iter_has_child(iter))
child = treestore.iter_children(iter)
self.assertTrue(child is None)
child = treestore.iter_nth_child(iter, 0)
self.assertTrue(child is None)
self.assertTrue(npages > 10) # double check sanity of walk() method
# Check if all the signals go OK
treestore.disconnect_index()
del treestore
self.index.flush()
treestore = PageTreeStore(self.index)
treeview = PageTreeView(ui, treestore)
self.index.update(callback=tests.gtk_process_events)
# Try some TreeView methods
path = Path('Test:foo')
self.assertTrue(treeview.select_page(path))
self.assertEqual(treeview.get_selected_path(), path)
treepath = treeview.get_model().get_treepath(path)
self.assertTrue(not treepath is None)
col = treeview.get_column(0)
treeview.row_activated(treepath, col)
#~ treeview.emit('popup-menu')
treeview.emit('insert-link', path)
treeview.emit('copy')
# Check if all the signals go OK in delete
for page in reversed(list(self.notebook.walk())): # delete bottom up
self.notebook.delete_page(page)
tests.gtk_process_events()
