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

kivy/tests/test_resources.py

@@ -0,0 +1,79 @@
+"""
+Resource loading tests
+======================
+"""
+import pytest
+import tempfile
+import os
+from unittest.mock import patch
+from kivy.cache import Cache
+from kivy.clock import Clock
+from kivy.resources import resource_find, resource_add_path
+
+
+@pytest.fixture
+def test_file():
+    return "uix/textinput.py"
+
+
+RESOURCE_CACHE = "kv.resourcefind"
+
+
+def test_load_resource_cached(test_file):
+    Cache.remove(RESOURCE_CACHE)
+    found_file = resource_find(test_file)
+    assert found_file is not None
+    cached_filename = Cache.get(RESOURCE_CACHE, test_file)
+    assert found_file == cached_filename
+
+
+def test_load_resource_not_cached(test_file):
+    Cache.remove(RESOURCE_CACHE)
+    found_file = resource_find(test_file, use_cache=False)
+    assert found_file is not None
+    cached_filename = Cache.get(RESOURCE_CACHE, test_file)
+    assert cached_filename is None
+
+
+def test_load_resource_not_found():
+    Cache.remove(RESOURCE_CACHE)
+    missing_file_name = "missing_test_file.foo"
+
+    find_missing_file = resource_find(missing_file_name)
+    assert find_missing_file is None
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        missing_file_path = os.path.join(temp_dir, missing_file_name)
+
+        with open(missing_file_path, "w"):
+            pass  # touch file
+
+        find_missing_file_again = resource_find(missing_file_name)
+        assert find_missing_file_again is None
+
+        cached_filename = Cache.get(RESOURCE_CACHE, missing_file_name)
+        assert cached_filename is None
+
+        resource_add_path(temp_dir)
+
+        found_file = resource_find(missing_file_name)
+        assert missing_file_path == found_file
+        assert missing_file_path == Cache.get(RESOURCE_CACHE, missing_file_name)
+
+
+def test_timestamp_and_lastaccess(test_file):
+    Cache.remove(RESOURCE_CACHE)
+    start = Clock.get_time()
+
+    resource_find(test_file)
+    ts = Cache.get_timestamp(RESOURCE_CACHE, test_file)
+    last_access = Cache.get_lastaccess(RESOURCE_CACHE, test_file)
+
+    assert ts >= start, 'Last timestamp not accurate.'
+    assert last_access >= start, 'Last access time is not accurate.'
+
+
+def test_print_usage():
+    with patch('kivy.cache.print') as mock_print:
+        Cache.print_usage()
+        mock_print.assert_called()

kivy/tests/test_rst_replace.py

@@ -0,0 +1,63 @@
+# coding=utf-8
+import unittest
+from kivy.tests.common import GraphicUnitTest
+
+
+def _build_rst():
+    from kivy.uix.rst import RstDocument
+
+    class _TestRstReplace(RstDocument):
+        def __init__(self, **kwargs):
+            super(_TestRstReplace, self).__init__(**kwargs)
+            self.text = '''
+    .. |uni| unicode:: 0xe4
+    .. |nbsp| unicode:: 0xA0
+    .. |text| replace:: is
+    .. |hop| replace:: replaced
+    .. _hop: https://kivy.org
+
+    |uni| |nbsp| |text| |hop|_
+    '''
+
+    return _TestRstReplace()
+
+
+class RstSubstitutionTestCase(GraphicUnitTest):
+    # XXX Mathieu - i tried to fix the window context to prevent segfault here
+    # but nothing actually works. Works alone, but not after a window restart.
+    # On linux:
+    #    # 1  0x00007ffff12807e9 in  () at /usr/lib/libnvidia-glcore.so.418.43
+    #    # 2  0x00007ffff1288554 in  () at /usr/lib/libnvidia-glcore.so.418.43
+    #    # 3  0x00007ffff0e2e3db in  () at /usr/lib/libnvidia-glcore.so.418.43
+    #    # 4  0x00007ffff5d5ae15 in __pyx_f_4kivy_8graphics_3vbo_11VertexBatch_draw  # noqa
+    #         (__pyx_v_self=0x7fffed641390) at kivy/graphics/vbo.c:6529
+    # On OSX:
+    #  * thread #1, queue = 'com.apple.main-thread',
+    #     stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
+    #  * frame #0: 0x00007fff555d9d42 GLEngine`gleRunVertexSubmitImmediate + 1234  # noqa
+    #    frame #1: 0x00007fff554c1544 GLEngine`glDrawElements_Exec + 563
+    #    frame #2: 0x000000010429d273 vbo.cpython-36m-darwin.so
+    #    `__pyx_f_4kivy_8graphics_3vbo_11VertexBatch_draw(
+    #    __pyx_v_self=0x000000010cf344f8) at vbo.c:6575 [opt]
+    @unittest.skip("Currently segfault, but no idea why.")
+    def test_rst_replace(self):
+        rst = _build_rst()
+        self.render(rst)
+
+        # RstDocument > Scatter > GridLayout > RstParagraph
+        pg = rst.children[0].children[0].children[0]
+        rendered_text = pg.text[:]
+
+        # [anchor=] and [ref=] might change in the future
+        compare_text = (
+            u'[color=202020ff][anchor=hop]'
+            u'\xe4 \xA0 is '
+            u'[ref=None][color=ce5c00ff]replaced[/color][/ref]'
+            u'[/color]'
+        )
+        self.assertEqual(rendered_text, compare_text)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()

kivy/tests/test_screen.py

@@ -0,0 +1,38 @@
+import pytest
+
+transition_cls_names = (
+    'ShaderTransition', 'SlideTransition', 'SwapTransition', 'FadeTransition',
+    'WipeTransition', 'FallOutTransition', 'RiseInTransition', 'NoTransition',
+    'CardTransition',
+)
+
+
+def test_switch_to():
+    import kivy.uix.screenmanager as sm
+    manager = sm.ScreenManager()
+    screen1 = sm.Screen(name='first')
+    screen2 = sm.Screen(name='second')
+    manager.switch_to(screen1)
+    manager.switch_to(screen2)
+    manager.switch_to(screen1)
+    manager.switch_to(screen2)
+    manager.current = 'first'
+    manager.switch_to(screen1)
+    manager.current = 'second'
+    manager.switch_to(screen2)
+
+
+@pytest.mark.parametrize('transition_cls_name', transition_cls_names)
+def test_switching_does_not_affect_a_list_of_screens(transition_cls_name):
+    import kivy.uix.screenmanager as sm
+    transition_cls = getattr(sm, transition_cls_name)
+    scrmgr = sm.ScreenManager()
+    for i in range(3):
+        scrmgr.add_widget(sm.Screen(name=str(i)))
+    names = list(scrmgr.screen_names)
+    scrmgr.transition = transition_cls()
+    scrmgr.current = '1'
+    assert names == scrmgr.screen_names
+    scrmgr.transition = transition_cls()
+    scrmgr.current = '2'
+    assert names == scrmgr.screen_names

kivy/tests/test_storage.py

@@ -0,0 +1,135 @@
+'''
+Storage tests
+=============
+'''
+
+import unittest
+from os.path import abspath, dirname, join
+import errno
+import os
+
+
+class StorageTestCase(unittest.TestCase):
+    def test_dict_storage(self):
+        from kivy.storage.dictstore import DictStore
+        from tempfile import mkstemp
+        from os import unlink, close
+
+        try:
+            tmpfd, tmpfn = mkstemp('.dict')
+            close(tmpfd)
+
+            self._do_store_test_empty(DictStore(tmpfn))
+            self._do_store_test_filled(DictStore(tmpfn))
+        finally:
+            unlink(tmpfn)
+
+    def test_dict_storage_nofolder(self):
+        from kivy.storage.dictstore import DictStore
+        self._do_store_test_nofolder(DictStore)
+
+    def test_json_storage_nofolder(self):
+        from kivy.storage.jsonstore import JsonStore
+        self._do_store_test_nofolder(JsonStore)
+
+    def test_json_storage(self):
+        from kivy.storage.jsonstore import JsonStore
+        from tempfile import mkstemp
+        from os import unlink, close
+
+        try:
+            tmpfd, tmpfn = mkstemp('.json')
+            close(tmpfd)
+            self._do_store_test_empty(JsonStore(tmpfn))
+            self._do_store_test_filled(JsonStore(tmpfn))
+        finally:
+            unlink(tmpfn)
+
+        try:
+            tmpfd, tmpfn = mkstemp('.json')
+            close(tmpfd)
+            self._do_store_test_empty(JsonStore(tmpfn, indent=2))
+            self._do_store_test_filled(JsonStore(tmpfn, indent=2))
+        finally:
+            unlink(tmpfn)
+
+        try:
+            tmpfd, tmpfn = mkstemp('.json')
+            close(tmpfd)
+            self._do_store_test_empty(JsonStore(tmpfn, sort_keys=True))
+            self._do_store_test_filled(JsonStore(tmpfn, sort_keys=True))
+        finally:
+            unlink(tmpfn)
+
+    def test_redis_storage(self):
+        if os.environ.get('NONETWORK'):
+            return
+        try:
+            from kivy.storage.redisstore import RedisStore
+            from redis.exceptions import ConnectionError
+            try:
+                params = dict(db=15)
+                self._do_store_test_empty(RedisStore(params))
+                self._do_store_test_filled(RedisStore(params))
+            except ConnectionError:
+                pass
+        except ImportError:
+            pass
+
+    def _do_store_test_empty(self, store):
+        store.clear()
+        self.assertTrue(store.count() == 0)
+        self.assertFalse(store.exists('plop'))
+        self.assertRaises(KeyError, lambda: store.get('plop'))
+        self.assertTrue(store.put('plop', name='Hello', age=30))
+        self.assertTrue(store.exists('plop'))
+        self.assertTrue(store.get('plop').get('name') == 'Hello')
+        self.assertTrue(store.get('plop').get('age') == 30)
+        self.assertTrue(store.count() == 1)
+        self.assertTrue('plop' in store.keys())
+
+        # test queries
+        store.put('key1', name='Name1', attr1='Common')
+        store.put('key2', name='Name2', attr1='Common', attr2='bleh')
+        store.put('key3', name='Name3', attr1='Common', attr2='bleh')
+        self.assertTrue(store.count() == 4)
+        self.assertTrue(store.exists('key1'))
+        self.assertTrue(store.exists('key2'))
+        self.assertTrue(store.exists('key3'))
+
+        self.assertTrue(len(list(store.find(name='Name2'))) == 1)
+        self.assertTrue(list(store.find(name='Name2'))[0][0] == 'key2')
+        self.assertTrue(len(list(store.find(attr1='Common'))) == 3)
+        self.assertTrue(len(list(store.find(attr2='bleh'))) == 2)
+        self.assertTrue(
+            len(list(store.find(attr1='Common', attr2='bleh'))) == 2)
+        self.assertTrue(len(list(store.find(name='Name2', attr2='bleh'))) == 1)
+        self.assertTrue(len(list(store.find(name='Name1', attr2='bleh'))) == 0)
+
+    def _do_store_test_filled(self, store):
+        self.assertTrue(store.count() == 4)
+        self.assertRaises(KeyError, lambda: store.get('plop2'))
+        self.assertRaises(KeyError, lambda: store.delete('plop2'))
+        self.assertTrue(store.exists('plop'))
+        self.assertTrue(store.get('plop').get('name') == 'Hello')
+        self.assertTrue(store.put('plop', name='World', age=1))
+        self.assertTrue(store.get('plop').get('name') == 'World')
+        self.assertTrue(store.exists('plop'))
+        self.assertTrue(store.delete('plop'))
+        self.assertRaises(KeyError, lambda: store.delete('plop'))
+        self.assertRaises(KeyError, lambda: store.get('plop'))
+
+    def _do_store_test_nofolder(self, store_cls):
+        ext = store_cls.__name__.lower()[:4]
+        path = join(
+            dirname(abspath(__file__)),
+            '__i_dont_exist__',
+            'test.' + ext
+        )
+        with self.assertRaises(IOError) as context:
+            store = store_cls(path)
+        self.assertEqual(context.exception.errno, errno.ENOENT)
+
+
+if __name__ == '__main__':
+    unittest.main()

kivy/tests/test_uix_actionbar.py

@@ -0,0 +1,363 @@
+from kivy.tests.common import GraphicUnitTest, UTMotionEvent
+
+from kivy.lang import Builder
+from kivy.base import EventLoop
+from kivy.weakproxy import WeakProxy
+from time import sleep
+
+DropDown = None
+
+
+KV = '''
+# +/- copied from ActionBar example + edited for the test
+FloatLayout:
+    ActionBar:
+        pos_hint: {'top': 1}
+        ActionView:
+            use_separator: True
+            ActionPrevious:
+                title: 'Action Bar'
+                with_previous: False
+            ActionOverflow:
+            ActionButton:
+                text: 'Btn0'
+                icon: 'atlas://data/images/defaulttheme/audio-volume-high'
+            ActionButton:
+                text: 'Btn1'
+            ActionButton:
+                text: 'Btn2'
+            ActionGroup:
+                id: group1
+                text: 'group 1'
+                ActionButton:
+                    id: group1button
+                    text: 'Btn3'
+                    on_release:
+                        setattr(root, 'g1button', True)
+                ActionButton:
+                    text: 'Btn4'
+            ActionGroup:
+                id: group2
+                dropdown_width: 200
+                text: 'group 2'
+                ActionButton:
+                    id: group2button
+                    text: 'Btn5'
+                    on_release:
+                        setattr(root, 'g2button', True)
+                ActionButton:
+                    text: 'Btn6'
+                ActionButton:
+                    text: 'Btn7'
+'''
+
+
+class TouchPoint(UTMotionEvent):
+    def __init__(self, raw_x, raw_y):
+        win = EventLoop.window
+        super().__init__(
+            "unittest", 1, {
+                "x": raw_x / float(win.width),
+                "y": raw_y / float(win.height),
+            }
+        )
+        # press & release
+        EventLoop.post_dispatch_input("begin", self)
+        EventLoop.post_dispatch_input("end", self)
+        EventLoop.idle()
+
+
+class ActionBarTestCase(GraphicUnitTest):
+    framecount = 0
+
+    def setUp(self):
+        global DropDown
+        from kivy.uix.dropdown import DropDown
+
+        # kill KV lang logging (too long test)
+        import kivy.lang.builder as builder
+
+        if not hasattr(self, '_trace'):
+            self._trace = builder.trace
+
+        self.builder = builder
+        builder.trace = lambda *_, **__: None
+        super(ActionBarTestCase, self).setUp()
+
+    def tearDown(self, *args, **kwargs):
+        # add the logging back
+        import kivy.lang.builder as builder
+        builder.trace = self._trace
+        super(ActionBarTestCase, self).tearDown(*args, **kwargs)
+
+    def move_frames(self, t):
+        for i in range(t):
+            EventLoop.idle()
+
+    def clean_garbage(self, *args):
+        for child in self._win.children[:]:
+            self._win.remove_widget(child)
+        self.move_frames(5)
+
+    def check_dropdown(self, present=True):
+        any_list = [
+            isinstance(child, DropDown)
+            for child in self._win.children
+        ]
+
+        # mustn't allow more than one DropDown opened!
+        self.assertLess(sum(any_list), 2)
+
+        # passed
+        if not present and not any(any_list):
+            return
+        elif present and any(any_list):
+            return
+
+        print('DropDown either missing, or isn\'t supposed to be there')
+        self.assertTrue(False)
+
+    def test_1_openclose(self, *args):
+        # click on Group 2 to open its DropDown
+        # - DropDown shows up
+        # then click away
+        # - Group 2 DropDown disappears
+        # click on Group 1 to open its DropDown
+        # - DropDown shows up
+        # then click away
+        # - Group 1 DropDown disappears
+        self._win = EventLoop.window
+        self.clean_garbage()
+        root = Builder.load_string(KV)
+        self.render(root)
+        self.assertLess(len(self._win.children), 2)
+        group2 = root.ids.group2
+        group1 = root.ids.group1
+        self.move_frames(5)
+
+        # no DropDown present yet
+        self.check_dropdown(present=False)
+        self.assertFalse(group2.is_open)
+        self.assertFalse(group1.is_open)
+
+        items = ((group2, group1), (group1, group2))
+        for item in items:
+            active, passive = item
+            # click on active Group
+            TouchPoint(*active.center)
+
+            # active Group DropDown shows up
+            self.check_dropdown(present=True)
+            gdd = WeakProxy(self._win.children[0])
+
+            # active Group DropDown == value in WeakProxy
+            self.assertIn(gdd, self._win.children)
+            self.assertEqual(gdd, self._win.children[0])
+            self.assertTrue(active.is_open)
+            self.assertFalse(passive.is_open)
+
+            # click away
+            TouchPoint(0, 0)
+
+            # wait for closed Group DropDown to disappear
+            # go to the next frame after the DropDown disappeared
+            sleep(gdd.min_state_time)
+            self.move_frames(1)
+
+            # no DropDown is open
+            self.assertNotEqual(gdd, self._win.children[0])
+            self.assertLess(len(self._win.children), 2)
+            self.check_dropdown(present=False)
+            self.assertFalse(active.is_open)
+            self.assertFalse(passive.is_open)
+        self._win.remove_widget(root)
+
+    def test_2_switch(self, *args):
+        # click on Group 2 to open its DropDown
+        # - DropDown shows up
+        # then click on Group 1 to open its DropDown
+        # - Group 2 DropDown disappears, Group 1 DropDown shows up
+        # click away
+        # - no DropDown is opened
+        self._win = EventLoop.window
+        self.clean_garbage()
+        root = Builder.load_string(KV)
+        self.render(root)
+        self.assertLess(len(self._win.children), 2)
+        group2 = root.ids.group2
+        group1 = root.ids.group1
+        self.move_frames(5)
+
+        # no DropDown present yet
+        self.check_dropdown(present=False)
+        self.assertFalse(group2.is_open)
+        self.assertFalse(group1.is_open)
+
+        # click on Group 2
+        TouchPoint(*group2.center)
+
+        # Group 2 DropDown shows up
+        self.check_dropdown(present=True)
+        g2dd = WeakProxy(self._win.children[0])
+
+        # Group 2 DropDown == value in WeakProxy
+        self.assertIn(g2dd, self._win.children)
+        self.assertEqual(g2dd, self._win.children[0])
+        self.assertTrue(group2.is_open)
+        self.assertFalse(group1.is_open)
+
+        # click away from ActionBar and wait for it to disappear
+        TouchPoint(0, 0)
+        sleep(g2dd.min_state_time)
+        self.move_frames(1)
+
+        # click on Group 1
+        TouchPoint(*group1.center)
+
+        # wait for closed Group 2 DropDown to disappear
+        # and for Group 1 DropDown to appear (there are 2 DDs now)
+        # go to the next frame after the DropDown disappeared
+        sleep(g2dd.min_state_time)
+        self.move_frames(1)
+
+        # Group 1 DropDown != value in WeakProxy (Group 2 DD)
+        self.assertNotEqual(g2dd, self._win.children[0])
+        self.assertFalse(group2.is_open)
+        self.assertTrue(group1.is_open)
+        self.check_dropdown(present=True)
+
+        # click away from ActionBar
+        TouchPoint(0, 0)
+
+        # wait for closed Group DropDown to disappear
+        # go to the next frame after the DropDown disappeared
+        sleep(g2dd.min_state_time)
+        self.move_frames(1)
+
+        # no DropDown present in Window
+        self.check_dropdown(present=False)
+        self.assertFalse(group2.is_open)
+        self.assertFalse(group1.is_open)
+        self.assertNotIn(g2dd, self._win.children)
+        self._win.remove_widget(root)
+
+    def test_3_openpress(self, *args):
+        # click on Group 2 to open its DropDown
+        # - DropDown shows up
+        # then click on Group 2 DropDown button
+        # - DropDown disappears
+        # click on Group 1 to open its DropDown
+        # - DropDown shows up
+        # then click on Group 1 DropDown button
+        # - DropDown disappears
+        self._win = EventLoop.window
+        self.clean_garbage()
+        root = Builder.load_string(KV)
+        self.render(root)
+        self.assertLess(len(self._win.children), 2)
+        group2 = root.ids.group2
+        group2button = root.ids.group2button
+        group1 = root.ids.group1
+        group1button = root.ids.group1button
+        self.move_frames(5)
+
+        # no DropDown present yet
+        self.check_dropdown(present=False)
+        self.assertFalse(group2.is_open)
+        self.assertFalse(group1.is_open)
+
+        items = (
+            (group2, group1, group2button),
+            (group1, group2, group1button)
+        )
+        for item in items:
+            active, passive, button = item
+
+            # click on active Group
+            TouchPoint(*active.center)
+
+            # active Group DropDown shows up
+            self.check_dropdown(present=True)
+            gdd = WeakProxy(self._win.children[0])
+
+            # active Group DropDown == value in WeakProxy
+            self.assertIn(gdd, self._win.children)
+            self.assertEqual(gdd, self._win.children[0])
+            self.assertTrue(active.is_open)
+            self.assertFalse(passive.is_open)
+
+            # click on active Group DropDown Button (needed to_window)
+            TouchPoint(*button.to_window(*button.center))
+            self.assertTrue(getattr(
+                root, active.text[0::6] + 'button'
+            ))
+
+            # wait for closed Group DropDown to disappear
+            # go to the next frame after the DropDown disappeared
+            sleep(gdd.min_state_time)
+            self.move_frames(1)
+
+            # no DropDown is open
+            self.assertNotEqual(gdd, self._win.children[0])
+            self.assertLess(len(self._win.children), 2)
+            self.assertFalse(active.is_open)
+            self.assertFalse(passive.is_open)
+            self.check_dropdown(present=False)
+        self._win.remove_widget(root)
+
+    def test_4_openmulti(self, *args):
+        # click on Group to open its DropDown
+        # - DropDown shows up
+        # then click on Group DropDown button
+        # - DropDown disappears
+        # repeat
+        self._win = EventLoop.window
+        self.clean_garbage()
+        root = Builder.load_string(KV)
+        self.render(root)
+        self.assertLess(len(self._win.children), 2)
+        group2 = root.ids.group2
+        group2button = root.ids.group2button
+        group1 = root.ids.group1
+        group1button = root.ids.group1button
+        self.move_frames(5)
+
+        # no DropDown present yet
+        self.check_dropdown(present=False)
+        self.assertFalse(group2.is_open)
+
+        items = ((group2, group2button), (group1, group1button))
+        for item in items:
+            group, button = item
+
+            for _ in range(5):
+                # click on Group
+                TouchPoint(*group.center)
+
+                # Group DropDown shows up
+                self.check_dropdown(present=True)
+                gdd = WeakProxy(self._win.children[0])
+
+                # Group DropDown == value in WeakProxy
+                self.assertIn(gdd, self._win.children)
+                self.assertEqual(gdd, self._win.children[0])
+                self.assertTrue(group.is_open)
+
+                # click on Group DropDown Button
+                TouchPoint(*button.to_window(*button.center))
+
+                # wait for closed Group DropDown to disappear
+                # go to the next frame after the DropDown disappeared
+                sleep(gdd.min_state_time)
+                self.move_frames(1)
+
+                # no DropDown is open
+                self.assertNotEqual(gdd, self._win.children[0])
+                self.assertFalse(group.is_open)
+                self.check_dropdown(present=False)
+        self._win.remove_widget(root)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()