def test_add_to_toolbar_no_label(self):
window = Window()
window.open()
action_item = ActionItem(action=self.action)
toolbar_manager = ToolBarManager(name='Test')
image_cache = ImageCache(height=32, width=32)
menu = toolbar_manager.create_tool_bar(window.control)
action_item.add_to_toolbar(window.control, menu, image_cache, None, False)
window.close()
def test_add_to_toolbar_no_label(self):
window = Window()
window.open()
action_item = ActionItem(action=self.action)
toolbar_manager = ToolBarManager(name='Test')
image_cache = ImageCache(height=32, width=32)
menu = toolbar_manager.create_tool_bar(window.control)
action_item.add_to_toolbar(window.control, menu, image_cache, None, False)
window.close()
def test_add_to_menu(self):
window = Window()
window.open()
action_item = ActionItem(action=self.action)
menu_bar_manager = MenuBarManager()
menu_manager = MenuManager(name='Test')
menu_bar = menu_bar_manager.create_menu_bar(window.control)
menu = menu_manager.create_menu(menu_bar)
action_item.add_to_menu(window.control, menu, None)
window.close()
def test_add_to_menu(self):
window = Window()
window.open()
action_item = ActionItem(action=self.action)
menu_bar_manager = MenuBarManager()
menu_manager = MenuManager(name='Test')
menu_bar = menu_bar_manager.create_menu_bar(window.control)
menu = menu_manager.create_menu(menu_bar)
action_item.add_to_menu(window.control, menu, None)
window.close()
class TestWidget(unittest.TestCase, UnittestTools):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
self.widget = self._create_widget()
self.parent.open()
self.gui.process_events()
def _create_widget(self):
self.data = np.arange(30.0).reshape(5, 6)
self.model = ArrayDataModel(data=self.data, value_type=FloatValue())
return DataViewWidget(parent=self.parent.control,
data_model=self.model)
def _create_widget_control(self):
self.widget._create()
self.addCleanup(self._destroy_widget)
self.widget.show(True)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def _destroy_widget(self):
self.widget.destroy()
self.gui.process_events()
self.widget = None
def test_defaults(self):
self.assertTrue(self.widget.header_visible)
def test_lifecycle(self):
self._create_widget_control()
def test_header_visible(self):
self._create_widget_control()
self.widget.header_visible = False
self.gui.process_events()
self.assertFalse(self.widget._get_control_header_visible())
def test_header_visible_before_control(self):
self.widget.header_visible = False
self._create_widget_control()
self.assertFalse(self.widget._get_control_header_visible())
def test_add_to_toolbar_controller_false(self):
window = Window()
window.open()
action_item = ActionItem(action=self.action)
toolbar_manager = ToolBarManager(name="Test")
image_cache = ImageCache(height=32, width=32)
menu = toolbar_manager.create_tool_bar(window.control)
controller = FalseActionController()
action_item.add_to_toolbar(window.control, menu, image_cache,
controller, True)
window.close()
def test_add_to_menu_controller_false(self):
window = Window()
window.open()
action_item = ActionItem(action=self.action)
menu_bar_manager = MenuBarManager()
menu_manager = MenuManager(name="Test")
menu_bar = menu_bar_manager.create_menu_bar(window.control)
menu = menu_manager.create_menu(menu_bar)
controller = FalseActionController()
action_item.add_to_menu(window.control, menu, controller)
window.close()
def test_parent(self):
# test that lifecycle works with a parent
parent = Window()
self.dialog.parent = parent.control
parent.open()
tester = ModalDialogTester(self.dialog.open)
tester.open_and_run(when_opened=lambda x: x.close(accept=True))
with self.event_loop():
parent.close()
self.assertEqual(tester.result, OK)
self.assertEqual(self.dialog.return_code, OK)
def test_add_to_toolbar_widget(self):
self.action.style = "widget"
self.action.control_factory = self.control_factory
window = Window()
window.open()
action_item = ActionItem(action=self.action)
toolbar_manager = ToolBarManager(name='Test')
image_cache = ImageCache(height=32, width=32)
menu = toolbar_manager.create_tool_bar(window.control)
try:
action_item.add_to_toolbar(window.control, menu, image_cache, None, True)
finally:
window.close()
def test_add_to_toolbar_widget(self):
self.action.style = "widget"
self.action.control_factory = self.control_factory
window = Window()
window.open()
action_item = ActionItem(action=self.action)
toolbar_manager = ToolBarManager(name='Test')
image_cache = ImageCache(height=32, width=32)
menu = toolbar_manager.create_tool_bar(window.control)
try:
action_item.add_to_toolbar(window.control, menu, image_cache, None, True)
finally:
window.close()
class FieldMixin(UnittestTools):
""" Mixin which provides standard methods for all fields. """
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
self.widget = self._create_widget()
self.parent.open()
self.gui.process_events()
def _create_widget(self):
raise NotImplementedError()
def _create_widget_control(self):
self.widget._create()
self.addCleanup(self._destroy_widget)
self.widget.show(True)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def _destroy_widget(self):
self.widget.destroy()
self.gui.process_events()
self.widget = None
# Tests ------------------------------------------------------------------
def test_field_tooltip(self):
self._create_widget_control()
self.widget.tooltip = "New tooltip."
self.gui.process_events()
self.assertEqual(self.widget._get_control_tooltip(), "New tooltip.")
def test_field_menu(self):
self._create_widget_control()
self.widget.menu = MenuManager(Action(name='Test'), name='Test')
self.gui.process_events()
class FieldMixin(UnittestTools):
""" Mixin which provides standard methods for all fields. """
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
self.widget = self._create_widget()
self.parent.open()
self.gui.process_events()
def _create_widget(self):
raise NotImplementedError()
def _create_widget_control(self):
self.widget._create()
self.addCleanup(self._destroy_widget)
self.widget.show(True)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def _destroy_widget(self):
self.widget.destroy()
self.gui.process_events()
self.widget = None
# Tests ------------------------------------------------------------------
def test_field_tooltip(self):
self._create_widget_control()
self.widget.tooltip = "New tooltip."
self.gui.process_events()
self.assertEqual(self.widget._get_control_tooltip(), "New tooltip.")
def test_field_menu(self):
self._create_widget_control()
self.widget.menu = MenuManager(Action(name="Test"), name="Test")
self.gui.process_events()
class TestTraitsUIWidgetAction(unittest.TestCase, UnittestTools):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.parent.open()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def create_model(self):
from traitsui.api import View, Item
class SimpleEnum(HasTraits):
value = Enum('a', 'b', 'c')
view = View(Item('value'))
return SimpleEnum()
def test_traitsui_widget_action(self):
from traitsui.api import View, Item
class SimpleEnumAction(TraitsUIWidgetAction):
value = Enum('a', 'b', 'c')
view = View(Item('value'))
action = SimpleEnumAction(name="Simple")
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors('value')[0]
with self.assertTraitChanges(action, 'value', count=1):
if toolkit.toolkit in {'qt', 'qt4'}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == 'wx':
import wx
event = wx.CommandEvent(wx.EVT_CHOICE.typeId,
editor.control.GetId())
event.SetString('b')
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(action.value, 'b')
def test_traitsui_widget_action_model(self):
from traitsui.api import View, Item
class SimpleEnumAction(TraitsUIWidgetAction):
view = View(Item('value'))
model = self.create_model()
action = SimpleEnumAction(name="Simple", model=model)
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors('value')[0]
with self.assertTraitChanges(model, 'value', count=1):
if toolkit.toolkit in {'qt', 'qt4'}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == 'wx':
import wx
event = wx.CommandEvent(wx.EVT_CHOICE.typeId,
editor.control.GetId())
event.SetString('b')
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(model.value, 'b')
def test_traitsui_widget_action_model_view(self):
from traitsui.api import HGroup, View, Item
class ComplexEnumAction(TraitsUIWidgetAction):
value = Enum('a', 'b', 'c')
view = View(
HGroup(
Item('value'),
Item('action.value'),
)
)
model = self.create_model()
action = ComplexEnumAction(name="Simple", model=model)
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors('value')[0]
with self.assertTraitChanges(model, 'value', count=1):
if toolkit.toolkit in {'qt', 'qt4'}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == 'wx':
import wx
event = wx.CommandEvent(wx.EVT_CHOICE.typeId,
editor.control.GetId())
event.SetString('b')
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(model.value, 'b')
editor = control._ui.get_editors('value')[1]
with self.assertTraitChanges(action, 'value', count=1):
if toolkit.toolkit in {'qt', 'qt4'}:
editor.control.setCurrentIndex(2)
editor.control.activated.emit(2)
elif toolkit.toolkit == 'wx':
event = wx.CommandEvent(wx.EVT_CHOICE.typeId,
editor.control.GetId())
event.SetString('c')
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(action.value, 'c')
class TestTraitsUIWidgetAction(unittest.TestCase, UnittestTools):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.parent.open()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def create_model(self):
from traitsui.api import View, Item
class SimpleEnum(HasTraits):
value = Enum("a", "b", "c")
view = View(Item("value"))
return SimpleEnum()
def test_traitsui_widget_action(self):
from traitsui.api import View, Item
class SimpleEnumAction(TraitsUIWidgetAction):
value = Enum("a", "b", "c")
view = View(Item("value"))
action = SimpleEnumAction(name="Simple")
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors("value")[0]
with self.assertTraitChanges(action, "value", count=1):
if toolkit.toolkit in {"qt", "qt4"}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == "wx":
import wx
event = wx.CommandEvent(
wx.EVT_CHOICE.typeId, editor.control.GetId()
)
event.SetString("b")
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(action.value, "b")
def test_traitsui_widget_action_model(self):
from traitsui.api import View, Item
class SimpleEnumAction(TraitsUIWidgetAction):
view = View(Item("value"))
model = self.create_model()
action = SimpleEnumAction(name="Simple", model=model)
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors("value")[0]
with self.assertTraitChanges(model, "value", count=1):
if toolkit.toolkit in {"qt", "qt4"}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == "wx":
import wx
event = wx.CommandEvent(
wx.EVT_CHOICE.typeId, editor.control.GetId()
)
event.SetString("b")
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(model.value, "b")
def test_traitsui_widget_action_model_view(self):
from traitsui.api import HGroup, View, Item
class ComplexEnumAction(TraitsUIWidgetAction):
value = Enum("a", "b", "c")
view = View(HGroup(Item("value"), Item("action.value")))
model = self.create_model()
action = ComplexEnumAction(name="Simple", model=model)
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors("value")[0]
with self.assertTraitChanges(model, "value", count=1):
if toolkit.toolkit in {"qt", "qt4"}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == "wx":
import wx
event = wx.CommandEvent(
wx.EVT_CHOICE.typeId, editor.control.GetId()
)
event.SetString("b")
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(model.value, "b")
editor = control._ui.get_editors("value")[1]
with self.assertTraitChanges(action, "value", count=1):
if toolkit.toolkit in {"qt", "qt4"}:
editor.control.setCurrentIndex(2)
editor.control.activated.emit(2)
elif toolkit.toolkit == "wx":
event = wx.CommandEvent(
wx.EVT_CHOICE.typeId, editor.control.GetId()
)
event.SetString("c")
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(action.value, "c")
class TestWindow(unittest.TestCase, GuiTestAssistant):
def setUp(self):
GuiTestAssistant.setUp(self)
self.window = Window()
def tearDown(self):
if self.window.control is not None:
with self.delete_widget(self.window.control):
self.window.destroy()
self.window = None
GuiTestAssistant.tearDown(self)
def test_destroy(self):
# test that destroy works even when no control
with self.event_loop():
self.window.destroy()
def test_open_close(self):
# test that opening and closing works as expected
with self.assertTraitChanges(self.window, "opening", count=1):
with self.assertTraitChanges(self.window, "opened", count=1):
with self.event_loop():
self.window.open()
with self.assertTraitChanges(self.window, "closing", count=1):
with self.assertTraitChanges(self.window, "closed", count=1):
with self.event_loop():
self.window.close()
def test_show(self):
# test that showing works as expected
with self.event_loop():
self.window._create()
with self.event_loop():
self.window.show(True)
with self.event_loop():
self.window.show(False)
with self.event_loop():
self.window.destroy()
def test_activate(self):
# test that activation works as expected
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.activate()
with self.event_loop():
self.window.close()
def test_position(self):
# test that default position works as expected
self.window.position = (100, 100)
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.close()
def test_reposition(self):
# test that changing position works as expected
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.position = (100, 100)
with self.event_loop():
self.window.close()
def test_size(self):
# test that default size works as expected
self.window.size = (100, 100)
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.close()
def test_resize(self):
# test that changing size works as expected
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.size = (100, 100)
with self.event_loop():
self.window.close()
def test_title(self):
# test that default title works as expected
self.window.title = "Test Title"
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.close()
def test_retitle(self):
# test that changing title works as expected
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.title = "Test Title"
with self.event_loop():
self.window.close()
def test_show_event(self):
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.visible = False
with self.assertTraitChanges(self.window, "visible", count=1):
with self.event_loop():
self.window.control.show()
self.assertTrue(self.window.visible)
def test_hide_event(self):
with self.event_loop():
self.window.open()
with self.assertTraitChanges(self.window, "visible", count=1):
with self.event_loop():
self.window.control.hide()
self.assertFalse(self.window.visible)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Confirmation dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Confirmation dialog click tests don't work reliably on linux. Issue #282.",
)
def test_confirm_reject(self):
# test that cancel works as expected
tester = ModalDialogTester(
lambda: self.window.confirm("message", cancel=True))
tester.open_and_run(when_opened=lambda x: x.close(accept=False))
self.assertEqual(tester.result, CANCEL)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Confirmation dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Confirmation dialog click tests don't work reliably on linux. Issue #282.",
)
def test_confirm_yes(self):
# test that yes works as expected
tester = ModalDialogTester(lambda: self.window.confirm("message"))
tester.open_and_wait(when_opened=lambda x: x.click_button(YES))
self.assertEqual(tester.result, YES)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Confirmation dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Confirmation dialog click tests don't work reliably on linux. Issue #282.",
)
def test_confirm_no(self):
# test that no works as expected
tester = ModalDialogTester(lambda: self.window.confirm("message"))
tester.open_and_wait(when_opened=lambda x: x.click_button(NO))
self.assertEqual(tester.result, NO)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Confirmation dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Confirmation dialog click tests don't work reliably on linux. Issue #282.",
)
def test_confirm_cancel(self):
# test that cncel works as expected
tester = ModalDialogTester(
lambda: self.window.confirm("message", cancel=True))
tester.open_and_wait(when_opened=lambda x: x.click_button(CANCEL))
self.assertEqual(tester.result, CANCEL)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
def test_information_accept(self):
self._check_message_dialog_accept(self.window.information)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Message dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Message dialog click tests don't work reliably on linux. Issue #282.",
)
def test_information_ok(self):
self._check_message_dialog_ok(self.window.information)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
def test_warning_accept(self):
self._check_message_dialog_accept(self.window.warning)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Message dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Message dialog click tests don't work reliably on linux. Issue #282.",
)
def test_warning_ok(self):
self._check_message_dialog_ok(self.window.warning)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
def test_error_accept(self):
self._check_message_dialog_accept(self.window.error)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Message dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Message dialog click tests don't work reliably on linux. Issue #282.",
)
def test_error_ok(self):
self._check_message_dialog_ok(self.window.error)
def _check_message_dialog_ok(self, method):
tester = self._setup_tester(method)
tester.open_and_wait(when_opened=lambda x: x.click_button(OK))
self.assertIsNone(tester.result)
def _check_message_dialog_accept(self, method):
tester = self._setup_tester(method)
tester.open_and_run(when_opened=lambda x: x.close(accept=True))
self.assertIsNone(tester.result)
def _setup_tester(self, method):
kwargs = {
"title": "Title",
"detail": "Detail",
"informative": "Informative",
}
tester = ModalDialogTester(lambda: method("message", **kwargs))
return tester
class TestWidget(unittest.TestCase, UnittestTools):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
self.widget = self._create_widget()
self.parent.open()
self.gui.process_events()
def _create_widget(self):
self.data = np.arange(120.0).reshape(4, 5, 6)
self.model = ArrayDataModel(data=self.data, value_type=FloatValue())
return DataViewWidget(parent=self.parent.control,
data_model=self.model)
def _create_widget_control(self):
self.widget._create()
self.addCleanup(self._destroy_widget)
self.parent.show(True)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def _destroy_widget(self):
self.widget.destroy()
self.gui.process_events()
self.widget = None
def test_defaults(self):
self.assertTrue(self.widget.header_visible)
def test_lifecycle(self):
self._create_widget_control()
def test_header_visible(self):
self._create_widget_control()
self.assertTrue(self.widget._get_control_header_visible())
self.widget.header_visible = False
self.gui.process_events()
self.assertFalse(self.widget._get_control_header_visible())
def test_header_visible_before_control(self):
self.widget.header_visible = False
self._create_widget_control()
self.assertFalse(self.widget._get_control_header_visible())
def test_init_selection(self):
self.widget.selection = [((1, ), ())]
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection(), [((1, ), ())])
def test_selection_mode_change(self):
self._create_widget_control()
self.widget.selection = [((1, 4), ()), ((2, 0), ())]
self.widget.selection_mode = "single"
self.assertEqual(self.widget._get_control_selection_mode(), "single")
self.assertEqual(self.widget.selection, [])
self.widget.selection = [((1, 4), ())]
if "none" in selection_modes:
self.widget.selection_mode = "none"
self.assertEqual(self.widget._get_control_selection_mode(), "none")
self.assertEqual(self.widget.selection, [])
self.widget.selection_mode = "extended"
self.assertEqual(self.widget._get_control_selection_mode(), "extended")
self.assertEqual(self.widget.selection, [])
@unittest.skipIf(
len(selection_types) <= 1,
"Changing selection types not supported",
)
def test_selection_type_change(self):
self._create_widget_control()
if "column" in selection_types:
self.widget.selection_type = "column"
self.assertEqual(
self.widget._get_control_selection_type(),
"column",
)
self.assertEqual(self.widget.selection, [])
if "item" in selection_types:
self.widget.selection_type = "item"
self.assertEqual(self.widget._get_control_selection_type(), "item")
self.assertEqual(self.widget.selection, [])
if "row" in selection_types:
self.widget.selection_type = "row"
self.assertEqual(self.widget._get_control_selection_type(), "row")
self.assertEqual(self.widget.selection, [])
@unittest.skipIf(
"none" not in selection_modes,
"Selection mode 'none' not supported",
)
def test_selection_mode_none(self):
self.widget.selection_mode = "none"
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_mode(), "none")
self.widget.selection = []
self.gui.process_events()
self.assertEqual(self.widget.selection, [])
self.assertEqual(self.widget._get_control_selection(), [])
@unittest.skipIf(
"none" not in selection_modes,
"Selection mode 'none' not supported",
)
def test_selection_mode_none_invalid(self):
self.widget.selection_mode = "none"
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 4), ()), (2, 1), ()]
def test_selection_mode_single(self):
self.widget.selection_mode = "single"
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_mode(), "single")
self.widget.selection = [((1, 4), ())]
self.gui.process_events()
self.assertEqual(self.widget.selection, [((1, 4), ())])
self.assertEqual(self.widget._get_control_selection(), [((1, 4), ())])
def test_selection_mode_single_invalid(self):
self.widget.selection_mode = "single"
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 4), ()), (2, 1), ()]
@unittest.skipIf(
is_wx and is_linux,
"Selection mode 'extended' not working on Linux",
)
def test_selection_mode_extended(self):
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_mode(), "extended")
self.widget.selection = [((1, 4), ()), ((2, 0), ())]
self.gui.process_events()
self.assertEqual(self.widget.selection, [((1, 4), ()), ((2, 0), ())])
self.assertEqual(
self.widget._get_control_selection(),
[((1, 4), ()), ((2, 0), ())],
)
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column(self):
self.widget.selection_type = "column"
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_type(), "column")
self.widget.selection = [((0, ), (2, )), ((1, ), (4, ))]
self.gui.process_events()
self.assertEqual(self.widget.selection, [((0, ), (2, )),
((1, ), (4, ))])
self.assertEqual(self.widget._get_control_selection(),
[((0, ), (2, )), ((1, ), (4, ))])
@unittest.skipIf(
'item' not in selection_types,
"Selection type 'item' not supported",
)
def test_selection_type_item(self):
self.widget.selection_type = "item"
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_type(), "item")
self.widget.selection = [((1, 4), (2, )), ((2, 0), (4, ))]
self.gui.process_events()
self.assertEqual(self.widget.selection, [((1, 4), (2, )),
((2, 0), (4, ))])
self.assertEqual(
self.widget._get_control_selection(),
[((1, 4), (2, )), ((2, 0), (4, ))],
)
def test_selection_type_row_invalid_row_big(self):
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((10, ), ())]
def test_selection_type_row_invalid_row_long(self):
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 1, 1), ())]
def test_selection_type_row_invalid_column(self):
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 2), (2, ))]
@unittest.skipIf(
'item' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_item_invalid_row_too_big(self):
self.widget.selection_type = 'item'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 10), (2, ))]
@unittest.skipIf(
'item' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_item_invalid_row_too_long(self):
self.widget.selection_type = 'item'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 4, 5, 6), (2, ))]
@unittest.skipIf(
'item' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_item_invalid_column(self):
self.widget.selection_type = 'item'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 2), (10, ))]
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column_invalid_row_too_long(self):
self.widget.selection_type = 'column'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 4, 5, 6), (2, ))]
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column_invalid_row_too_big(self):
self.widget.selection_type = 'column'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((10, ), (2, ))]
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column_invalid_row_not_parent(self):
self.widget.selection_type = 'column'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 2), (2, ))]
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column_invalid_column(self):
self.widget.selection_type = 'column'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((), (10, ))]
def test_selection_updated(self):
self._create_widget_control()
with self.assertTraitChanges(self.widget, 'selection'):
self.widget._set_control_selection([((1, 4), ())])
self.gui.process_events()
self.assertEqual(self.widget.selection, [((1, 4), ())])
self.assertEqual(
self.widget._get_control_selection(),
[((1, 4), ())],
)
def test_selection_updating_context_manager(self):
self.assertFalse(self.widget._selection_updating_flag)
with self.widget._selection_updating():
self.assertTrue(self.widget._selection_updating_flag)
with self.widget._selection_updating():
self.assertTrue(self.widget._selection_updating_flag)
self.assertTrue(self.widget._selection_updating_flag)
self.assertFalse(self.widget._selection_updating_flag)
def test_selection_updating_context_manager_exception(self):
with self.assertRaises(ZeroDivisionError):
with self.widget._selection_updating():
with self.widget._selection_updating():
1 / 0
self.assertFalse(self.widget._selection_updating_flag)