Kivy-examples 2.3.1.dev0__py3-none-any.whl

kivy/tests/test_issues/test_6315.py

@@ -0,0 +1,55 @@
+import unittest
+
+
+class PaddingSpacingTestCase(unittest.TestCase):
+    def test_tb_lr_stacklayout(self):
+        from kivy.uix.checkbox import CheckBox
+        a = CheckBox(allow_no_selection=False, group='check')
+        b = CheckBox(allow_no_selection=False, group='check')
+
+        a.active = True
+        self.assertTrue(a.active)
+        self.assertEqual(a.state, 'down')
+
+        self.assertFalse(b.active)
+        self.assertEqual(b.state, 'normal')
+
+        b.active = True
+        self.assertTrue(b.active)
+        self.assertEqual(b.state, 'down')
+
+        self.assertFalse(a.active)
+        self.assertEqual(a.state, 'normal')
+
+        a.state = 'down'
+        self.assertTrue(a.active)
+        self.assertEqual(a.state, 'down')
+
+        self.assertFalse(b.active)
+        self.assertEqual(b.state, 'normal')
+
+        b.state = 'down'
+        self.assertTrue(b.active)
+        self.assertEqual(b.state, 'down')
+
+        self.assertFalse(a.active)
+        self.assertEqual(a.state, 'normal')
+
+        b.state = 'normal'
+        self.assertFalse(a.active)
+        self.assertEqual(a.state, 'normal')
+        self.assertFalse(b.active)
+        self.assertEqual(b.state, 'normal')
+
+        b.state = 'down'
+        self.assertTrue(b.active)
+        self.assertEqual(b.state, 'down')
+
+        self.assertFalse(a.active)
+        self.assertEqual(a.state, 'normal')
+
+        b.active = False
+        self.assertFalse(a.active)
+        self.assertEqual(a.state, 'normal')
+        self.assertFalse(b.active)
+        self.assertEqual(b.state, 'normal')

kivy/tests/test_issues/test_issue_1084.py

@@ -0,0 +1,47 @@
+#
+# Bug fixed:
+# - put utf-8 in string, and validate -> no more crash due to str() encoding
+# - put utf-8 in string, validate, close, open the app and edit the value -> no
+# more weird space due to ascii->utf8 encoding.
+# - create an unicode directory, and select it with Path. -> no more crash at
+# validation.
+# - create an unicode directory, and select it with Path and restart -> the
+# path is still correct.
+
+from kivy.app import App
+
+data = '''
+[
+    {
+        "type": "string",
+        "title": "String",
+        "desc": "-",
+        "section": "test",
+        "key": "string"
+    },
+    {
+        "type": "path",
+        "title": "Path",
+        "desc": "-",
+        "section": "test",
+        "key": "path"
+    }
+]
+'''
+
+
+class UnicodeIssueSetting(App):
+    def build_config(self, config):
+        config.add_section('test')
+        config.setdefault('test', 'string', 'Hello world')
+        config.setdefault('test', 'path', '/')
+
+    def build(self):
+        from kivy.uix.settings import Settings
+        s = Settings()
+        s.add_json_panel('Test Panel', self.config, data=data)
+        return s
+
+
+if __name__ == '__main__':
+    UnicodeIssueSetting().run()

kivy/tests/test_issues/test_issue_1091.py

@@ -0,0 +1,19 @@
+import unittest
+
+
+class PaddingSpacingTestCase(unittest.TestCase):
+    def test_tb_lr_stacklayout(self):
+        from kivy.uix.stacklayout import StackLayout
+        from kivy.uix.widget import Widget
+
+        stacklayout = StackLayout(
+            orientation='tb-lr',
+            size=(200, 200),
+            padding=20,
+            spacing=10)
+
+        widget = Widget(width=100, size_hint=(0.2, 0.4))
+        stacklayout.add_widget(widget)
+        stacklayout.do_layout()
+
+        self.assertEqual(stacklayout.top - widget.top, 20)

kivy/tests/test_issues/test_issue_599.py

@@ -0,0 +1,21 @@
+import unittest
+
+
+class Issue599(unittest.TestCase):
+
+    def test_minmax(self):
+        from kivy.event import EventDispatcher
+        from kivy.properties import BoundedNumericProperty
+
+        class PropertyWidget(EventDispatcher):
+            foo = BoundedNumericProperty(1, min=-5, max=5)
+
+        wid = PropertyWidget()
+
+        self.assertEqual(wid.property('foo').get_min(wid), -5)
+        wid.property('foo').set_min(wid, 0)
+        self.assertEqual(wid.property('foo').get_min(wid), 0)
+
+        self.assertEqual(wid.property('foo').get_max(wid), 5)
+        wid.property('foo').set_max(wid, 10)
+        self.assertEqual(wid.property('foo').get_max(wid), 10)

kivy/tests/test_issues/test_issue_609.py

@@ -0,0 +1,19 @@
+from kivy.tests.common import GraphicUnitTest
+
+
+class Issue609(object):
+
+    def test_markup_pos(self):
+        from kivy.uix.label import Label
+        from kivy.uix.gridlayout import GridLayout
+
+        lbl = Label(text="TextToTest")
+        lbl.bind(text_size=lbl.setter('size'))
+        mrkp = Label(text="TextToTest", markup=True)
+        mrkp.bind(text_size=mrkp.setter('size'))
+
+        grid = GridLayout(rows=1, size_hint=(1, 1))
+        grid.add_widget(lbl)
+        grid.add_widget(mrkp)
+
+        self.render(grid, 2)

kivy/tests/test_issues/test_issue_6909.py

@@ -0,0 +1,28 @@
+import locale
+import unittest
+from unittest import mock
+from kivy import Config
+from kivy.logger import Logger, FileHandler
+import pytest
+
+
+class CodecLoggingTestCase(unittest.TestCase):
+    def test_log_handles_cp949(self):
+        with mock.patch("locale.getpreferredencoding", return_value="cp949"):
+            FileHandler.fd = None
+            FileHandler.encoding = "utf-8"
+            Config.set("kivy", "log_enable", 1)
+            Config.set("kivy", "log_level", "trace")
+            for string in ["한국어", "Niñas and niños"]:
+                Logger.trace("Lang: call_fn => value=%r" % (string,))
+
+    def test_non_utf8_encoding_raises_exception(
+        self,
+    ):  # the old error before utf-8 was standard
+        FileHandler.fd = None
+        FileHandler.encoding = "cp949"
+        Config.set("kivy", "log_enable", 1)
+        Config.set("kivy", "log_level", "trace")
+
+        with pytest.raises(UnicodeError):
+            Logger.trace("Lang: call_fn => value=%r" % ("Niñas and niños",))

kivy/tests/test_issues/test_issue_883.py

@@ -0,0 +1,12 @@
+import unittest
+
+
+class LabelEmptyMarkupTestCase(unittest.TestCase):
+    def test_empty_markup(self):
+        from kivy.uix.label import Label
+
+        label = Label(text='[b][/b]', markup=True)
+        label.texture_update()
+        self.assertTrue(label.texture is not None)
+        self.assertEqual(label.texture.width, 1)
+        self.assertEqual(label.texture.height, 1)

kivy/tests/test_kivy_init.py

@@ -0,0 +1,30 @@
+from kivy import (
+    kivy_configure, kivy_register_post_configuration, get_includes,
+    kivy_usage)
+from unittest.mock import Mock, patch
+from os.path import exists, isdir
+
+
+def test_kivy_configure():
+    """Test the kivy_configure calls the post_configuration callbacks."""
+    mock_callback = Mock()
+    kivy_register_post_configuration(mock_callback)
+    kivy_configure()
+
+    mock_callback.assert_called()
+
+
+def test_kivy_get_includes():
+    """Test that the `get_includes` function return a list of valid paths."""
+    paths = get_includes()
+    assert len(paths) > 2, "get_includes does not return a full path list."
+    for path in paths:
+        assert exists(path) and isdir(path), \
+            "get_includes returns invalid paths."
+
+
+def test_kivy_usage():
+    """Test the kivy_usage command."""
+    with patch('kivy.print') as mock_print:
+        kivy_usage()
+        mock_print.assert_called()

kivy/tests/test_knspace.py

@@ -0,0 +1,247 @@
+
+import unittest
+'''ACHTUNG: when testing, never re-use widget names, otherwise the tests
+may fail as the namespace will remember the names between tests.
+'''
+
+
+class KNSpaceTestCase(unittest.TestCase):
+
+    def test_not_exists(self):
+        from kivy.uix.behaviors.knspace import knspace
+        self.assertRaises(AttributeError, lambda: knspace.label)
+
+    def test_not_exists_property(self):
+        from kivy.uix.behaviors.knspace import knspace
+        self.assertRaises(AttributeError, lambda: knspace.label2)
+        knspace.property('label2')
+        self.assertIsNone(knspace.label2)
+
+    def test_allow_none(self):
+        from kivy.uix.behaviors.knspace import knspace, KNSpaceBehavior
+        from kivy.uix.widget import Widget
+
+        class MyWidget(KNSpaceBehavior, Widget):
+            pass
+        knspace.label3 = 1
+        knspace.label3 = None
+        w = MyWidget()
+        w.knspace = knspace
+        w.knspace = None
+
+    def test_name(self):
+        from kivy.uix.behaviors.knspace import knspace, KNSpaceBehavior
+        from kivy.uix.widget import Widget
+
+        class MyWidget(KNSpaceBehavior, Widget):
+            pass
+        w = MyWidget()
+        w.knsname = 'label4'
+        w.knsname = ''
+
+    def test_proxy_ref(self):
+        from kivy.uix.behaviors.knspace import knspace
+        from kivy.uix.widget import Widget
+
+        w = Widget()
+        knspace.widget1 = w
+        self.assertIs(w.proxy_ref, knspace.widget1)
+        knspace.widget1 = 55
+        self.assertIs(55, knspace.widget1)
+
+    def test_constructor(self):
+        from kivy.uix.behaviors.knspace import knspace, KNSpaceBehavior
+        from kivy.uix.widget import Widget
+
+        class MyWidget(KNSpaceBehavior, Widget):
+            pass
+
+        w = MyWidget(knsname='construct_name')
+        self.assertEqual(knspace.construct_name, w)
+
+    def test_re_assign(self):
+        from kivy.uix.behaviors.knspace import knspace, KNSpaceBehavior
+        from kivy.uix.widget import Widget
+
+        class MyWidget(KNSpaceBehavior, Widget):
+            pass
+
+        w = MyWidget(knsname='construct_name2')
+        self.assertEqual(knspace.construct_name2, w)
+        w2 = MyWidget(knsname='construct_name2')
+        self.assertEqual(knspace.construct_name2, w2)
+
+    def test_simple(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace
+
+        w = Builder.load_string('''
+<NamedLabel@KNSpaceBehavior+Label>
+
+NamedLabel:
+    knsname: 'label5'
+    text: 'Hello'
+''')
+        self.assertEqual(knspace.label5, w)
+        self.assertIs(w, knspace.label5.__self__)
+        self.assertIsNot(w, knspace.label5)
+        self.assertEqual('Hello', knspace.label5.text)
+        w.text = 'Goodbye'
+        self.assertEqual('Goodbye', knspace.label5.text)
+
+    def test_simple_multiple_names(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace
+
+        w = Builder.load_string('''
+<NamedLabel@KNSpaceBehavior+Label>
+
+BoxLayout:
+    NamedLabel:
+        knsname: 'label61'
+        text: 'Hello'
+    NamedLabel:
+        knsname: 'label62'
+        text: 'Goodbye'
+''')
+        self.assertEqual('Hello', knspace.label61.text)
+        self.assertEqual('Goodbye', knspace.label62.text)
+
+    def test_simple_binding(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace
+
+        w = Builder.load_string('''
+#:import knspace kivy.uix.behaviors.knspace.knspace
+<NamedLabel@KNSpaceBehavior+Label>
+
+BoxLayout:
+    text: knspace.label7.text if knspace.label7 else ''
+    NamedLabel:
+        knsname: 'label7'
+        text: 'Hello'
+''')
+        self.assertEqual('Hello', w.text)
+        knspace.label7.text = 'Goodbye'
+        self.assertEqual('Goodbye', w.text)
+
+    def test_simple_name_change(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace
+
+        w = Builder.load_string('''
+<NamedLabel@KNSpaceBehavior+Label>
+
+NamedLabel:
+    knsname: 'label8'
+    text: 'Hello'
+''')
+        self.assertEqual(w, knspace.label8)
+        w.knsname = 'named_label8'
+        self.assertIsNone(knspace.label8)
+        self.assertEqual(w, knspace.named_label8)
+
+    def test_fork_string(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace
+
+        w = Builder.load_string('''
+<NamedLabel@KNSpaceBehavior+Label>
+
+BoxLayout:
+    NamedLabel:
+        knspace: 'fork'
+        knsname: 'label9'
+        text: 'Hello'
+    NamedLabel:
+        knspace: 'fork'
+        knsname: 'label9'
+        text: 'Goodbye'
+''')
+        self.assertEqual(w.children[0].knspace.label9.text, 'Goodbye')
+        self.assertEqual(w.children[1].knspace.label9.text, 'Hello')
+
+    def test_fork(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace, KNSpaceBehavior
+        from kivy.uix.widget import Widget
+
+        class NamedWidget(KNSpaceBehavior, Widget):
+            pass
+        nw = NamedWidget()
+        w = Widget()
+        w2 = Widget()
+
+        before = knspace.fork()
+        knspace.widget2 = w
+        after = knspace.fork()
+        self.assertEqual(knspace.widget2, w)
+        self.assertEqual(before.widget2, w)
+        self.assertEqual(after.widget2, w)
+
+        child = knspace.fork()
+        child2 = knspace.fork()
+        grandchild = child.fork()
+        child.widget3 = w2
+        self.assertEqual(grandchild.widget3, w2)
+        self.assertEqual(child.widget3, w2)
+        # this could actually be none rather than raising, depending
+        # on when the class was instantiated. So if this fails, change the
+        # test to assert is none.
+        self.assertIsNone(knspace.widget3)
+        grandchild.parent = child2
+        self.assertIsNone(grandchild.widget3)
+
+    def test_fork_binding(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace
+
+        w = Builder.load_string('''
+<NamedLabel@KNSpaceBehavior+Label>
+
+<MyComplexWidget@NamedLabel>:
+    knsname: 'root_label'
+    text: 'Hello'
+    NamedLabel:
+        id: child
+        knsname: 'child_label'
+        text: self.knspace.root_label.text if self.knspace.root_label else ''
+
+BoxLayout:
+    MyComplexWidget:
+        knspace: 'fork'
+        id: first
+    MyComplexWidget:
+        knspace: 'fork'
+        id: second
+''')
+        self.assertEqual(w.ids.first.ids.child.text, 'Hello')
+        self.assertEqual(w.ids.second.ids.child.text, 'Hello')
+        self.assertEqual(w.ids.first.knspace.child_label.text, 'Hello')
+        self.assertEqual(w.ids.second.knspace.child_label.text, 'Hello')
+
+        w.ids.first.text = 'Goodbye'
+        self.assertEqual(w.ids.first.ids.child.text, 'Goodbye')
+        self.assertEqual(w.ids.second.ids.child.text, 'Hello')
+        self.assertEqual(w.ids.first.knspace.child_label.text, 'Goodbye')
+        self.assertEqual(w.ids.second.knspace.child_label.text, 'Hello')
+
+        first = w.ids.first.knspace
+        w.ids.first.knspace = w.ids.second.knspace
+        w.ids.second.knspace = first
+        self.assertEqual(w.ids.first.ids.child.text, 'Goodbye')
+        self.assertEqual(w.ids.second.ids.child.text, 'Hello')
+        self.assertEqual(w.ids.first.knspace.child_label.text, 'Goodbye')
+        self.assertEqual(w.ids.second.knspace.child_label.text, 'Hello')
+
+        w.ids.first.text = 'Goodbye2'
+        self.assertEqual(w.ids.first.ids.child.text, 'Goodbye2')
+        self.assertEqual(w.ids.second.ids.child.text, 'Hello')
+        self.assertEqual(w.ids.first.knspace.child_label.text, 'Goodbye2')
+        self.assertEqual(w.ids.second.knspace.child_label.text, 'Hello')
+
+        w.ids.first.knspace.root_label.text = 'Goodbye3'
+        self.assertEqual(w.ids.first.ids.child.text, 'Goodbye3')
+        self.assertEqual(w.ids.second.ids.child.text, 'Hello')
+        self.assertEqual(w.ids.first.knspace.child_label.text, 'Goodbye3')
+        self.assertEqual(w.ids.second.knspace.child_label.text, 'Hello')