diff options
| author | SVN-Git Migration <python-modules-team@lists.alioth.debian.org> | 2015-10-08 09:27:57 -0700 |
|---|---|---|
| committer | SVN-Git Migration <python-modules-team@lists.alioth.debian.org> | 2015-10-08 09:27:57 -0700 |
| commit | 928ccf929c26a5344c224303b5108e99c2eb597a (patch) | |
| tree | 6d371148311fe4467b0c9a208e9c36d24380c75e /tests | |
Imported Upstream version 1.9.8
Diffstat (limited to 'tests')
33 files changed, 2889 insertions, 0 deletions
diff --git a/tests/Proxies/CheckButton.py b/tests/Proxies/CheckButton.py new file mode 100644 index 0000000..1907aa0 --- /dev/null +++ b/tests/Proxies/CheckButton.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python +import sys +sys.path.insert(0, "../..") + +DEBUG = 0 +if len(sys.argv) > 1: + DEBUG = 1 + +from Kiwi.initgtk import gtk +from Kiwi.Proxies import Proxy +from Kiwi.Models import Model + +class Foo(Model): + A = 1 + B = 0 + +class CheckProxy(Proxy): + widgets = [":B", ":A"] + def __init__(self, model): + self._build() + Proxy.__init__(self, model, delete_handler=gtk.mainquit) + gtk.idle_add(self.focus_topmost) + + def _build(self): + self.win = gtk.Window() + self.A = gtk.CheckButton("This is A") + self.B = gtk.CheckButton("This is B") + vbox = gtk.VBox() + vbox.add(self.A) + vbox.add(self.B) + self.win.add(vbox) + +class ToggleProxy(CheckProxy): + def _build(self): + self.win = gtk.Window() + self.A = gtk.ToggleButton("This is A") + self.B = gtk.ToggleButton("This is B") + vbox = gtk.VBox() + vbox.add(self.A) + vbox.add(self.B) + self.win.add(vbox) + +f = Foo() +c = CheckProxy(f) +assert f.A == 1 +assert f.B == 0 +c.A.clicked() +c.B.clicked() +assert f.A == 0, f.A +assert f.B == 1, f.B +if DEBUG: c.show_all_and_loop() ; print f.__dict__ +print "CheckButton OK" + +f = Foo() +c = ToggleProxy(f) +assert f.A == 1, f.A +assert f.B == 0, f.B +c.A.clicked() +c.B.clicked() +assert f.A == 0, f.A +assert f.B == 1, f.B +if DEBUG: c.show_all_and_loop(); print f.__dict__ +print "ToggleButton OK" diff --git a/tests/Proxies/Entry.py b/tests/Proxies/Entry.py new file mode 100644 index 0000000..05b7304 --- /dev/null +++ b/tests/Proxies/Entry.py @@ -0,0 +1,274 @@ +#!/usr/bin/env python +import sys, pprint +sys.path.insert(0, "../..") + +DEBUG = 0 +if len(sys.argv) > 1: + DEBUG = 1 + +from mx import DateTime + +from Kiwi.initgtk import gtk +from Kiwi.Proxies import Proxy +from Kiwi.Models import Model + +class Foo(Model): + A = "Alphabet" + B = "Beetroot" + C = 10 + D = 20 + E = DateTime.now() + # F unset + G = 30 + # H unset + +class NumberFoo(Model): + A = 1 + B = 2 + C = 3 + D = 4 + E = DateTime.now() + # F unset + G = 6 + # H unset + +class EntryProxy(Proxy): + widgets = [":B", ":A", ":C", ":D", ":E", ":F", ":G", ":H"] + def __init__(self, model, flag=0): + self._build() + self.set_numeric("C") + if flag: + self.set_datetime("E") + self.set_numeric("G") + self.set_numeric("H") + self.set_format("H", "%.3f") + self.set_format("G", "%.3f") + self.set_decimal_separator(",") + Proxy.__init__(self, model, delete_handler=gtk.mainquit) + gtk.idle_add(self.focus_topmost) + + def _build(self): + self.win = gtk.Window() + self.A = gtk.Entry() + self.B = gtk.Entry() + self.C = gtk.Entry() + self.D = gtk.Entry() + self.E = gtk.Entry() + self.F = gtk.Entry() + self.F.set_text("NOOGIE") + self.G = gtk.Entry() + self.H = gtk.Entry() + self.H.set_text("30.41") + vbox = gtk.VBox() + vbox.add(self.A) + vbox.add(self.B) + vbox.add(self.C) + vbox.add(self.D) + vbox.add(self.E) + vbox.add(self.F) + vbox.add(self.G) + vbox.add(self.H) + self.vbox = vbox + self.win.add(vbox) + +class ComboProxy(EntryProxy): + def _build(self): + self.win = gtk.Window() + self.A = gtk.Combo() + self.A.set_popdown_strings(["foo"]) + self.B = gtk.Combo() + self.B.set_popdown_strings(["bar"]) + self.C = gtk.Combo() + self.C.set_popdown_strings(["99"]) + self.D = gtk.Combo() + self.D.set_popdown_strings(["100"]) + self.E = gtk.Combo() + self.F = gtk.Combo() + self.F.entry.set_text("NOOGIE") + self.G = gtk.Combo() + self.H = gtk.Combo() + self.H.entry.set_text("30.41") + vbox = gtk.VBox() + vbox.add(self.A) + vbox.add(self.B) + vbox.add(self.C) + vbox.add(self.D) + vbox.add(self.E) + vbox.add(self.F) + vbox.add(self.G) + vbox.add(self.H) + self.win.add(vbox) + +class LabelProxy(EntryProxy): + def _build(self): + self.win = gtk.Window() + self.A = gtk.Label() + self.B = gtk.Label() + self.C = gtk.Label() + self.D = gtk.Label() + self.E = gtk.Label() + self.F = gtk.Label("NOOGIE") + self.G = gtk.Label() + self.H = gtk.Label() + self.H.set_text("30.41") + vbox = gtk.VBox() + vbox.add(self.A) + vbox.add(self.B) + vbox.add(self.C) + vbox.add(self.D) + vbox.add(self.E) + vbox.add(self.F) + vbox.add(self.G) + vbox.add(self.H) + self.win.add(vbox) + +class SpinProxy(EntryProxy): + def _build(self): + self.win = gtk.Window() + self.A = gtk.SpinButton(None, 1, 2) + adj = self.A.get_adjustment() + adj.step_increment = 1.0 + adj.changed() + self.A.set_adjustment(adj) + self.A.set_range(-100, 100) + self.B = gtk.SpinButton(None, 1, 2) + self.B.set_range(-100, 100) + self.C = gtk.SpinButton(None, 1, 2) + self.C.set_range(-100, 100) + self.D = gtk.SpinButton(None, 1, 2) + self.D.set_range(-100, 100) + self.E = gtk.SpinButton(None, 1, 2) + self.E.set_range(-100, 100) + self.F = gtk.SpinButton(None, 1, 2) + self.F.set_range(-100, 100) + self.F.set_text("NOOGIE") + self.G = gtk.SpinButton(None, 1, 2) + self.G.set_range(-100, 100) + self.H = gtk.SpinButton(None, 1, 2) + self.H.set_range(-100, 100) + vbox = gtk.VBox() + vbox.add(self.A) + vbox.add(self.B) + vbox.add(self.C) + vbox.add(self.D) + vbox.add(self.E) + vbox.add(self.F) + vbox.add(self.G) + vbox.add(self.H) + self.win.add(vbox) + self.set_numeric(["A", "B", "C", "D", "E", "F"]) + +f = Foo() +try: + c = EntryProxy(f) +except TypeError: + pass +f.flush_proxies() +c = EntryProxy(f, 1) +assert f.A == "Alphabet", f.A +assert f.B == "Beetroot", f.B +assert f.C == 10, f.C +assert f.D == "20", f.D +assert f.F == "NOOGIE", f.F +assert f.H == 30.41, f.H +f.G = 30.42 +c.A.set_text("Aspargus") +c.B.set_text("Barney") +c.C.set_text("200") +c.D.set_text("barney") +assert f.A == "Aspargus", f.A +assert f.B == "Barney", f.B +assert f.C == 200, f.D +assert f.D == "barney", f.D +t = c.G.get_text() +assert t == "30,420", t +assert f.G == 30.42 +if DEBUG: c.show_all_and_loop() ; pprint.pprint(f.__dict__) +print "Entry OK" + +f = Foo() +try: + c = ComboProxy(f) +except TypeError: + pass +f.flush_proxies() +c = ComboProxy(f, 1) +assert f.A == "Alphabet", f.A +assert f.B == "Beetroot", f.B +assert f.C == 10, f.C +assert f.D == "20", f.D +assert f.F == "NOOGIE", f.F +c.A.entry.set_text("Aspargus") +c.B.entry.set_text("Barney") +c.C.entry.set_text("200") +c.D.entry.set_text("barney") +f.G = 30.42 +assert f.A == "Aspargus", f.A +assert f.B == "Barney", f.B +assert f.C == 200, f.D +assert f.D == "barney", f.D +t = c.G.entry.get_text() +assert t == "30,420", t +if DEBUG: c.show_all_and_loop() ; pprint.pprint(f.__dict__) +print "Combo OK" + +f = Foo() +try: + c = LabelProxy(f) +except TypeError: + pass +f.flush_proxies() +c = LabelProxy(f, 1) +assert f.A == "Alphabet", f.A +assert f.B == "Beetroot", f.B +assert f.C == 10, f.C +# XXX: Label does *NOT* convert to text on startup because it never +# triggers signals - is this correct, and is Entry correct? +assert f.D == 20 +# XXX: label doesn't generate signals, so we can't pick up the +# set_text() changes done to it. This is why +# assert f.F == "NOOGIE" +# fails here. See WidgetProxies.Entry:Labelproxy.update for details. +f.A = "Aspargus" +f.B = "Barney" +try: + f.C = "200" +except TypeError: + f.C = 200 +f.D = "barney" +f.G = 30.42 +assert c.A.get() == "Aspargus", f.A +assert c.B.get() == "Barney", f.B +assert c.C.get() == "200", f.C +assert c.D.get() == "barney", f.D +t = c.G.get_text() +assert t == "30,420", t +if DEBUG: c.show_all_and_loop() ; pprint.pprint(f.__dict__) +print "Label OK" + +f = NumberFoo() +assert f.D == 4, f.D +try: + c = SpinProxy(f) +except TypeError: + pass +f.flush_proxies() +c = SpinProxy(f, 1) +if DEBUG: c.show_all_and_loop() ; pprint.pprint(f.__dict__) +assert f.A == 0, f.A +assert f.B == 0, f.B +assert f.C == 0 +assert f.D == 0, f.D +assert f.F == 0, f.F +c.A.set_text("4") +c.B.set_text("3") +c.C.set_text("2") +c.D.set_text("1") +f.G = 30.42 +assert f.A == 4, f.A +assert f.B == 3, f.B +assert f.C == 2, f.D +assert f.D == 1, f.D +t = c.G.get_text() +assert t == "30,420", t +print "SpinButton OK" diff --git a/tests/Proxies/NoModel.py b/tests/Proxies/NoModel.py new file mode 100644 index 0000000..aae6802 --- /dev/null +++ b/tests/Proxies/NoModel.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python + +# +# Tests creating a Proxy with no initial model, and then adding one later +# + +import sys, pprint +sys.path.insert(0, "../..") + +DEBUG = 0 +if len(sys.argv) > 1: + DEBUG = 1 + +from Kiwi.initgtk import gtk +from Kiwi.Proxies import Proxy +from Kiwi.Models import Model + +class Foo(Model): + pass + +class XProxy(Proxy): + widgets = [":A"] + def __init__(self, model=None, flag=0): + self._build() + self.set_numeric("A") + Proxy.__init__(self, model, delete_handler=gtk.mainquit) + self.A.grab_focus() + + def _build(self): + self.win = gtk.Window() + self.A = gtk.Entry() + self.win.add(self.A) + +f = Foo() +c = XProxy() +c.new_model(f) +if DEBUG: + c.show_all() + gtk.mainloop() + pprint.pprint(f.__dict__) +assert f.A == 0, f.A # XXX: Is this really expected? + +f = Foo() +f.A = 10 +c.new_model(f) +assert f.A == 10, f.A +t = c.A.get_text() +assert t == "10", t +print "NoModel ok" diff --git a/tests/Proxies/None.py b/tests/Proxies/None.py new file mode 100644 index 0000000..0cdcd15 --- /dev/null +++ b/tests/Proxies/None.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python + +# +# Tests creating a Proxy against a widget that is not supported by +# Proxies (a Frame). +# + +import sys +sys.path.insert(0, "../..") + +DEBUG = 0 +if len(sys.argv) > 1: + DEBUG = 1 + +from Kiwi.initgtk import gtk +from Kiwi.Proxies import Proxy +from Kiwi.Models import Model + +class Foo(Model): + pass + +class NoProxy(Proxy): + widgets = [":A"] + def __init__(self, model, flag=0): + self._build() + Proxy.__init__(self, model, delete_handler=gtk.mainquit) + + def _build(self): + self.win = gtk.Window() + self.A = gtk.Frame() + self.win.add(self.A) + +f = Foo() +try: + c = NoProxy(f) + raise AssertionError +except TypeError: + print "None ok" diff --git a/tests/Proxies/OptionMenu.py b/tests/Proxies/OptionMenu.py new file mode 100644 index 0000000..962275a --- /dev/null +++ b/tests/Proxies/OptionMenu.py @@ -0,0 +1,77 @@ +#!/usr/bin/env python +import sys, pprint +sys.path.insert(0, "../..") + +DEBUG = 0 +if len(sys.argv) > 1: + DEBUG = 1 + +from Kiwi.initgtk import gtk +from Kiwi.Proxies import Proxy +from Kiwi.Models import Model +#from Kiwi.Menu import OptionMenu +from gtk import OptionMenu + +def prefill(args): + print "ARGS", args + +class Foo(Model): + A = "Run" + B = "Hide" + C = None # Play + # No D - Play + E = 666 # Run + # No F - Play + +class CheckProxy(Proxy): + widgets = [":A", ":B", ":C", ":D", ":E", ":F"] + def __init__(self, model): + self._build() + Proxy.__init__(self, model, delete_handler=gtk.mainquit) + gtk.idle_add(self.focus_topmost) + + def _build(self): + self.win = gtk.Window() + self.A = OptionMenu() + self.A.prefill(["Play", "Hide", "Run"]) + self.B = OptionMenu() + self.B.prefill(["Play", "Hide", "Run"]) + self.C = OptionMenu() + self.C.prefill(["Play", "Hide", "Run"]) + self.D = OptionMenu() + self.D.prefill(["Play", "Hide", "Run"]) + self.E = OptionMenu() + self.E.prefill([("Play", 111), ("Hide", 222) , ("Run", 666)]) + self.F = OptionMenu() + self.F.prefill([("Play", 111), ("Hide", 222) , ("Run", 666)]) + vbox = gtk.VBox() + vbox.add(self.A) + vbox.add(self.B) + vbox.add(self.C) + vbox.add(self.D) + vbox.add(self.E) + vbox.add(self.F) + self.win.add(vbox) + +f = Foo() +c = CheckProxy(f) +assert f.A == "Run", f.A +assert f.B == "Hide", f.B +assert f.C == "Play", f.C +assert f.D == "Play", f.D +assert f.E == 666, f.E +assert f.F == 111, f.E +c.A.get_menu().children()[0].activate() +c.B.get_menu().children()[2].activate() +c.E.get_menu().children()[1].activate() +assert f.A == "Play", f.A +assert f.B == "Run", f.B +assert f.E == 222, f.B +try: + f.E = 231 + raise AssertionError +except ValueError: + # XXX: set value back to normal. See Model.__setattr__ + f.E = 222 +if DEBUG: c.show_all_and_loop() ; pprint.pprint(f.__dict__) +print "OptionMenu OK" diff --git a/tests/Proxies/RadioGroup.py b/tests/Proxies/RadioGroup.py new file mode 100644 index 0000000..8714797 --- /dev/null +++ b/tests/Proxies/RadioGroup.py @@ -0,0 +1,103 @@ +#!/usr/bin/env python +import sys, pprint +sys.path.insert(0, "../..") + +DEBUG = 0 +if len(sys.argv) > 1: + DEBUG = 1 + +from Kiwi.initgtk import gtk +from Kiwi.Proxies import Proxy +from Kiwi.Models import Model + +class Foo(Model): + A = "Play" + B = 222 + C = "OOH" + # No D - Play + E = None # Run + # No F - Play + +class RadioProxy(Proxy): + def __init__(self, model): + self._build() + Proxy.__init__(self, model, delete_handler=gtk.mainquit) + gtk.idle_add(self.focus_topmost) + + def _build(self): + self.win = gtk.Window() + self.A1 = gtk.RadioButton(label="Play") + self.A2 = gtk.RadioButton(self.A1, label="Hide") + self.A3 = gtk.RadioButton(self.A1, label="Run") + self.group_radiobuttons("A", ["A1", "A2", "A3"]) + + self.B1 = gtk.RadioButton(label="B Play") + self.B2 = gtk.RadioButton(self.B1, label="B Hide") + self.B3 = gtk.RadioButton(self.B1, label="B Run") + self.group_radiobuttons("B", {"B1": 111, "B2": 222, "B3": 333}) + + self.C1 = gtk.RadioButton(label="C Play") + self.C2 = gtk.RadioButton(self.C1, label="C Hide") + self.C3 = gtk.RadioButton(self.C1, label="C Run") + self.group_radiobuttons("C", {"C1": 111, "C2": 222, "C3": 333}) + + self.D1 = gtk.RadioButton(label="D Play") + self.D2 = gtk.RadioButton(self.D1, label="D Hide") + self.D3 = gtk.RadioButton(self.D1, label="D Run") + self.group_radiobuttons("D", {"D1": 111, "D2": 222, "D3": 333}) + + self.E1 = gtk.RadioButton(label="E Play") + self.E2 = gtk.RadioButton(self.E1, label="E Hide") + self.E3 = gtk.RadioButton(self.E1, label="E Run") + self.group_radiobuttons("E", {"E1": 111, "E2": 222, "E3": 333}) + + vbox = gtk.VBox() + vbox.add(self.A1) + vbox.add(self.A2) + vbox.add(self.A3) + vbox.add(self.B1) + vbox.add(self.B2) + vbox.add(self.B3) + vbox.add(self.C1) + vbox.add(self.C2) + vbox.add(self.C3) + vbox.add(self.D1) + vbox.add(self.D2) + vbox.add(self.D3) + vbox.add(self.E1) + vbox.add(self.E2) + vbox.add(self.E3) + self.win.add(vbox) + +f = Foo() +try: + f.D + raise AssertionError +except: + pass +assert f.E == None, f.E +try: + c = RadioProxy(f) + raise AssertionError +except ValueError: + pass +f.flush_proxies() +f.C = 333 +c = RadioProxy(f) +assert f.A == "Play", f.A +assert f.B == 222, f.B +assert f.C == 333, f.C +assert f.D == 111, f.D +assert f.E == 111, f.E +c.A2.clicked() +c.B3.clicked() +c.C1.clicked() +assert f.A == "Hide", f.A +assert f.B == 333, f.B +assert f.C == 111, f.B +c.A3.clicked() +assert f.A == "Run", f.A +f.E = None +assert f.E == 111, f.E +if DEBUG: c.show_all_and_loop(); pprint.pprint(f.__dict__) +print 'RadioButton OK' diff --git a/tests/Proxies/Separator.py b/tests/Proxies/Separator.py new file mode 100644 index 0000000..bf77ac4 --- /dev/null +++ b/tests/Proxies/Separator.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python +import sys +sys.path.insert(0, "../..") + +DEBUG = 0 +if len(sys.argv) > 1: + DEBUG = 1 + +from Kiwi import set_decimal_separator +from Kiwi.initgtk import gtk +from Kiwi.Proxies import Proxy +from Kiwi.Models import Model + +class Foo(Model): + A = 10.10 + +class EntryProxy(Proxy): + widgets = [":A"] + def __init__(self, model): + self.set_numeric("A") + self._build() + Proxy.__init__(self, model, delete_handler=gtk.mainquit) + gtk.idle_add(self.focus_topmost) + + def _build(self): + self.win = gtk.Window() + self.A = gtk.Entry() + self.win.add(self.A) + +set_decimal_separator(",") +f = Foo() +c = EntryProxy(f) +assert c.A.get_text() == "10,1", c.A.get_text() +assert f.A == 10.1 + +set_decimal_separator("X") +f = Foo() +c = EntryProxy(f) +assert c.A.get_text() == "10X1", c.A.get_text() +assert f.A == 10.1 + +set_decimal_separator(".") +f = Foo() +c = EntryProxy(f) +assert c.A.get_text() == "10.1", c.A.get_text() +assert f.A == 10.1 + +set_decimal_separator("X") +f = Foo() +c = EntryProxy(f) +c.set_decimal_separator(".") +c.update("A") # Trigger view refresh +assert c.A.get_text() == "10.1", c.A.get_text() +assert f.A == 10.1 + +print "Separator OK" diff --git a/tests/Proxies/Text.py b/tests/Proxies/Text.py new file mode 100644 index 0000000..b99a978 --- /dev/null +++ b/tests/Proxies/Text.py @@ -0,0 +1,92 @@ +#!/usr/bin/env python +import sys, pprint +sys.path.insert(0, "../..") + +DEBUG = 0 +if len(sys.argv) > 1: + DEBUG = 1 + +from mx import DateTime + +from Kiwi.initgtk import gtk +from Kiwi.Proxies import Proxy +from Kiwi.FrameWork import Model + +class Foo(Model): + A = "Alphabet" + B = "Beetroot" + C = 10 + D = 20 + E = DateTime.now() + # F unset + G = 30.42 + +class TextProxy(Proxy): + widgets = [":A", ":B", ":C", ":D", ":E", ":F", ":G"] + def __init__(self, model, flag=0): + self._build() + self.set_numeric("C") + if flag: + self.set_datetime("E") + self.set_numeric("G") + self.set_format("G", "%.3f") + Proxy.__init__(self, model, delete_handler=gtk.mainquit) + gtk.idle_add(self.focus_topmost) + + def _build(self): + self.win = gtk.GtkWindow() + self.A = gtk.GtkText() + self.A.set_editable(1) + self.B = gtk.GtkText() + self.B.set_editable(1) + self.C = gtk.GtkText() + self.C.set_editable(1) + self.D = gtk.GtkText() + self.D.set_editable(1) + self.E = gtk.GtkText() + self.E.set_editable(1) + self.F = gtk.GtkText() + self.F.set_editable(1) + self.F.insert_text("NOOGIE") + self.G = gtk.GtkText() + self.G.set_editable(1) + vbox = gtk.GtkVBox() + vbox.add(self.A) + vbox.add(self.B) + vbox.add(self.C) + vbox.add(self.D) + vbox.add(self.E) + vbox.add(self.F) + vbox.add(self.G) + self.win.add(vbox) + +f = Foo() +try: + c = TextProxy(f) +except TypeError: + pass +f.flush_proxies() +assert f.A == "Alphabet", f.A +c = TextProxy(f, 1) +assert f.A == "Alphabet", f.A +assert f.B == "Beetroot", f.B +assert f.C == 10, f.C +assert f.D == "20", f.D +assert f.F == "NOOGIE", f.F +c.A.delete_text(0, c.A.get_length()) +c.A.insert_text("Aspargus") +c.B.delete_text(0, c.B.get_length()) +c.B.insert_text("Barney") +c.C.delete_text(0, c.C.get_length()) +c.C.insert_text("200") +c.D.delete_text(0, c.D.get_length()) +c.D.insert_text("barney") +f.G = 30.42 +assert f.A == "Aspargus", f.A +assert f.B == "Barney", f.B +assert f.C == 200, f.D +assert f.D == "barney", f.D +t = c.G.get_chars(0, c.G.get_length()) +assert t == "30.420", t +if DEBUG: c.show_all_and_loop() ; pprint.pprint(f.__dict__) +print "Text OK" diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..b861dc2 --- /dev/null +++ b/tests/__init__.py @@ -0,0 +1,5 @@ +try: + import pygtk + pygtk.require('2.0') +except ImportError: + pass diff --git a/tests/actions.glade b/tests/actions.glade new file mode 100644 index 0000000..59c9a2f --- /dev/null +++ b/tests/actions.glade @@ -0,0 +1,150 @@ +<?xml version="1.0" ?> +<glade-interface> + <object class="GtkUIManager" id="uimanager"> + <child> + <object class="GtkActionGroup" id="DefaultActions"> + <child> + <object class="GtkAction" id="FileMenu"> + <property name="label">_File</property> + <property name="tooltip"></property> + <property name="callback"></property> + <property name="accelerator"></property> + </object> + </child> + <child> + <object class="GtkAction" id="New"> + <property name="label">_New</property> + <property name="tooltip">Create a new file</property> + <property name="stock_id">gtk-new</property> + <property name="callback"></property> + <property name="accelerator"><control>N</property> + </object> + </child> + <child> + <object class="GtkAction" id="Open"> + <property name="label">_Open</property> + <property name="tooltip">Open a file</property> + <property name="stock_id">gtk-open</property> + <property name="callback"></property> + <property name="accelerator"><control>O</property> + </object> + </child> + <child> + <object class="GtkAction" id="Save"> + <property name="label">_Save</property> + <property name="tooltip">Save a file</property> + <property name="stock_id">gtk-save</property> + <property name="callback"></property> + <property name="accelerator"><control>S</property> + </object> + </child> + <child> + <object class="GtkAction" id="SaveAs"> + <property name="label">Save _as</property> + <property name="tooltip">Save with a differente name</property> + <property name="stock_id">gtk-save-as</property> + <property name="callback"></property> + <property name="accelerator"></property> + </object> + </child> + <child> + <object class="GtkAction" id="Quit"> + <property name="label">_Quit</property> + <property name="tooltip">Quit the program</property> + <property name="stock_id">gtk-quit</property> + <property name="callback"></property> + <property name="accelerator"><control>Q</property> + </object> + </child> + <child> + <object class="GtkAction" id="EditMenu"> + <property name="label">_Edit</property> + <property name="tooltip"></property> + <property name="callback"></property> + <property name="accelerator"></property> + </object> + </child> + <child> + <object class="GtkAction" id="Copy"> + <property name="label">_Copy</property> + <property name="tooltip">Copy selected object into the clipboard</property> + <property name="stock_id">gtk-copy</property> + <property name="callback"></property> + <property name="accelerator"><control>C</property> + </object> + </child> + <child> + <object class="GtkAction" id="Cut"> + <property name="label">C_ut</property> + <property name="tooltip">Cut selected object into the clipboard</property> + <property name="stock_id">gtk-cut</property> + <property name="callback"></property> + <property name="accelerator"><control>X</property> + </object> + </child> + <child> + <object class="GtkAction" id="Paste"> + <property name="label">_Paste</property> + <property name="tooltip">Paste object from the Clipboard</property> + <property name="stock_id">gtk-paste</property> + <property name="callback"></property> + <property name="accelerator"><control>V</property> + </object> + </child> + </object> + </child> + <ui id="initial-state"><![CDATA[<ui> + <menubar action="menubar1" name="menubar1"> + <menu action="FileMenu" name="FileMenu"> + <menuitem action="New" name="New"/> + <menuitem action="Open" name="Open"/> + <menuitem action="Save" name="Save"/> + <menuitem action="SaveAs" name="SaveAs"/> + <separator name="sep1"/> + <menuitem action="Quit" name="Quit"/> + </menu> + <menu action="EditMenu" name="EditMenu"> + <menuitem action="Copy" name="Copy"/> + <menuitem action="Cut" name="Cut"/> + <menuitem action="Paste" name="Paste"/> + </menu> + </menubar> + <toolbar action="toolbar1" name="toolbar1"> + <toolitem action="New" name="New"/> + <toolitem action="Open" name="Open"/> + <toolitem action="Save" name="Save"/> + <separator name="sep2"/> + <toolitem action="Copy" name="Copy"/> + <toolitem action="Cut" name="Cut"/> + <toolitem action="Paste" name="Paste"/> + </toolbar> + </ui>]]></ui> + </object> + <widget class="GtkWindow" id="window1"> + <property name="title" translatable="True"></property> + <property name="role"></property> + <child> + <widget class="GtkVBox" id="vbox1"> + <property name="visible">True</property> + <child> + <widget class="GtkMenuBar" id="menubar1" constructor="initial-state"> + <property name="visible">True</property> + </widget> + <packing> + <property name="expand">False</property> + </packing> + </child> + <child> + <widget class="GtkToolbar" id="toolbar1" constructor="initial-state"> + <property name="toolbar_style">both</property> + <property name="visible">True</property> + </widget> + <packing> + <property name="position">1</property> + <property name="expand">False</property> + </packing> + </child> + </widget> + </child> + </widget> +</glade-interface> diff --git a/tests/run_all_tests.py b/tests/run_all_tests.py new file mode 100644 index 0000000..66fe3e3 --- /dev/null +++ b/tests/run_all_tests.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python +import os +import glob +import sys +import inspect +import unittest + +myself = os.path.abspath(__file__) +testdir = os.path.dirname(myself) +if testdir not in sys.path: + sys.path.append(testdir) +sys.path.insert(0, os.path.join(testdir, '..')) + +print 'Running tests on', testdir + +from kiwi.environ import require_gazpacho +require_gazpacho() +suite = unittest.TestSuite() + +for file in glob.glob(os.path.join(testdir, 'test_*.py')): + filename = os.path.basename(file) + modulename = os.path.splitext(filename)[0] + mod = __import__(modulename, globals(), locals()) + members = [mem[1] for mem in inspect.getmembers(mod, inspect.isclass) \ + if issubclass(mem[1], unittest.TestCase) \ + and not mem[1] == unittest.TestCase] + for mem in members: + suite.addTest(unittest.makeSuite(mem)) + + +unittest.TextTestRunner(verbosity=2).run(suite) diff --git a/tests/simple_button.glade b/tests/simple_button.glade new file mode 100644 index 0000000..929a950 --- /dev/null +++ b/tests/simple_button.glade @@ -0,0 +1,17 @@ +<?xml version="1.0" ?> +<glade-interface> + <widget class="GtkWindow" id="simple_button"> + <property name="role"></property> + <property name="events">all-events-mask | button-motion-mask | button-press-mask | button-release-mask | button1-motion-mask | button2-motion-mask | button3-motion-mask | enter-notify-mask | exposure-mask | focus-change-mask | key-press-mask | key-release-mask | leave-notify-mask | pointer-motion-hint-mask | pointer-motion-mask | property-change-mask | proximity-in-mask | proximity-out-mask | scroll-mask | structure-mask | substructure-mask | visibility-notify-mask</property> + <property name="title" context="True" translatable="True"></property> + <child> + <widget class="GtkButton" id="button"> + <property name="receives_default">True</property> + <property name="label" context="True" translatable="True">Click me!</property> + <property name="events">all-events-mask | button-motion-mask | button-press-mask | button-release-mask | button1-motion-mask | button2-motion-mask | button3-motion-mask | enter-notify-mask | exposure-mask | focus-change-mask | key-press-mask | key-release-mask | leave-notify-mask | pointer-motion-hint-mask | pointer-motion-mask | property-change-mask | proximity-in-mask | proximity-out-mask | scroll-mask | structure-mask | substructure-mask | visibility-notify-mask</property> + <property name="can_focus">True</property> + <property name="visible">True</property> + </widget> + </child> + </widget> +</glade-interface> diff --git a/tests/test_Action.py b/tests/test_Action.py new file mode 100644 index 0000000..21ec18f --- /dev/null +++ b/tests/test_Action.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python +from utils import refresh_gui +import unittest + +from kiwi.ui.delegates import Delegate + +class ActionDelegate(Delegate): + def __init__(self): + Delegate.__init__(self, gladefile="actions.glade", + toplevel_name='window1', + widgets=['New'], + delete_handler=self.quit_if_last) + self.new_activated = False + + def on_New__activate(self, *args): + self.new_activated = True + +class ActionTest(unittest.TestCase): + def testButtons(self): + action_delegate = ActionDelegate() + refresh_gui() + action_delegate.New.activate() + refresh_gui() + self.assertEqual(action_delegate.new_activated, True) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_BaseView.py b/tests/test_BaseView.py new file mode 100644 index 0000000..f077f55 --- /dev/null +++ b/tests/test_BaseView.py @@ -0,0 +1,129 @@ +#!/usr/bin/env python +import unittest +import gtk +from gtk import keysyms + +from utils import refresh_gui + +from kiwi.controllers import BaseController +from kiwi.ui.gadgets import set_foreground, get_foreground, \ + set_background, get_background +from kiwi.ui.views import BaseView + +class FooView(BaseView): + widgets = [ "vbox", "label" ] + def __init__(self): + self.build_ui() + BaseView.__init__(self, toplevel_name='win') + + def build_ui(self): + self.win = gtk.Window() + vbox = gtk.VBox() + self.label = gtk.Label("Pick one noogie") + vbox.add(self.label) + self.button = gtk.Button(label="Noogie!") + vbox.add(self.button) + self.foo__button = gtk.Button(label="Boogie!") + vbox.add(self.foo__button) + self.win.add(vbox) + self.vbox = vbox + return vbox + +class FooController(BaseController): + def __init__(self, view): + keyactions = { + keysyms.A: self.on_button__clicked, + keysyms.a: self.on_button__clicked, + keysyms.B: self.on_foo__button__clicked, + keysyms.b: self.on_foo__button__clicked + } + BaseController.__init__(self, view, keyactions) + + def on_button__clicked(self, *args): + self.bar = Bar() + + def on_foo__button__clicked(self, *args): + # This is subclassed + self.view.label.set_text("Good click!") + +class Bar(BaseView, BaseController): + def __init__(self): + self.win = gtk.Window() + self.label = gtk.Label("foobar!") + self.win.add(self.label) + BaseView.__init__(self, toplevel=self.win) + BaseController.__init__(self, view=self) + set_foreground(self.label, "#CC99FF") + set_background(self.win, "#001100") + +# these classes are bad and should trigger exceptions + +class NoWinFoo(BaseView, BaseController): + def __init__(self): + self.win = 0 + BaseView.__init__(self) + BaseController.__init__(self, view=self) + + +class NotWidgetFoo(FooView, BaseController): + def __init__(self): + self.vbox = self.build_ui() + # It's dumb, and it breaks + self.noogie = NotWidgetFoo + FooView.__init__(self) + BaseController.__init__(self, view=self) + + def on_noogie__haxored(self, *args): + print "I AM NOT A NUMBER I AM A FREE MAN" + +class BaseViewTest(unittest.TestCase): + + def setUp(self): + self.foo = FooController(FooView()) + refresh_gui() + + def tearDown(self): + for win in gtk.window_list_toplevels(): + win.destroy() + + def testFooButton(self): + self.foo.view.foo__button.clicked() + refresh_gui() + self.assertEqual(self.foo.view.label.get_text(), + "Good click!") + + def testSubView(self): + self.foo.view.button.clicked() + refresh_gui() + self.assertEqual(self.foo.bar, self.foo.bar.view) + self.assertEqual(self.foo.bar.toplevel, self.foo.bar.win) + # setting None as transient window should be an error + self.assertRaises(TypeError, self.foo.bar.set_transient_for, None) + + def testColors(self): + self.foo.view.button.clicked() + refresh_gui() + win = self.foo.bar.win + win.realize() + color = get_background(win) + self.assertEqual(color, "#001100") + label = self.foo.bar.label + label.realize() + color = get_foreground(label) + self.assertEqual(color, "#CC99FF") + + +class BrokenViewsTest(unittest.TestCase): + + def testNoWindow(self): + # A View requires an instance variable called toplevel that + # specifies the toplevel widget in it + self.assertRaises(TypeError, NoWinFoo) + + def testNotAWidget(self): + # noogie (__main__.NotWidgetFoo) is not a widget and + # can't be connected to + self.assertRaises(AttributeError, NotWidgetFoo) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_CheckButton.py b/tests/test_CheckButton.py new file mode 100644 index 0000000..ca18395 --- /dev/null +++ b/tests/test_CheckButton.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python +import utils + +import unittest + +from kiwi.ui.widgets.checkbutton import ProxyCheckButton + +class CheckButtonTest(unittest.TestCase): + def testForBool(self): + myChkBtn = ProxyCheckButton() + self.assertEqual(myChkBtn.get_property("data-type"), bool) + + # this test doens't work... maybe be a pygtk bug + #self.assertRaises(TypeError, myChkBtn.set_property, 'data-type', str) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_ComboBox.py b/tests/test_ComboBox.py new file mode 100644 index 0000000..da7ac5f --- /dev/null +++ b/tests/test_ComboBox.py @@ -0,0 +1,116 @@ +#!/usr/bin/env python +import utils + +import unittest + +from kiwi.python import disabledeprecationcall, Settable +from kiwi.ui.proxy import Proxy +from kiwi.ui.widgets.combobox import ProxyComboBox, ProxyComboBoxEntry + +class TestComboBox(unittest.TestCase): + def setUp(self): + self.combo = ProxyComboBox() + + def _prefill(self): + self.combo.prefill((('Johan', 1981), + ('Lorenzo', 1979), + ('Christian', 1976))) + + def testPrefill(self): + self.combo.prefill(('foo', 'bar')) + model = self.combo.get_model() + self.assertEqual(tuple(model[0]), ('foo', None)) + self.assertEqual(tuple(model[1]), ('bar', None)) + + def testPrefillWithData(self): + self.combo.prefill((('foo', 42), ('bar', 138))) + model = self.combo.get_model() + self.assertEqual(tuple(model[0]), ('foo', 42)) + self.assertEqual(tuple(model[1]), ('bar', 138)) + self.combo.prefill([]) + self.assertEqual(len(self.combo.get_model()), 0) + self.assertEqual(len(model), 0) + self.assertEqual(len(self.combo), 0) + + def testSelectItemByPosition(self): + self._prefill() + self.combo.select_item_by_position(1) + model = self.combo.get_model() + iter = self.combo.get_active_iter() + self.assertEqual(model.get_value(iter, 0), 'Lorenzo') + self.assertEqual(model.get_value(iter, 1), 1979) + self.assertRaises(KeyError, self.combo.select_item_by_label, 4) + + def testSelectItemByLabel(self): + self._prefill() + self.combo.select_item_by_label('Christian') + model = self.combo.get_model() + iter = self.combo.get_active_iter() + rowNo = model.get_path(iter)[0] + self.assertEqual(rowNo, 2) + self.assertRaises(KeyError, self.combo.select_item_by_label, 'Salgado') + + def testSelectByData(self): + self._prefill() + self.combo.select_item_by_data(1976) + model = self.combo.get_model() + iter = self.combo.get_active_iter() + rowNo = model.get_path(iter)[0] + self.assertEqual(rowNo, 2) + self.assertEqual(model.get_value(iter, 0), 'Christian') + self.assertEqual(model.get_value(iter, 1), 1976) + self.assertRaises(KeyError, self.combo.select_item_by_data, 1980) + + def testGetSelectedData(self): + self._prefill() + self.combo.select_item_by_position(0) + self.assertEqual(self.combo.get_selected_data(), 1981) + self.assertRaises(TypeError, + self.combo.select_item_by_position, 'foobar') + + def testGetSelectedLabel(self): + self._prefill() + + def testClear(self): + self._prefill() + self.combo.clear() + self.assertEqual(map(list, self.combo.get_model()), []) + +class FakeView: + def handler_block(self, widget): + pass + + def handler_unblock(self, widget): + pass + +class BaseModelTest: + def setUp(self): + self.model = Settable(attr=0) + proxy = Proxy(FakeView(), self.model) + self.combo = disabledeprecationcall(self.type) + self.combo.data_type = int + self.combo.model_attribute = 'attr' + self.combo.prefill([('foo', 0), + ('bar', 1)]) + proxy.add_widget('attr', self.combo) + + def testSelectItemByData(self): + self.combo.select_item_by_data(1) + self.assertEqual(self.model.attr, 1) + self.combo.select_item_by_data(0) + self.assertEqual(self.model.attr, 0) + + def testSelectItemBylabel(self): + self.combo.select_item_by_label('bar') + self.assertEqual(self.model.attr, 1) + self.combo.select_item_by_label('foo') + self.assertEqual(self.model.attr, 0) + +class ComboModelTest(BaseModelTest, unittest.TestCase): + type = ProxyComboBox + +class ComboEntryModelTest(BaseModelTest, unittest.TestCase): + type = ProxyComboBoxEntry + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_Delegate.py b/tests/test_Delegate.py new file mode 100644 index 0000000..1a37a1d --- /dev/null +++ b/tests/test_Delegate.py @@ -0,0 +1,112 @@ +#!/usr/bin/env python +import unittest +import gtk + +from kiwi.ui.delegates import Delegate +from utils import refresh_gui + +class A: + def on_foo__clicked(self, *args): + self.x = "FOO in A" + +class B: + def on_foo__clicked(self, *args): + self.x = "FOO in B" + + def on_bar__clicked(self, *args): + self.y = "BAR in B" + +class C: + def on_foo__clicked(self, *args): + self.x = "FOO in C" + +class X(A,B,C): + def on_foo__clicked(self, *args): + self.x = "FOO in X" + +class Y: + def on_foo__clicked(self, *args): + self.x = "FOO in Y" + +class Foo(X,Y,Delegate): + widget = ["foo"] + def __init__(self): + self.win = gtk.Window() + self.foo = gtk.Button("CLICK ME AND BE HAPPY") + self.bar = gtk.Button("CLICK ME AND BE HAPPY") + v = gtk.VBox() + v.add(self.foo) + v.add(self.bar) + self.win.add(v) + self.x = self.y = "NOOO" + Delegate.__init__(self, toplevel=self.win, + delete_handler=self.quit_if_last) + + def on_foo__clicked(self, *args): + self.x = "FOO in Foo" + + def on_bar__clicked(self, *args): + self.y = "BAR in B" + +class ClickCounter(Delegate): + """In this delegate we count the number of clicks we do""" + def __init__(self): + self.win = gtk.Window() + self.button = gtk.Button('Click me!') + self.win.add(self.button) + Delegate.__init__(self, toplevel=self.win, + delete_handler=self.quit_if_last) + + self.clicks = 0 + + def on_button__clicked(self, *args): + self.clicks += 1 + +class GladeClickCounter(Delegate): + def __init__(self): + Delegate.__init__(self, gladefile="simple_button", + widgets=['button'], + delete_handler=self.quit_if_last) + + self.clicks = 0 + + def on_button__clicked(self, *args): + self.clicks += 1 + +class DelegateTest(unittest.TestCase): + def testButtons(self): + f = Foo() + refresh_gui() + f.foo.clicked() + refresh_gui() + self.assertEqual(f.x, "FOO in Foo") + f.bar.clicked() + refresh_gui() + self.assertEqual(f.y, "BAR in B") + + def testClickCounter(self): + clickcounter = ClickCounter() + refresh_gui() + + # one for the boys + clickcounter.button.clicked() + self.assertEqual(clickcounter.clicks, 1) + + # one for the girls + clickcounter.button.clicked() + self.assertEqual(clickcounter.clicks, 2) + + def testClickCounterGlade(self): + clickcounter = GladeClickCounter() + refresh_gui() + + # one for the boys + clickcounter.button.clicked() + self.assertEqual(clickcounter.clicks, 1) + + # one for the girls + clickcounter.button.clicked() + self.assertEqual(clickcounter.clicks, 2) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_Entry.py b/tests/test_Entry.py new file mode 100644 index 0000000..cf41c55 --- /dev/null +++ b/tests/test_Entry.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import unittest + +import gobject + +from kiwi import ValueUnset +from kiwi import datatypes +from kiwi.ui.entry import KiwiEntry +from kiwi.ui.widgets.entry import ProxyEntry + +import utils + +class EntryTest(unittest.TestCase): + def testModel(self): + entry = ProxyEntry() + entry.set_text('value') + entry.set_property("data-type", "str") + self.assertEqual(entry.read(), 'value') + + # FIXME + def _testValidDataType(self): + + entry = ProxyEntry() + entry.set_property("data-type", "date") + # let's make the entry complain! + entry.set_text("string") + self.assertEqual(entry.read(), ValueUnset) + self.assertNotEqual(entry._complaint_checker_id, -1) + + # now let's put proper data + entry.set_text(self.date_format) + date = datatypes.date2str(entry.read()) + self.assertEqual(date, self.date_format) + self.assertEqual(entry._background_timeout_id, -1) + + locale_dictionary = datatypes.locale_dictionary + + # now change the data-type and do it again + entry.set_property("data-type", "float") + if locale_dictionary["thousands_sep"] == ',': + # correct value + entry.set_text("23,400,000.2") + self.assertEqual(entry.read(), 23400000.2) + self.assertEqual(entry._background_timeout_id, -1) + + # wrong value + entry.set_text("23.400.000,2") + self.assertEqual(entry.read(), ValueUnset) + + def testDigitMask(self): + e = ProxyEntry() + e.set_mask('000.000') + self.assertEqual(e.get_text(), ' . ') + self.assertEqual(e.get_field_text(), [None, None]) + e.set_text('123.456') + self.assertEqual(e.get_text(), '123.456') + self.assertEqual(e.get_field_text(), [123, 456]) + e.delete_text(0, 2) + self.assertEqual(e.get_text(), ' 3.456') + self.assertEqual(e.get_field_text(), [3, 456]) + + def testAsciiMask(self): + e = ProxyEntry() + e.set_mask('LLLL-L') + self.assertEqual(e.get_text(), ' - ') + self.assertEqual(e.get_field_text(), ['', '']) + e.set_text('abcd-e') + self.assertEqual(e.get_text(), 'abcd-e') + self.assertEqual(e.get_field_text(), ['abcd', 'e']) + + def testAlphaNumericMask(self): + e = ProxyEntry() + e.set_mask('&&&-aaa') + self.assertEqual(e.get_text(), ' - ') + self.assertEqual(e.get_field_text(), ['', '']) + e.set_text('aáé-á1e') + self.assertEqual(e.get_text(), 'aáé-á1e') + self.assertEqual(e.get_field_text(), ['aáé', 'á1e']) + + def testMaskSmallFields(self): + e = ProxyEntry() + e.set_mask('0.0.0') + self.assertEqual(e.get_text(), ' . . ') + self.assertEqual(e.get_field_text(), [None, None, None]) + e.set_text('1.2.3') + self.assertEqual(e.get_text(), '1.2.3') + self.assertEqual(e.get_field_text(), [1, 2, 3]) + + def testGType(self): + entry = KiwiEntry() + self.assertEqual(gobject.type_name(entry), 'KiwiEntry') + + entry = ProxyEntry() + self.assertEqual(gobject.type_name(entry), 'ProxyEntry') + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_Label.py b/tests/test_Label.py new file mode 100644 index 0000000..d97c8f2 --- /dev/null +++ b/tests/test_Label.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python +import unittest + +from kiwi.ui.widgets.label import ProxyLabel + +class LabelTest(unittest.TestCase): + def testAttr(self): + label = ProxyLabel() + label.set_text("test label") + label.set_italic(True) + self.assertEqual(label.get_label(), + '<span style="italic">test label</span>') + + label.set_bold(True) + label.set_size("xx-small") + self.assertEqual(label.get_label(), + '<span size="xx-small" style="italic" weight="bold">' + 'test label</span>') + + label.set_italic(True) + label.set_bold(False) + label.set_size("xx-large") + self.assertEqual(label.get_label(), + '<span size="xx-large" style="italic">' + 'test label</span>') + + label.set_bold(True) + label.set_label("<b>different label</b>") + label.set_text("test one more label") + label.set_size("xx-small") + self.assertEqual(label.get_label(), + '<span size="xx-small" style="italic" weight="bold">' + 'test one more label</span>') + + self.assertRaises(ValueError, label.set_size, "wrong size") + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_ObjectList.py b/tests/test_ObjectList.py new file mode 100644 index 0000000..626155a --- /dev/null +++ b/tests/test_ObjectList.py @@ -0,0 +1,332 @@ +#!/usr/bin/env python +import unittest + +import gtk + +from kiwi.ui.objectlist import ObjectList, Column +from kiwi.python import Settable + +from utils import refresh_gui + +class Person: + def __init__(self, name, age): + self.name, self.age = name, age + +# we will use this tuple in several tests +persons = (Person('Johan', 24), Person('Gustavo', 25), + Person('Kiko', 28), Person('Salgado', 25), + Person('Lorenzo', 26), Person('Henrique', 21)) + +class ColumnTests(unittest.TestCase): + + def setUp(self): + self.win = gtk.Window() + self.win.set_default_size(400, 400) + + def tearDown(self): + self.win.destroy() + del self.win + + def testEmptyObjectList(self): + mylist = ObjectList() + self.win.add(mylist) + refresh_gui() + + def testOneColumn(self): + # column's attribute can not contain spaces + self.assertRaises(AttributeError, Column, 'test column') + + mylist = ObjectList(Column('test_column')) + self.win.add(mylist) + refresh_gui() + + self.assertEqual(1, len(mylist.get_columns())) + +class DataTests(unittest.TestCase): + """In all this tests we use the same configuration for a list""" + def setUp(self): + self.win = gtk.Window() + self.win.set_default_size(400, 400) + self.list = ObjectList([Column('name'), Column('age')]) + self.win.add(self.list) + refresh_gui() + + def tearDown(self): + self.win.destroy() + del self.win + + def testAddingOneInstance(self): + # we should have two columns now + self.assertEqual(2, len(self.list.get_columns())) + + person = Person('henrique', 21) + self.list.append(person) + + refresh_gui() + + # usually you don't use the model directly, but tests are all about + # breaking APIs, right? + self.assertEqual(self.list[0], person) + self.assertEqual(self.list[0].name, 'henrique') + self.assertEqual(self.list[0].age, 21) + + # we still have to columns, right? + self.assertEqual(2, len(self.list.get_columns())) + + def testAddingAObjectList(self): + global persons + + self.list.add_list(persons) + refresh_gui() + + self.assertEqual(len(self.list), len(persons)) + + def testAddingABunchOfInstances(self): + global persons + + for person in persons: + self.list.append(person) + refresh_gui() + + self.assertEqual(len(self.list), len(persons)) + + def testRemovingOneInstance(self): + global persons + + self.list.add_list(persons) + refresh_gui() + + # we are going to remove Kiko + person = persons[2] + + self.list.remove(person) + + self.assertEqual(len(self.list), len(persons) - 1) + + # now let's remove something that is not on the list + #new_person = Person('Evandro', 24) + #self.assertRaises(ValueError, self.list.remove, new_person) + + # note that even a new person with the same values as a person + # in the list is not considered to be in the list + #existing_person = Person('Gustavo', 25) + #self.assertRaises(ValueError, self.list.remove, + # existing_person) + + def testClearObjectList(self): + global persons + + self.list.add_list(persons) + refresh_gui() + + self.list.clear() + + self.assertEqual(len(self.list), 0) + + + def testUpdatingOneInstance(self): + global persons + + self.list.add_list(persons) + refresh_gui() + + persons[0].age = 29 + self.list.update(persons[0]) + + refresh_gui() + + # Do we have the same number of instances that we had before ? + self.assertEqual(len(self.list), len(persons)) + + # Trying to find our updated instance in the list + self.assertEqual(self.list[0].age, 29) + + # let's be evil + new_person = Person('Nando', 32) + self.assertRaises(ValueError, self.list.update, new_person) + + + def testContains(self): + global persons + + self.list.add_list(persons) + self.assertEqual(persons[0] in self.list, True) + + new_person = Person('Nando', 32) + self.assertEqual(new_person in self.list, False) + + def testSelect(self): + first = persons[0] + self.list.add_list(persons) + self.list.select(first) + self.assertEqual(self.list.get_selected(), first) + + self.list.remove(first) + self.assertRaises(ValueError, self.list.select, first) + +class TestSignals(unittest.TestCase): + def setUp(self): + self.klist = ObjectList() + self.klist.connect('has-rows', self._on_klist__has_rows) + self.klist.connect('selection-changed', + self._on_klist__selection_changed) + self.rows = None + self.selected = None + + def _on_klist__has_rows(self, klist, rows): + self.rows = rows + + def _on_klist__selection_changed(self, klist, selected): + self.selected = selected + + def testHasRows(self): + self.assertEqual(self.rows, None) + self.assertEqual(len(self.klist), 0) + + # Add one + self.klist.append(0) + self.assertEqual(len(self.klist), 1) + self.assertEqual(self.rows, True) + self.klist.remove(0) + self.assertEqual(self.rows, False) + self.assertEqual(len(self.klist), 0) + + # Add several + self.klist.extend((1, 2)) + self.assertEqual(len(self.klist), 2) + self.assertEqual(self.rows, True) + self.klist.remove(1) + self.assertEqual(self.rows, True) + self.klist.remove(2) + self.assertEqual(self.rows, False) + self.assertEqual(len(self.klist), 0) + + def testSelectionChanged(self): + self.assertEqual(self.selected, None) + self.assertEqual(len(self.klist), 0) + self.klist.extend((0, 1)) + self.klist.select(0) + self.assertEqual(self.selected, 0) + self.klist.unselect_all() + self.assertEqual(self.selected, None) + self.assertRaises(ValueError, self.klist.select, 2) + +class ConstructorTest(unittest.TestCase): + def testInvalidArguments(self): + self.assertRaises(TypeError, ObjectList, columns='') + self.assertRaises(TypeError, ObjectList, mode='') + + def testInstanceObjectList(self): + klist = ObjectList([Column('name', sorted=True)], + [Settable(name='first')]) + columns = klist.get_columns() + self.assertEqual(len(columns), 1) + self.assertEqual(columns[0].attribute, 'name') + + def testInstanceObjectListWithNoneData(self): + klist = ObjectList([Column('name', sorted=True)], + [Settable(name=None)]) + columns = klist.get_columns() + self.assertEqual(len(columns), 1) + +class MethodTest(unittest.TestCase): + def setUp(self): + self.klist = ObjectList([Column('name', sorted=True)], + [Settable(name='first')]) + + def testNonZero(self): + self.assertEqual(self.klist.__nonzero__(), True) + self.klist.remove(self.klist[0]) + self.assertEqual(self.klist.__nonzero__(), True) + if not self.klist: + raise AssertionError + + def testIter(self): + for item1 in self.klist: + pass + for item2 in iter(self.klist): + self.assertEqual(item1, item2) + + def testGetItem(self): + self.klist.append(Settable(name='second')) + model = self.klist.get_model() + item1 = model[0][0] + item2 = model[1][0] + self.assertEqual(self.klist[0], item1) + self.assertEqual(self.klist[:1], [item1]) + self.assertEqual(self.klist[-1:], [item2]) + self.assertRaises(TypeError, self.klist.__getitem__, None) + + def testSetItem(self): + self.klist[0] = Settable(name='second') + self.assertRaises(NotImplementedError, self.klist.__setitem__, + slice(0), None) + self.assertRaises(TypeError, self.klist.__setitem__, None, None) + + def testIndex(self): + self.assertRaises(NotImplementedError, self.klist.index, 0, start=0) + self.assertRaises(NotImplementedError, self.klist.index, 0, stop=0) + + self.assertEqual(self.klist.index(self.klist[0]), 0) + self.assertRaises(ValueError, self.klist.index, None) + + def testCount(self): + item = self.klist[0] + self.assertEqual(self.klist.count(item), 1) + self.klist.append(item) + self.assertEqual(self.klist.count(item), 2) + self.klist.clear() + self.assertEqual(self.klist.count(item), 0) + + def testInsert(self): + self.assertRaises(NotImplementedError, self.klist.insert, 1, 2) + + def testPop(self): + self.assertRaises(NotImplementedError, self.klist.pop, None) + + def testReverse(self): + self.assertRaises(NotImplementedError, self.klist.reverse, 1, 2) + + def testSort(self): + self.assertRaises(NotImplementedError, self.klist.sort, 1, 2) + + def testSelectPath(self): + self.klist.get_treeview().get_selection().set_mode(gtk.SELECTION_NONE) + self.assertRaises(TypeError, self.klist.select_paths, (0,)) + self.klist.get_treeview().get_selection().set_mode(gtk.SELECTION_SINGLE) + self.klist.select_paths((0,)) + + def testSelect(self): + self.klist.get_treeview().get_selection().set_mode(gtk.SELECTION_NONE) + self.assertRaises(TypeError, self.klist.select, None) + self.klist.get_treeview().get_selection().set_mode(gtk.SELECTION_SINGLE) + + def testGetSelected(self): + item = self.klist[0] + self.klist.select(item) + self.klist.get_treeview().get_selection().set_mode(gtk.SELECTION_SINGLE) + self.assertEqual(self.klist.get_selected(), item) + + def testGetSelectedRows(self): + self.klist.get_treeview().get_selection().set_mode(gtk.SELECTION_MULTIPLE) + item = self.klist[0] + self.klist.select(item) + self.assertEqual(self.klist.get_selected_rows(), [item]) + + def testGetNextAndPrevious(self): + self.klist.append(Settable(name='second')) + self.klist.append(Settable(name='third')) + item1, item2, item3 = self.klist + + self.assertEqual(self.klist.get_next(item1), item2) + self.assertEqual(self.klist.get_next(item2), item3) + self.assertEqual(self.klist.get_next(item3), item1) + self.assertRaises(ValueError, self.klist.get_next, None) + + self.assertEqual(self.klist.get_previous(item1), item3) + self.assertEqual(self.klist.get_previous(item2), item1) + self.assertEqual(self.klist.get_previous(item3), item2) + self.assertRaises(ValueError, self.klist.get_previous, None) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_SpinButton.py b/tests/test_SpinButton.py new file mode 100644 index 0000000..5ba937d --- /dev/null +++ b/tests/test_SpinButton.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python +import unittest + +from kiwi.ui.widgets.spinbutton import ProxySpinButton + +class SpinButtonTest(unittest.TestCase): + def testForIntFloat(self): + mySpinBtn = ProxySpinButton() + self.assertEqual(mySpinBtn.get_property("data-type"), int) + + # this test doens't work... might be a pygtk bug + #self.assertRaises(TypeError, mySpinBtn.set_property, 'data-type', str) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_argcheck.py b/tests/test_argcheck.py new file mode 100644 index 0000000..1682149 --- /dev/null +++ b/tests/test_argcheck.py @@ -0,0 +1,164 @@ +import datetime +from decimal import Decimal +import unittest + +from kiwi.argcheck import argcheck, number, percent + +class ArgTest(unittest.TestCase): + def testOneArg(self): + f = argcheck(str)(lambda s: None) + f('str') + self.assertRaises(TypeError, f, None) + self.assertRaises(TypeError, f, 1) + + def testTwoArgs(self): + f = argcheck(str, int)(lambda s, i: None) + f('str', 1) + self.assertRaises(TypeError, f, 1, 1) # first incorret + self.assertRaises(TypeError, f, 'str', 'str') # second incorrect + self.assertRaises(TypeError, f, 1, 'str') # swapped + self.assertRaises(TypeError, f, 1) # too few + self.assertRaises(TypeError, f, 'str', 1, 1) # too many + + def testVarArgs(self): + f = argcheck(int)(lambda *v: None) + f(1) + f(1, 'str') + f(1, 2, 3) + #self.assertRaises(TypeError, f, 'str') + + def testDefault(self): + f1 = lambda a, b=1: None + d1 = argcheck(int, int)(f1) + self.assertRaises(TypeError, d1, 'f') + + f2 = lambda a, b='str': None + self.assertRaises(TypeError, argcheck, f2) + + def testKwargs(self): + self.assertRaises(TypeError, argcheck, lambda **kw: None) + + def testUserDefined(self): + class Payment(object): + pass + + @argcheck(Payment, str) + def pay(payment, description): + pass + pay(Payment(), 'foo') + self.assertRaises(TypeError, 'bar', 'bar') + self.assertRaises(TypeError, Payment(), Payment()) + + def testClass(self): + class Custom(object): + pass + + class Test: + @argcheck(int, int) + def method1(self, foo, bar): + return foo + bar + + @argcheck(Custom, int, datetime.datetime, int, int, + float, float) + def method2(self, a, b, c, d, e, f, g=0.0): + return g + + @argcheck(str, datetime.datetime, datetime.datetime) + def method3(self, s, date=None, date2=None): + return + + @argcheck(percent) + def method4(self, n): + return n + + t = Test() + self.assertEqual(t.method1(1, 2), 3) + self.assertRaises(TypeError, t.method1, None, None) + self.assertEqual(t.method2(Custom(), 2, datetime.datetime.now(), + 4, 5, 6.0), 0.0) + + t.method3('foo') + t.method3('bar', None) + t.method3('baz', None, None) + t.method3(s='foo') + t.method3(s='bar', date=None) + t.method3(s='baz', date=None, date2=None) + t.method4(n=0) + t.method4(n=50) + t.method4(n=100) + self.assertRaises(TypeError, t.method3, 'noggie', True) + self.assertRaises(TypeError, t.method3, 'boogie', None, True) + self.assertRaises(TypeError, t.method3, s='noggie', date2=True) + self.assertRaises(TypeError, t.method3, s='boogie', + date=None, date2=True) + self.assertRaises(ValueError, t.method4, -1) + self.assertRaises(ValueError, t.method4, 101) + + def testNone(self): + @argcheck(datetime.datetime) + def func_none(date=None): + return date + func_none() + func_none(None) + self.assertRaises(TypeError, func_none, True) + self.assertRaises(TypeError, func_none, date=True) + + @argcheck(str, datetime.datetime, datetime.datetime) + def func_none2(s, date=None, date2=None): + return date + + func_none2('foo') + func_none2('bar', None) + func_none2('baz', None, None) + func_none2(s='foo') + func_none2(s='bar', date=None) + func_none2(s='baz', date=None, date2=None) + self.assertRaises(TypeError, func_none2, 'noggie', True) + self.assertRaises(TypeError, func_none2, 'boogie', None, True) + self.assertRaises(TypeError, func_none2, s='noggie', date2=True) + self.assertRaises(TypeError, func_none2, s='boogie', + date=None, date2=True) + + + def testNumber(self): + @argcheck(number) + def func(n): + return n + self.assertEqual(func(0), 0) + self.assertEqual(func(0L), 0L) + self.assertEqual(func(0.0), 0.0) + self.assertEqual(func(Decimal(0)), Decimal(0)) + + def testPercent(self): + @argcheck(percent) + def func(n): + return n + self.assertEqual(func(50), 50) + self.assertEqual(func(50L), 50L) + self.assertEqual(func(50.0), 50.0) + self.assertEqual(func(Decimal(50)), Decimal(50)) + self.assertRaises(ValueError, func, -1) + self.assertRaises(ValueError, func, -1L) + self.assertRaises(ValueError, func, -1.0) + self.assertRaises(ValueError, func, Decimal(-1)) + self.assertRaises(ValueError, func, 101) + self.assertRaises(ValueError, func, 101L) + self.assertRaises(ValueError, func, 101.0) + self.assertRaises(ValueError, func, Decimal(101)) + + def testDisable(self): + argcheck.disable() + @argcheck(str) + def func(s): + pass + func(10) + argcheck.enable() + + def testErrorHandling(self): + self.assertRaises(TypeError, argcheck(str), True) + self.assertRaises(TypeError, argcheck(int), lambda **x: None) + self.assertRaises(TypeError, argcheck(int), lambda : None) + self.assertRaises(TypeError, argcheck(int), lambda x='str': None) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_comboentry.py b/tests/test_comboentry.py new file mode 100644 index 0000000..b2d0501 --- /dev/null +++ b/tests/test_comboentry.py @@ -0,0 +1,94 @@ +import unittest + +import gtk + +from kiwi.ui.comboentry import ComboEntry +from kiwi.ui.widgets.combo import ProxyComboEntry + +class TestComboEntry(unittest.TestCase): + def setUp(self): + self.called = False + + def testSimple(self): + entry = ComboEntry() + self.failUnless(isinstance(entry, ComboEntry)) + + def testPopup(self): + entry = ComboEntry() + win = gtk.Window() + win.add(entry) + win.show_all() + entry.hide() + entry.popup() + entry.popdown() + + def _on_activate(self, combo): + self.called = True + + def testActivate(self): + entry = ComboEntry() + entry.connect('activate', self._on_activate) + entry.entry.emit('activate') + self.assertEqual(self.called, True) + +class TestProxyComboEntry(unittest.TestCase): + def testSelectItemByLabel(self): + entry = ProxyComboEntry() + entry.prefill(['one', 'two']) + entry.select_item_by_label('one') + self.assertEqual(entry.get_text(), 'one') + entry.select_item_by_label('two') + self.assertEqual(entry.get_text(), 'two') + self.assertRaises(KeyError, entry.select_item_by_label, 'three') + + def testSelectItemByLabelInDataMode(self): + entry = ProxyComboEntry() + entry.prefill([('one', 1), ('two', 2)]) + entry.select_item_by_label('one') + self.assertEqual(entry.get_text(), 'one') + entry.select_item_by_label('two') + self.assertEqual(entry.get_text(), 'two') + self.assertRaises(KeyError, entry.select_item_by_label, 'three') + + def testSelectItemByData(self): + entry = ProxyComboEntry() + entry.prefill([('one', 1), ('two', 2)]) + entry.select_item_by_data(1) + self.assertEqual(entry.get_text(), 'one') + entry.select_item_by_data(2) + self.assertEqual(entry.get_text(), 'two') + self.assertRaises(KeyError, entry.select_item_by_data, 3) + + def testSelectItemByDataInTextMode(self): + entry = ProxyComboEntry() + entry.prefill(['one', 'two']) + self.assertRaises(TypeError, entry.select_item_by_data, 1) + + def testGetSelectedInTextMode(self): + entry = ProxyComboEntry() + self.assertEqual(entry.get_selected(), None) + entry.prefill(['one', 'two']) + entry.select_item_by_label('two') + self.assertEqual(entry.get_selected(), 'two') + + def testGetSelectedInDataMode(self): + entry = ProxyComboEntry() + self.assertEqual(entry.get_selected(), None) + entry.prefill([('one', 1), ('two', 2)]) + entry.select_item_by_label('two') + self.assertEqual(entry.get_selected(), 2) + + def testSelectInTextMode(self): + entry = ProxyComboEntry() + entry.prefill(['one', 'two']) + entry.select('two') + self.assertEqual(entry.get_selected(), 'two') + + def testSelectInDataMode(self): + entry = ProxyComboEntry() + entry.prefill([('one', 1), ('two', 2)]) + entry.select(2) + self.assertEqual(entry.get_selected(), 2) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_component.py b/tests/test_component.py new file mode 100644 index 0000000..7f421c4 --- /dev/null +++ b/tests/test_component.py @@ -0,0 +1,121 @@ +import unittest + +from kiwi.component import AlreadyImplementedError, Interface, \ + get_utility, provide_utility, implements + +class IBanana(Interface): + pass + +class Obj(object): pass +o = Obj() + +class TestUtilities(unittest.TestCase): + def _clear(self, iface): + # Yey, yey + from kiwi.component import _handler + del _handler._utilities[iface] + + def testGet(self): + provide_utility(IBanana, o) + self.assertRaises(TypeError, get_utility, object) + self.assertEqual(get_utility(IBanana), o) + self._clear(IBanana) + + def testProvide(self): + self.assertRaises(NotImplementedError, get_utility, IBanana) + provide_utility(IBanana, o) + self.assertRaises(TypeError, provide_utility, object, o) + self._clear(IBanana) + + def testAlreadyImplemented(self): + self.assertRaises(NotImplementedError, get_utility, IBanana) + provide_utility(IBanana, o) + self.assertRaises(AlreadyImplementedError, + provide_utility, IBanana, o) + self._clear(IBanana) + + def testZopeInterface(self): + try: + from zope.interface import Interface + except ImportError: + return + + class IApple(Interface): + pass + + self.assertRaises(NotImplementedError, get_utility, IApple) + provide_utility(IApple, o) + self.assertRaises(AlreadyImplementedError, + provide_utility, IApple, o) + self._clear(IApple) + + def testImplements(self): + class I1(Interface): + pass + class C(object): + implements(I1) + c = C() + class X(object): + pass + x = X() + self.assertEqual(I1.providedBy(x), False) + #self.assertEqual(I1.providedBy(C), False) + self.assertEqual(I1.providedBy(c), True) + + def testInterfaceSub(self): + class I1(Interface): + pass + class I2(I1): + pass + class C(object): + implements(I2) + class D(object): + implements(I1) + c = C() + self.assertEqual(I1.providedBy(c), True) + self.assertEqual(I2.providedBy(c), True) + d = D() + self.assertEqual(I1.providedBy(d), True) + self.assertEqual(I2.providedBy(d), False) + + def testZImplements(self): + try: + from zope.interface import Interface, implements + except ImportError: + return + + class I1(Interface): + pass + class C(object): + implements(I1) + c = C() + class X(object): + pass + x = X() + self.assertEqual(I1.providedBy(x), False) + self.assertEqual(I1.providedBy(C), False) + self.assertEqual(I1.providedBy(c), True) + + def testZInterfaceSub(self): + try: + from zope.interface import Interface, implements + except ImportError: + return + + class I1(Interface): + pass + class I2(I1): + pass + class C(object): + implements(I2) + class D(object): + implements(I1) + c = C() + self.assertEqual(I1.providedBy(c), True) + self.assertEqual(I2.providedBy(c), True) + d = D() + self.assertEqual(I1.providedBy(d), True) + self.assertEqual(I2.providedBy(d), False) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_datatypes.py b/tests/test_datatypes.py new file mode 100644 index 0000000..d82a2b4 --- /dev/null +++ b/tests/test_datatypes.py @@ -0,0 +1,271 @@ +from decimal import Decimal +import datetime +import unittest +import locale + +from kiwi.datatypes import currency, converter, ValidationError, ValueUnset + +import utils + +def set_locale(category, name): + # set the date format to the spanish one + try: + locale.setlocale(category, name) + except locale.Error: + print 'skipping %s, locale not available' % name + return False + return True + +class RegistryTest(unittest.TestCase): + def testAdd(self): + self.assertRaises(TypeError, converter.add, object) + +class BoolTest(unittest.TestCase): + def setUp(self): + self.conv = converter.get_converter(bool) + + def testFromString(self): + self.assertEqual(self.conv.from_string('TRUE'), True) + self.assertEqual(self.conv.from_string('true'), True) + self.assertEqual(self.conv.from_string('TrUe'), True) + self.assertEqual(self.conv.from_string('1'), True) + self.assertEqual(self.conv.from_string('FALSE'), False) + self.assertEqual(self.conv.from_string('false'), False) + self.assertEqual(self.conv.from_string('FalSE'), False) + self.assertEqual(self.conv.from_string('0'), False) + + # you are not supposed to pass something that is not a string + self.assertRaises(AttributeError, self.conv.from_string, None) + +class DateTest(unittest.TestCase): + def setUp(self): + self.date = datetime.date(1979, 2, 12) + self.conv = converter.get_converter(datetime.date) + + def tearDown(self): + set_locale(locale.LC_ALL, 'C') + + def testFromStringES(self): + if not set_locale(locale.LC_TIME, 'es_ES'): + return + + self.assertEqual(self.conv.from_string("12/2/79"), self.date) + self.assertEqual(self.conv.from_string("12/02/79"), self.date) + + def testAsStringES(self): + if not set_locale(locale.LC_TIME, 'es_ES'): + return + + self.assertEqual(self.conv.as_string(self.date), "12/02/79") + + def testFromStringBR(self): + if not set_locale(locale.LC_TIME, 'pt_BR'): + return + + self.assertEqual(self.conv.from_string("12-2-1979"), self.date) + self.assertEqual(self.conv.from_string("12-02-1979"), self.date) + + # test some invalid dates + self.assertRaises(ValidationError, + self.conv.from_string, "40-10-2005") + self.assertRaises(ValidationError, + self.conv.from_string, "30-02-2005") + + def testAsStringBR(self): + if not set_locale(locale.LC_TIME, 'pt_BR'): + return + + self.assertEqual(self.conv.as_string(self.date), "12-02-1979") + +class CurrencyTest(unittest.TestCase): + def setUp(self): + self.conv = converter.get_converter(currency) + + def tearDown(self): + set_locale(locale.LC_ALL, 'C') + + def testFormatBR(self): + if not set_locale(locale.LC_MONETARY, 'pt_BR'): + return + + self.assertEqual(currency(100).format(), 'R$100') + self.assertEqual(currency('123.45').format(), 'R$123,45') + self.assertEqual(currency(12345).format(), 'R$12.345') + self.assertEqual(currency(-100).format(), 'R$-100') + + # Sometimes it works, sometimes it doesn''10,000,000.0't + #self.assertEqual(self.conv.from_string('0,5'), currency('0.5')) + + def testFormatUS(self): + if not set_locale(locale.LC_MONETARY, 'en_US'): + return + + self.assertEqual(currency(100).format(), '$100') + self.assertEqual(currency('123.45').format(), '$123.45') + self.assertEqual(currency(12345).format(), '$12,345') + self.assertEqual(currency(-100).format(), '$-100') + self.assertEqual(currency(1).format(True), '$1') + self.assertEqual(currency(1).format(False), '1') + self.assertEqual(currency(0).format(True), '$0') + + self.assertEqual(self.conv.from_string(''), ValueUnset) + self.assertEqual(self.conv.from_string('0'), currency(0)) + self.assertEqual(self.conv.from_string('0.5'), currency('0.5')) + self.assertRaises(ValidationError, self.conv.from_string, 'foo') + + self.assertEqual(self.conv.as_string(currency(0)), '$0.00') + self.assertEqual(self.conv.as_string(currency(-10)), '$-10.00') + #self.assertEqual(ValidationError, self.conv.as_string, object) + +class UnicodeTest(unittest.TestCase): + def setUp(self): + self.conv = converter.get_converter(unicode) + + def testFromString(self): + self.assertEqual(self.conv.from_string('foobar'), u'foobar') + # utf-8 encoded, as default after importing gtk + self.assertEqual(self.conv.from_string('\xc3\xa4'), u'\xe4') + + def testAsString(self): + self.assertEqual(self.conv.as_string(u'foobar'), 'foobar') + self.assertEqual(self.conv.as_string(u'\xe4'), '\xc3\xa4') + +class IntTest(unittest.TestCase): + def setUp(self): + self.conv = converter.get_converter(int) + + def tearDown(self): + set_locale(locale.LC_ALL, 'C') + + def testFromString(self): + self.assertEqual(self.conv.from_string('0'), 0) + self.assertRaises(ValidationError, self.conv.from_string, '0.5') + + def testAsString(self): + self.assertEqual(self.conv.as_string(0), '0') + self.assertEqual(self.conv.as_string(-10), '-10') + + def testAsStringUS(self): + if not set_locale(locale.LC_NUMERIC, 'en_US'): + return + + self.assertEqual(self.conv.as_string(123456789), '123456789') + +class FloatTest(unittest.TestCase): + def setUp(self): + self.conv = converter.get_converter(float) + + def tearDown(self): + set_locale(locale.LC_ALL, 'C') + + def testFromString(self): + self.assertEqual(self.conv.from_string('0'), 0.0) + self.assertEqual(self.conv.from_string('-0'), 0.0) + self.assertEqual(self.conv.from_string('0.'), 0.0) + self.assertEqual(self.conv.from_string('0.0'), 0.0) + self.assertEqual(self.conv.from_string('.5'), .5) + self.assertEqual(self.conv.from_string('-2.5'), -2.5) + self.assertEqual(self.conv.from_string('10.33'), 10.33) + self.assertEqual(self.conv.from_string('0.00000000001'), 0.00000000001) + self.assertRaises(ValidationError, self.conv.from_string, 'foo') + self.assertRaises(ValidationError, self.conv.from_string, '1.2.3') + self.assertEqual(self.conv.from_string(''), ValueUnset) + + def testFromStringUS(self): + if not set_locale(locale.LC_NUMERIC, 'en_US'): + return + self.assertEqual(self.conv.from_string('0.'), 0) + self.assertEqual(self.conv.from_string('1.75'), 1.75) + self.assertEqual(self.conv.from_string('10,000'), 10000) + self.assertEqual(self.conv.from_string('10,000,000.5'), 10000000.5) + self.assertRaises(ValidationError, + self.conv.from_string, ',210,000,000.5') + + def testFromStringSE(self): + # Swedish is interesting here because it has different + # thousand separator and decimal points (compared to en_US) + if not set_locale(locale.LC_NUMERIC, 'sv_SE'): + return + self.assertEqual(self.conv.from_string('0,'), 0) + self.assertEqual(self.conv.from_string('1,75'), 1.75) + self.assertEqual(self.conv.from_string('4 321'), 4321) + self.assertEqual(self.conv.from_string('54 321'), 54321) + self.assertEqual(self.conv.from_string('654 321'), 654321) + self.assertEqual(self.conv.from_string('7 654 321'), 7654321) + self.assertEqual(self.conv.from_string('10 000 000,5'), 10000000.5) + self.assertRaises(ValidationError, self.conv.from_string, '1,2 3') + self.assertRaises(ValidationError, self.conv.from_string, '1 23 ') + self.assertRaises(ValidationError, self.conv.from_string, ' 23 ') + #self.assertRaises(ValidationError, self.conv.from_string, '1234 234') + + def testAsString(self): + self.assertEqual(self.conv.as_string(0.0), '0.0') + self.assertEqual(self.conv.as_string(0.5), '0.5') + self.assertEqual(self.conv.as_string(-0.5), '-0.5') + self.assertEqual(self.conv.as_string(0.123456789), '0.123456789') + self.assertEqual(self.conv.as_string(-0.123456789), '-0.123456789') + self.assertEqual(self.conv.as_string(10000000), '10000000.0') + self.assertEqual(self.conv.as_string(10000000.0), '10000000.0') + + def testAsStringUS(self): + if not set_locale(locale.LC_NUMERIC, 'en_US'): + return + self.assertEqual(self.conv.as_string(10000000), '10,000,000.0') + self.assertEqual(self.conv.as_string(10000000.0), '10,000,000.0') + + def testAsStringSE(self): + if not set_locale(locale.LC_NUMERIC, 'sv_SE'): + return + self.assertEqual(self.conv.as_string(0.0), '0,0') + self.assertEqual(self.conv.as_string(0.5), '0,5') + self.assertEqual(self.conv.as_string(-0.5), '-0,5') + self.assertEqual(self.conv.as_string(0.123456789), '0,123456789') + self.assertEqual(self.conv.as_string(-0.123456789), '-0,123456789') + self.assertEqual(self.conv.as_string(10000000), '10000000,0') + self.assertEqual(self.conv.as_string(10000000.0), '10000000,0') + + +class DecimalTest(unittest.TestCase): + def setUp(self): + self.conv = converter.get_converter(Decimal) + + def tearDown(self): + set_locale(locale.LC_ALL, 'C') + + def testFromString(self): + self.assertEqual(self.conv.from_string('-2.5'), Decimal('-2.5')) + self.assertEqual(self.conv.from_string('10.33'), Decimal('10.33')) + self.assertRaises(ValidationError, self.conv.from_string, 'foo') + self.assertRaises(ValidationError, self.conv.from_string, '1.2.3') + self.assertEqual(self.conv.from_string(''), ValueUnset) + + def testAsString(self): + self.assertEqual(self.conv.as_string(Decimal('0.0')), '0.0') + self.assertEqual(self.conv.as_string(Decimal('0.5')), '0.5') + self.assertEqual(self.conv.as_string(Decimal('-0.5')), '-0.5') + self.assertEqual(self.conv.as_string(Decimal('0.123456789')), '0.123456789') + self.assertEqual(self.conv.as_string(Decimal('-0.123456789')), '-0.123456789') + self.assertEqual(self.conv.as_string(Decimal('10000000')), '10000000.0') + self.assertEqual(self.conv.as_string(Decimal('10000000.0')), '10000000.0') + + def testAsStringUS(self): + if not set_locale(locale.LC_NUMERIC, 'en_US'): + return + self.assertEqual(self.conv.as_string(Decimal('10000000')), '10,000,000.0') + self.assertEqual(self.conv.as_string(Decimal('10000000.0')), '10,000,000.0') + + def testAsStringSE(self): + if not set_locale(locale.LC_NUMERIC, 'sv_SE'): + return + self.assertEqual(self.conv.as_string(Decimal('0.0')), '0,0') + self.assertEqual(self.conv.as_string(Decimal('0.5')), '0,5') + self.assertEqual(self.conv.as_string(Decimal('-0.5')), '-0,5') + self.assertEqual(self.conv.as_string(Decimal('0.123456789')), '0,123456789') + self.assertEqual(self.conv.as_string(Decimal('-0.123456789')), '-0,123456789') + self.assertEqual(self.conv.as_string(Decimal('10000000')), '10000000,0') + self.assertEqual(self.conv.as_string(Decimal('10000000.0')), '10000000,0') + + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_dateentry.py b/tests/test_dateentry.py new file mode 100644 index 0000000..382fee3 --- /dev/null +++ b/tests/test_dateentry.py @@ -0,0 +1,19 @@ +import sys +import datetime +import unittest + +from kiwi.ui.dateentry import DateEntry + +class TestDateEntry(unittest.TestCase): + def setUp(self): + self.date = datetime.date.today() + + def testGetSetDate(self): + if sys.platform == 'win32': + return + entry = DateEntry() + entry.set_date(self.date) + self.assertEqual(entry.get_date(), self.date) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_desktopparser.py b/tests/test_desktopparser.py new file mode 100644 index 0000000..d583504 --- /dev/null +++ b/tests/test_desktopparser.py @@ -0,0 +1,74 @@ +# encoding: utf-8 +import StringIO +import unittest + +from kiwi.desktopparser import DesktopParser + +desktop_data = """ +[Desktop Entry] +Name=Totem Movie Player +Name[pt]=Reprodutor de Filmes Totem +Name[sv]=Filmspelaren Totem +Categories=GNOME;Application;AudioVideo +""" + +class TestTotem(unittest.TestCase): + def setUp(self): + self.parser = DesktopParser() + self.parser.readfp(StringIO.StringIO(desktop_data)) + + def test(self): + self.assertEqual(self.parser.get('Desktop Entry', 'Name'), + 'Totem Movie Player') + self.assertEqual(self.parser.get_locale( + 'Desktop Entry', 'Name', 'pt'), 'Reprodutor de Filmes Totem') + self.assertEqual(self.parser.get_locale( + 'Desktop Entry', 'Name', 'sv'), 'Filmspelaren Totem') + self.assertEqual( + self.parser.get_string_list('Desktop Entry', 'Categories'), + ['GNOME', 'Application', 'AudioVideo']) + + +class TestDesktopParser(unittest.TestCase): + def setUp(self): + self.parser = DesktopParser() + self.parser.add_section('Section') + + def testList(self): + self.parser.set_string_list('Section', 'Foo', ['A', 'B', 'C']) + self.assertEqual( + self.parser.get_string_list('Section', 'Foo'), + ['A', 'B', 'C']) + + self.parser.set_integer_list('Section', 'Bar', [1, 2, 3]) + self.assertEqual( + self.parser.get_integer_list('Section', 'Bar'), + [1, 2, 3]) + + self.parser.set_boolean_list('Section', 'Bar', [True, False]) + self.assertEqual( + self.parser.get_boolean_list('Section', 'Bar'), + [True, False]) + + def testLocale(self): + self.parser.set_locale( + 'Section', 'Foo', 'sv', 'Apa') + self.assertEqual( + self.parser.get_locale('Section', 'Foo', 'sv'), + 'Apa') + + self.parser.set_string_list_locale( + 'Section', 'Foo', 'sv', ['å', 'ä', 'ö']) + self.assertEqual( + self.parser.get_string_list_locale('Section', 'Foo', 'sv'), + ['å', 'ä', 'ö']) + + def testListSeparator(self): + self.parser.set('Section', 'Comma', '1,2,3') + self.assertEqual( + self.parser.get_string_list('Section', 'Comma'), + ['1,2,3']) + self.parser.set_list_separator(',') + self.assertEqual( + self.parser.get_string_list('Section', 'Comma'), + ['1', '2', '3']) diff --git a/tests/test_gazpacholoader.py b/tests/test_gazpacholoader.py new file mode 100644 index 0000000..376dd0b --- /dev/null +++ b/tests/test_gazpacholoader.py @@ -0,0 +1,41 @@ +import unittest + +import gobject +import gtk +from gazpacho.loader.loader import ObjectBuilder + +from kiwi.python import disabledeprecationcall +import kiwi.ui.gazpacholoader +kiwi + +HAVE_2_8 = gobject.pygtk_version[:2] == (2, 8) + +def glade(s): + return '<glade-interface>%s</glade-interface>' % s + +class TestGazpachoLoader(unittest.TestCase): + def testConstruct(self): + objs = [("kiwi+ui+widgets+list+List", "w1"), + ("kiwi+ui+widgets+combobox+ComboBox", "w3"), + ("kiwi+ui+widgets+combobox+ComboBoxEntry", "w5") + ] + + if HAVE_2_8: + objs.extend([("ObjectList", "w2"), + ("ProxyComboBox", "w4"), + ("ProxyComboBoxEntry", "w6") + ]) + s = '' + + for obj, name in objs: + s += '<widget class="%s" id="%s"/>\n' % (obj, name) + ob = disabledeprecationcall(ObjectBuilder, buffer=glade(s)) + for obj, name in objs: + widget = ob.get_widget(name) + self.failUnless(isinstance(widget, gtk.Widget)) + gtype = gobject.type_from_name(obj) + self.failUnless(gobject.type_is_a(gtype, gtk.Widget)) + self.failUnless(gobject.type_is_a(gtype, widget)) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_proxy.py b/tests/test_proxy.py new file mode 100644 index 0000000..f8338d1 --- /dev/null +++ b/tests/test_proxy.py @@ -0,0 +1,123 @@ +import unittest + +from kiwi import ValueUnset +from kiwi.python import Settable +from kiwi.ui.proxy import Proxy +from kiwi.ui.widgets.checkbutton import ProxyCheckButton +from kiwi.ui.widgets.entry import ProxyEntry +from kiwi.ui.widgets.label import ProxyLabel +from kiwi.ui.widgets.radiobutton import ProxyRadioButton +from kiwi.ui.widgets.spinbutton import ProxySpinButton +from kiwi.ui.widgets.textview import ProxyTextView +from kiwi.ui.widgets.combo import ProxyComboEntry, ProxyComboBox + +class FakeView(object): + def __init__(self): + self.widgets = [] + + def add(self, name, data_type, widget_type): + widget = widget_type() + widget.set_property('model-attribute', name) + widget.set_property('data-type', data_type) + + setattr(self, name, widget) + self.widgets.append(name) + return widget + + def handler_block(self, *args): + pass + + def handler_unblock(self, *args): + pass + +class Model(Settable): + def __init__(self): + Settable.__init__(self, + entry='foo', + checkbutton=True, + radiobutton='first', + label='label', + spinbutton=100, + textview='sliff', + comboentry='CE1', + combobox='CB1') + +class TestProxy(unittest.TestCase): + def setUp(self): + self.view = FakeView() + self.view.add('checkbutton', bool, ProxyCheckButton) + self.view.add('entry', str, ProxyEntry) + self.view.add('label', str, ProxyLabel) + self.view.add('spinbutton', int, ProxySpinButton) + self.view.add('textview', str, ProxyTextView) + self.radio_first = self.view.add('radiobutton', str, ProxyRadioButton) + self.radio_first.set_property('data_value', 'first') + self.radio_second = ProxyRadioButton() + self.radio_second.set_group(self.radio_first) + self.radio_second.set_property('data_value', 'second') + + self.comboentry = self.view.add('comboentry', str, ProxyComboEntry) + self.comboentry.prefill(['CE1','CE2','CE3']) + + self.combobox = self.view.add('combobox', str, ProxyComboBox) + self.combobox.prefill(['CB1','CB2','CB3']) + + self.model = Model() + self.proxy = Proxy(self.view, self.model, self.view.widgets) + + def testCheckButton(self): + self.assertEqual(self.model.checkbutton, True) + self.view.checkbutton.set_active(False) + self.assertEqual(self.model.checkbutton, False) + + def testEntry(self): + self.assertEqual(self.model.entry, 'foo') + self.view.entry.set_text('bar') + self.assertEqual(self.model.entry, 'bar') + + def testLabel(self): + self.assertEqual(self.model.label, 'label') + self.view.label.set_text('other label') + self.assertEqual(self.model.label, 'other label') + + def testRadioButton(self): + self.assertEqual(self.model.radiobutton, 'first') + self.radio_second.set_active(True) + self.assertEqual(self.model.radiobutton, 'second') + self.radio_first.set_active(True) + self.assertEqual(self.model.radiobutton, 'first') + + def testSpinButton(self): + self.assertEqual(self.model.spinbutton, 100) + self.view.spinbutton.set_text("200") + self.assertEqual(self.model.spinbutton, 200) + + def testTextView(self): + self.assertEqual(self.model.textview, 'sliff') + self.view.textview.get_buffer().set_text('sloff') + self.assertEqual(self.model.textview, 'sloff') + + def testComboEntry(self): + self.assertEqual(self.model.comboentry, 'CE1') + self.view.comboentry.select('CE2') + self.assertEqual(self.model.comboentry, 'CE2') + self.view.comboentry.entry.set_text('CENone') + self.assertEqual(self.model.comboentry, None) + + def testComboBox(self): + self.assertEqual(self.model.combobox, 'CB1') + self.view.combobox.select('CB2') + self.assertEqual(self.model.combobox, 'CB2') + + def testEmptyModel(self): + self.radio_second.set_active(True) + + self.proxy.set_model(None) + self.assertEqual(self.view.entry.read(), '') + self.assertEqual(self.view.checkbutton.read(), False) + self.assertEqual(self.view.radiobutton.read(), 'first') + self.assertEqual(self.view.label.read(), '') + self.assertEqual(self.view.spinbutton.read(), ValueUnset) + self.assertEqual(self.view.textview.read(), '') + self.assertEqual(self.view.comboentry.read(), None) + self.assertEqual(self.view.combobox.read(), 'CB1') diff --git a/tests/test_python.py b/tests/test_python.py new file mode 100644 index 0000000..5acd9e1 --- /dev/null +++ b/tests/test_python.py @@ -0,0 +1,28 @@ +import unittest + +from kiwi.python import slicerange + +class SliceTest(unittest.TestCase): + def genlist(self, limit, start, stop=None, step=None): + if stop == None: + stop = start + start = None + + return list(slicerange(slice(start, stop, step), limit)) + + def testStop(self): + self.assertEqual(self.genlist(10, 10), range(10)) + self.assertEqual(self.genlist(10, -5), range(5)) + self.assertEqual(self.genlist(10, -15), []) + self.assertEqual(self.genlist(5, 10), range(5)) + self.assertEqual(self.genlist(0, 10), []) + + def testStartStop(self): + self.assertEqual(self.genlist(10, 0, 10), range(10)) + self.assertEqual(self.genlist(10, 1, 9), range(10)[1:9]) + self.assertEqual(self.genlist(10, -1, -1), range(10)[-1:-1]) + self.assertEqual(self.genlist(10, 0, -15), range(10)[0:-15]) + self.assertEqual(self.genlist(10, 15, 0), range(10)[-15:0]) + + def testStartStopStep(self): + self.assertEqual(self.genlist(10, 0, 10, 2), range(10)[0:10:2]) diff --git a/tests/test_tasklet.py b/tests/test_tasklet.py new file mode 100644 index 0000000..dd5292f --- /dev/null +++ b/tests/test_tasklet.py @@ -0,0 +1,18 @@ +import unittest + +import gobject + +from kiwi.tasklet import WaitForSignal + +import utils + +class TestWaitForSignal(unittest.TestCase): + def testBadArguments(self): + self.assertRaises(TypeError, WaitForSignal, '', '') + self.assertRaises(ValueError, WaitForSignal, gobject.GObject(), 'foo') + + def testGoodArgumnets(self): + WaitForSignal(gobject.GObject(), 'notify') + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 0000000..362bd6c --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,74 @@ +import unittest + +import gobject + +from kiwi.ui.widgets.combo import ProxyComboBox +from kiwi.utils import PropertyObject, gproperty, HAVE_2_6 + +class Test(gobject.GObject, PropertyObject): + __gtype_name__ = 'Test' + gproperty('str-prop', str, nick='Nick', blurb='Blurb', + default='Default') + + def __init__(self, **kwargs): + gobject.GObject.__init__(self) + PropertyObject.__init__(self, **kwargs) + +class GPropertyTest(unittest.TestCase): + def testProperties(self): + for pspec in gobject.list_properties(Test): + self.assertEqual(pspec.name, 'str-prop') + self.assertEqual(pspec.nick, 'Nick', pspec.nick) + self.assertEqual(pspec.default_value, 'Default', + pspec.default_value) + self.assertEqual(pspec.blurb, 'Blurb', pspec.blurb) + +class Subclassing(unittest.TestCase): + def testSimple(self): + subtype = type('Test2', (Test,), {}) + self.failUnless(issubclass(subtype, Test)) + instance = subtype() + self.failUnless(isinstance(instance, Test)) + self.failUnless(isinstance(instance, subtype)) + + def testCombo(self): + self.assertEqual(getattr(ProxyComboBox, '__gsignals__', {}), {}) + self.assertEqual(getattr(ProxyComboBox, '__gproperties__', {}), {}) + subentry = type('MyClass', (ProxyComboBox,), {}) + self.assertNotEqual(gobject.type_name(subentry), + gobject.type_name(ProxyComboBox)) + +class MixinTest(unittest.TestCase): + def testProperties(self): + class Mixin(object): + gproperty('mixin-prop', str, default='foo') + + class Object(gobject.GObject, PropertyObject, Mixin): + gproperty('normal-prop', str, default='bar') + + def __init__(self, **kwargs): + gobject.GObject.__init__(self) + PropertyObject.__init__(self, **kwargs) + + o = Object() + + self.failUnless(hasattr(o, 'normal_prop')) + self.assertEqual(o.normal_prop, 'bar') + self.failUnless(hasattr(o, 'mixin_prop')) + self.assertEqual(o.mixin_prop, 'foo') + + def testSpinButton(self): + from kiwi.ui.widgets.spinbutton import ProxySpinButton + s = ProxySpinButton() + self.failUnless(hasattr(s, 'data_type')) + self.assertEqual(s.data_type, int) + + def testTypeName(self): + class Object(gobject.GObject, PropertyObject): + __gtype_name__ = 'Object' + if HAVE_2_6: + return + self.assertEqual(gobject.type_name(Object), 'Object') + +if __name__ == '__main__': + unittest.main() diff --git a/tests/utils.py b/tests/utils.py new file mode 100644 index 0000000..6adf8bf --- /dev/null +++ b/tests/utils.py @@ -0,0 +1,23 @@ +import os +import sys +import time + +try: + import pygtk + pygtk.require('2.0') +except: + pass + +import gtk + +def refresh_gui(delay=0): + while gtk.events_pending(): + gtk.main_iteration_do(block=False) + time.sleep(delay) + +dir = os.path.dirname(__file__) +if not dir in sys.path: + sys.path.insert(0, os.path.join(dir)) + +from kiwi.environ import environ +environ.add_resource('glade', dir) |