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

kivy/tests/test_benchmark.py

@@ -0,0 +1,292 @@
+import pytest
+from string import ascii_letters
+from random import randint
+import gc
+
+import sys
+
+
+@pytest.fixture
+def kivy_benchmark(benchmark, kivy_clock):
+    from kivy.core.window import Window
+    from kivy.cache import Cache
+    from kivy.utils import platform
+    import kivy
+    from kivy.core.gl import glGetString, GL_VENDOR, GL_RENDERER, GL_VERSION
+    from kivy.context import Context
+    from kivy.clock import ClockBase
+    from kivy.factory import FactoryBase, Factory
+    from kivy.lang.builder import BuilderBase, Builder
+
+    context = Context(init=False)
+    context['Clock'] = ClockBase()
+    context['Factory'] = FactoryBase.create_from(Factory)
+    context['Builder'] = BuilderBase.create_from(Builder)
+
+    for category in list(Cache._objects.keys()):
+        if category not in Cache._categories:
+            continue
+
+        for key in list(Cache._objects[category].keys()):
+            Cache.remove(category, key)
+
+    gc.collect()
+
+    benchmark.extra_info['platform'] = str(sys.platform)
+    benchmark.extra_info['python_version'] = str(sys.version)
+    benchmark.extra_info['python_api'] = str(sys.api_version)
+    benchmark.extra_info['kivy_platform'] = platform
+    benchmark.extra_info['kivy_version'] = kivy.__version__
+    benchmark.extra_info['gl_vendor'] = str(glGetString(GL_VENDOR))
+    benchmark.extra_info['gl_renderer'] = str(glGetString(GL_RENDERER))
+    benchmark.extra_info['gl_version'] = str(glGetString(GL_VERSION))
+
+    context.push()
+    try:
+        yield benchmark
+    finally:
+        context.pop()
+
+
+def test_event_dispatcher_creation(kivy_benchmark):
+    from kivy.event import EventDispatcher
+
+    class Event(EventDispatcher):
+        pass
+    # create one just so we don't incur loading cost
+    e = Event()
+    kivy_benchmark(Event)
+
+
+def test_widget_creation(kivy_benchmark):
+    from kivy.uix.widget import Widget
+    # create one just so we don't incur loading cost
+    w = Widget()
+    kivy_benchmark(Widget)
+
+
+def test_kv_widget_creation(kivy_benchmark):
+    from kivy.lang import Builder
+    from kivy.uix.widget import Widget
+
+    class MyWidget(Widget):
+        pass
+
+    Builder.load_string("""
+<MyWidget>:
+    width: 55
+    height: 37
+    x: self.width + 5
+    y: self.height + 32
+""")
+
+    # create one just so we don't incur loading cost
+    w = MyWidget()
+    kivy_benchmark(MyWidget)
+
+
+@pytest.mark.parametrize('test_component', ['create', 'set'])
+def test_complex_kv_widget(kivy_benchmark, test_component):
+    from kivy.lang import Builder
+    from kivy.uix.widget import Widget
+
+    class MyWidget(Widget):
+        pass
+
+    Builder.load_string("""
+<MyWidget>:
+    width: 1
+    height: '{}dp'.format(self.width + 1)
+    x: self.height + 1
+    y: self.x + 1
+    size_hint_min: self.size_hint
+    size_hint_max_y: self.size_hint_min_y
+    size_hint_max_x: self.size_hint_min_x
+    opacity: sum(self.size_hint_min) + sum(self.size_hint_max)
+""")
+
+    # create one just so we don't incur loading cost
+    widget = MyWidget()
+    w = 0
+    sh = 0
+
+    def set_value():
+        nonlocal w, sh
+        w += 1
+        sh += 1
+        widget.width = w
+        widget.size_hint = sh, sh
+
+    if test_component == 'create':
+        kivy_benchmark(MyWidget)
+    else:
+        kivy_benchmark(set_value)
+
+
+def get_event_class(name, args, kwargs):
+    from kivy.event import EventDispatcher
+    import kivy.properties
+    from kivy.properties import BooleanProperty, ReferenceListProperty, \
+        AliasProperty
+
+    if name == 'AliasProperty':
+        class Event(EventDispatcher):
+            def get_a(self):
+                return 0
+
+            def set_a(self, value):
+                pass
+            a = AliasProperty(get_a, set_a)
+
+    elif name == 'ReferenceListProperty':
+        class Event(EventDispatcher):
+
+            a1 = BooleanProperty(0)
+            a2 = BooleanProperty(0)
+            a = ReferenceListProperty(a1, a2)
+
+    else:
+        cls = getattr(kivy.properties, name)
+
+        class Event(EventDispatcher):
+
+            a = cls(*args, **kwargs)
+
+    return Event
+
+
+@pytest.mark.parametrize('name,args,kwargs', [
+    ('NumericProperty', (0,), {}),
+    ('ObjectProperty', (None,), {}),
+    ('VariableListProperty', ([0, 0, 0, 0],), {}),
+    ('BoundedNumericProperty', (1, ), {'min': 0, 'max': 2}),
+    ('DictProperty', ({}, ), {}),
+    ('ColorProperty', ([1, 1, 1, 1],), {}),
+    ('BooleanProperty', (False,), {}),
+    ('OptionProperty', ('a',), {'options': ['a', 'b']}),
+    ('StringProperty', ('',), {}),
+    ('ListProperty', ([],), {}),
+    ('AliasProperty', (), {}),
+    ('ReferenceListProperty', (), {}),
+])
+def test_property_creation(kivy_benchmark, name, args, kwargs):
+    event_cls = get_event_class(name, args, kwargs)
+
+    # create one just so we don't incur loading cost
+    e = event_cls()
+    kivy_benchmark(event_cls)
+
+
+@pytest.mark.parametrize('name,args,kwargs,val,reset_val', [
+    ('NumericProperty', (0,), {}, 10, 0),
+    ('NumericProperty', (0,), {}, '10dp', 0),
+    ('NumericProperty', (0,), {}, [10, 'dp'], 0),
+    ('ObjectProperty', (None,), {}, 5, 0),
+    ('VariableListProperty', ([0, 0, 0, 0],), {}, [2, 4], [0]),
+    ('BoundedNumericProperty', (1, ), {'min': 0, 'max': 2}, .5, 1),
+    ('DictProperty', ({}, ), {}, {'name': 1}, {}),
+    ('ColorProperty', ([1, 1, 1, 1],), {}, 'red', [1, 1, 1, 1]),
+    ('BooleanProperty', (False,), {}, True, False),
+    ('OptionProperty', ('a',), {'options': ['a', 'b']}, 'b', 'a'),
+    ('StringProperty', ('',), {}, 'a', ''),
+    ('ListProperty', ([],), {}, [1, 2], []),
+    ('AliasProperty', (0,), {}, 1, 0),
+    ('ReferenceListProperty', ((1, 2),), {}, (3, 4), (1, 2)),
+])
+@pytest.mark.parametrize('exclude_first', [True, False])
+def test_property_set(
+        kivy_benchmark, name, args, kwargs, val, reset_val, exclude_first):
+    event_cls = get_event_class(name, args, kwargs)
+
+    # create one just so we don't incur loading cost
+    e = event_cls()
+
+    def set_property():
+        e.a = reset_val
+        e.a = val
+
+    if exclude_first:
+        set_property()
+    kivy_benchmark(set_property)
+
+
+@pytest.mark.parametrize('n', [1, 10, 100, 1_000])
+def test_widget_empty_draw(kivy_benchmark, n):
+    from kivy.graphics import RenderContext
+    from kivy.uix.widget import Widget
+    ctx = RenderContext()
+    root = Widget()
+    for x in range(n):
+        root.add_widget(Widget())
+    ctx.add(root.canvas)
+
+    kivy_benchmark(ctx.draw)
+
+
+@pytest.mark.parametrize('n', [1, 10, 100, 1_000])
+def test_widget_dispatch_touch(kivy_benchmark, n):
+    from kivy.tests.common import UnitTestTouch
+    from kivy.uix.widget import Widget
+
+    root = Widget()
+    for x in range(10):
+        parent = Widget()
+        for y in range(n):
+            parent.add_widget(Widget())
+        root.add_widget(parent)
+
+    touch = UnitTestTouch(10, 10)
+
+    def dispatch():
+        root.dispatch('on_touch_down', touch)
+        root.dispatch('on_touch_move', touch)
+        root.dispatch('on_touch_up', touch)
+
+    kivy_benchmark(dispatch)
+
+
+@pytest.mark.parametrize('n', [1, 10, 100, 1_000])
+@pytest.mark.parametrize('name', ['label', 'button'])
+@pytest.mark.parametrize('tick', ['tick', 'no_tick'])
+def test_random_label_create(kivy_benchmark, n, name, tick):
+    from kivy.clock import Clock
+    from kivy.uix.label import Label
+    from kivy.uix.button import Button
+    label = Label(text='*&^%')
+    button = Button(text='*&^%')
+    cls = Label if name == 'label' else Button
+
+    labels = []
+    k = len(ascii_letters)
+    for x in range(n):
+        label = [ascii_letters[randint(0, k - 1)] for _ in range(10)]
+        labels.append(''.join(label))
+
+    def make_labels():
+        o = []
+        for text in labels:
+            o.append(cls(text=text))
+
+        if tick == 'tick':
+            Clock.tick()
+    kivy_benchmark(make_labels)
+
+
+def test_parse_kv(kivy_benchmark):
+    from kivy.lang import Builder
+    suffix = 0
+
+    def parse_kv():
+        nonlocal suffix
+        Builder.load_string(f"""
+<MyWidget{suffix}>:
+    width: 55
+    height: 37
+    x: self.width + 5
+    y: self.height + 32
+""")
+        suffix += 1
+
+    # create one just so we don't incur loading cost
+    parse_kv()
+    kivy_benchmark(parse_kv)

kivy/tests/test_clipboard.py

@@ -0,0 +1,48 @@
+from kivy.tests.common import GraphicUnitTest
+
+
+class ClipboardTestCase(GraphicUnitTest):
+
+    def setUp(self):
+        from kivy.core.clipboard import Clipboard
+        self._clippy = Clipboard
+        clippy_types = Clipboard.get_types()
+        cliptype = clippy_types[0]
+        if 'UTF8_STRING' in clippy_types:
+            cliptype = 'UTF8_STRING'
+        self._cliptype = cliptype
+        super(ClipboardTestCase, self).setUp()
+
+    def test_clipboard_not_dummy(self):
+        clippy = self._clippy
+        if clippy.__class__.__name__ == 'ClipboardDummy':
+            self.fail('Something went wrong "dummy" clipboard is being used')
+
+    def test_clipboard_paste(self):
+        clippy = self._clippy
+        try:
+            clippy.paste()
+        except:
+            self.fail(
+                'Can not get data from clipboard')
+
+    def test_clipboard_copy(self):
+        clippy = self._clippy
+        try:
+            clippy.copy(u"Hello World")
+        except:
+            self.fail(
+                'Can not put data to clipboard')
+
+    def test_clipboard_copy_paste(self):
+        clippy = self._clippy
+        txt1 = u"Hello 1"
+        clippy.copy(txt1)
+        ret = clippy.paste()
+        self.assertEqual(txt1, ret)
+
+    def test_clipboard_copy_paste_with_emoji(self):
+        clippy = self._clippy
+        test_emoji_str = 'kivy 😀 😁 🤣 😃 😄 😅 😆 😉 😊 😋 😎 😍 😘 😗'
+        clippy.copy(test_emoji_str)
+        self.assertEqual(test_emoji_str, clippy.paste())

kivy/tests/test_clock.py

@@ -0,0 +1,292 @@
+'''
+Clock tests
+===========
+'''
+import gc
+import weakref
+import pytest
+
+
+class ClockCounter:
+
+    counter = 0
+
+    def __call__(self, *args, **kwargs):
+        self.counter += 1
+
+
+@pytest.fixture()
+def clock_counter():
+    yield ClockCounter()
+
+
+def test_schedule_once(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter)
+    kivy_clock.tick()
+    assert clock_counter.counter == 1
+
+
+def test_schedule_once_twice(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter)
+    kivy_clock.schedule_once(clock_counter)
+    kivy_clock.tick()
+    assert clock_counter.counter == 2
+
+
+def test_schedule_once_draw_after(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter, 0)
+    kivy_clock.tick_draw()
+    assert clock_counter.counter == 0
+    kivy_clock.tick()
+    assert clock_counter.counter == 1
+
+
+def test_schedule_once_draw_before(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter, -1)
+    kivy_clock.tick_draw()
+    assert clock_counter.counter == 1
+    kivy_clock.tick()
+    assert clock_counter.counter == 1
+
+
+def test_unschedule(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter)
+    kivy_clock.unschedule(clock_counter)
+    kivy_clock.tick()
+    assert clock_counter.counter == 0
+
+
+def test_unschedule_event(kivy_clock, clock_counter):
+    ev = kivy_clock.schedule_once(clock_counter)
+    kivy_clock.unschedule(ev)
+    kivy_clock.tick()
+    assert clock_counter.counter == 0
+
+
+def test_unschedule_after_tick(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter, 5.)
+    kivy_clock.tick()
+    kivy_clock.unschedule(clock_counter)
+    kivy_clock.tick()
+    assert clock_counter.counter == 0
+
+
+def test_unschedule_draw(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter, 0)
+    kivy_clock.tick_draw()
+    assert clock_counter.counter == 0
+    kivy_clock.unschedule(clock_counter)
+    kivy_clock.tick()
+    assert clock_counter.counter == 0
+
+
+def test_trigger_create(kivy_clock, clock_counter):
+    trigger = kivy_clock.create_trigger(clock_counter, 0)
+    trigger()
+    assert clock_counter.counter == 0
+    kivy_clock.tick()
+    assert clock_counter.counter == 1
+
+
+def test_trigger_cancel(kivy_clock, clock_counter):
+    trigger = kivy_clock.create_trigger(clock_counter, 5.)
+    trigger()
+    trigger.cancel()
+    kivy_clock.tick()
+    assert clock_counter.counter == 0
+
+
+def test_trigger_interval(kivy_clock, clock_counter):
+    trigger = kivy_clock.create_trigger(clock_counter, 0, interval=True)
+    trigger()
+    kivy_clock.tick()
+    assert clock_counter.counter == 1
+    kivy_clock.tick()
+    assert clock_counter.counter == 2
+
+
+def test_trigger_decorator(kivy_clock, clock_counter):
+    from kivy.clock import triggered
+
+    @triggered()
+    def triggered_callback():
+        clock_counter(dt=0)
+
+    triggered_callback()
+    assert clock_counter.counter == 0
+    kivy_clock.tick()
+    assert clock_counter.counter == 1
+
+
+def test_trigger_decorator_cancel(kivy_clock, clock_counter):
+    from kivy.clock import triggered
+
+    @triggered()
+    def triggered_callback():
+        clock_counter(dt=0)
+
+    triggered_callback()
+    triggered_callback.cancel()
+    kivy_clock.tick()
+    assert clock_counter.counter == 0
+
+
+def test_exception_caught(kivy_clock, clock_counter):
+    exception = None
+
+    def handle_test_exception(e):
+        nonlocal exception
+        exception = str(e)
+
+    # monkey patch to ignore exception
+    kivy_clock.handle_exception = handle_test_exception
+
+    def raise_exception(*args):
+        raise ValueError('Stooooop')
+
+    kivy_clock.schedule_once(raise_exception)
+    kivy_clock.schedule_once(clock_counter)
+    kivy_clock.tick()
+
+    assert clock_counter.counter == 1
+    assert exception == 'Stooooop'
+
+
+def test_exception_ignored(kivy_clock, clock_counter):
+    def raise_exception(*args):
+        raise ValueError('Stooooop')
+
+    kivy_clock.schedule_once(raise_exception)
+    kivy_clock.schedule_once(clock_counter)
+
+    with pytest.raises(ValueError):
+        kivy_clock.tick()
+
+    assert clock_counter.counter == 0
+
+
+def test_exception_caught_handler(
+        kivy_clock, clock_counter, kivy_exception_manager):
+    from kivy.base import ExceptionHandler
+    exception = None
+
+    class KivyHandler(ExceptionHandler):
+
+        def handle_exception(self, e):
+            nonlocal exception
+            exception = str(e)
+            return kivy_exception_manager.PASS
+    kivy_exception_manager.add_handler(KivyHandler())
+
+    def raise_exception(*args):
+        raise ValueError('Stooooop')
+
+    kivy_clock.schedule_once(raise_exception)
+    kivy_clock.schedule_once(clock_counter)
+    kivy_clock.tick()
+
+    assert clock_counter.counter == 1
+    assert exception == 'Stooooop'
+
+
+def test_clock_ended_callback(kivy_clock, clock_counter):
+    counter2 = ClockCounter()
+    counter_schedule = ClockCounter()
+
+    kivy_clock.schedule_once(counter_schedule)
+    event = kivy_clock.create_lifecycle_aware_trigger(clock_counter, counter2)
+    event()
+
+    kivy_clock.stop_clock()
+    assert counter_schedule.counter == 0
+    assert clock_counter.counter == 0
+    assert counter2.counter == 1
+
+
+def test_clock_ended_del_safe(kivy_clock, clock_counter):
+    counter2 = ClockCounter()
+    kivy_clock.schedule_lifecycle_aware_del_safe(clock_counter, counter2)
+
+    kivy_clock.stop_clock()
+    assert clock_counter.counter == 0
+    assert counter2.counter == 1
+
+
+def test_clock_ended_raises(kivy_clock, clock_counter):
+    from kivy.clock import ClockNotRunningError
+    event = kivy_clock.create_lifecycle_aware_trigger(
+        clock_counter, clock_counter)
+
+    kivy_clock.stop_clock()
+    with pytest.raises(ClockNotRunningError):
+        event()
+    assert clock_counter.counter == 0
+
+    # we should be able to create the event
+    event = kivy_clock.create_lifecycle_aware_trigger(
+        clock_counter, clock_counter)
+    with pytest.raises(ClockNotRunningError):
+        event()
+    assert clock_counter.counter == 0
+
+    kivy_clock.schedule_once(clock_counter)
+    assert clock_counter.counter == 0
+
+
+def test_clock_ended_del_safe_raises(kivy_clock, clock_counter):
+    from kivy.clock import ClockNotRunningError
+    counter2 = ClockCounter()
+
+    kivy_clock.stop_clock()
+    with pytest.raises(ClockNotRunningError):
+        kivy_clock.schedule_lifecycle_aware_del_safe(clock_counter, counter2)
+    assert clock_counter.counter == 0
+
+
+def test_clock_stop_twice(kivy_clock, clock_counter):
+    counter2 = ClockCounter()
+    event = kivy_clock.create_lifecycle_aware_trigger(
+        clock_counter, counter2)
+    event()
+
+    kivy_clock.stop_clock()
+    assert clock_counter.counter == 0
+    assert counter2.counter == 1
+
+    kivy_clock.stop_clock()
+    assert clock_counter.counter == 0
+    assert counter2.counter == 1
+
+
+def test_clock_restart(kivy_clock):
+    kivy_clock.stop_clock()
+    # with pytest.raises(TypeError):
+    #     kivy_clock.start_clock()
+    # for now it doesn't yet raise a error
+    kivy_clock.start_clock()
+
+
+def test_clock_event_trigger_ref(kivy_clock):
+    value = None
+
+    class Counter:
+        def call(self, *args, **kwargs):
+            nonlocal value
+            value = 42
+
+    event = kivy_clock.create_trigger(Counter().call)
+    gc.collect()
+    event()
+    kivy_clock.tick()
+    assert value is None
+
+    kivy_clock.schedule_once(Counter().call)
+    event()
+    kivy_clock.tick()
+    assert value is None
+
+    event = kivy_clock.create_trigger(Counter().call, release_ref=False)
+    gc.collect()
+    event()
+    kivy_clock.tick()
+    assert value == 42

kivy/tests/test_compat.py

@@ -0,0 +1,6 @@
+from kivy.compat import isclose
+
+
+def test_isclose():
+    assert isclose(1.1, 1.1), 'Close floats should assert True'
+    assert not isclose(1.1, 2.1), 'Close floats should assert True'

kivy/tests/test_config.py

@@ -0,0 +1,35 @@
+"""This module houses test for the kivy config module."""
+from kivy.config import ConfigParser
+from os.path import join, dirname
+
+SAMPLE_CONFIG = join(dirname(__file__), 'data', 'test.ini')
+
+
+def test_configparser_callbacks():
+    """Test that the ConfigParser handles callbacks."""
+    def callback():
+        pass
+
+    config = ConfigParser()
+    assert len(config._callbacks) == 0
+
+    config.add_callback(callback, 'section', 'key')
+    assert len(config._callbacks) == 1
+
+    config.remove_callback(callback, 'section', 'key')
+    assert len(config._callbacks) == 0
+
+
+def test_configparser_read():
+    """Test that the ConfigParser can read a config file."""
+    config = ConfigParser()
+    config.read(SAMPLE_CONFIG)
+    assert config.get('section', 'key') == 'value'
+
+
+def test_configparser_setdefaults():
+    """Test the setdefaults method works as expected."""
+    config = ConfigParser()
+    config.setdefaults('section', {'test': '1'})
+
+    assert config.get('section', 'test') == '1'