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

kivy/tests/test_animations.py

@@ -0,0 +1,415 @@
+'''
+Animations tests
+================
+'''
+import pytest
+
+
+@pytest.fixture(scope='module')
+def ec_cls():
+    class EventCounter:
+        def __init__(self, anim):
+            self.n_start = 0
+            self.n_progress = 0
+            self.n_complete = 0
+            anim.bind(on_start=self.on_start,
+                      on_progress=self.on_progress,
+                      on_complete=self.on_complete)
+
+        def on_start(self, anim, widget):
+            self.n_start += 1
+
+        def on_progress(self, anim, widget, progress):
+            self.n_progress += 1
+
+        def on_complete(self, anim, widget):
+            self.n_complete += 1
+
+        def assert_(self, n_start, n_progress_greater_than_zero, n_complete):
+            assert self.n_start == n_start
+            if n_progress_greater_than_zero:
+                assert self.n_progress > 0
+            else:
+                assert self.n_progress == 0
+            assert self.n_complete == n_complete
+    return EventCounter
+
+
+@pytest.fixture(autouse=True)
+def cleanup():
+    from kivy.animation import Animation
+    Animation.cancel_all(None)
+
+
+def no_animations_being_played():
+    from kivy.animation import Animation
+    return len(Animation._instances) == 0
+
+
+def sleep(t):
+    from time import time, sleep
+    from kivy.clock import Clock
+    tick = Clock.tick
+    deadline = time() + t
+    while time() < deadline:
+        sleep(.01)
+        tick()
+
+
+class TestAnimation:
+
+    def test_start_animation(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=1)
+        w = Widget()
+        a.start(w)
+        sleep(1.5)
+        assert w.x == pytest.approx(100)
+        assert no_animations_being_played()
+
+    def test_animation_duration_0(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=0)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        assert no_animations_being_played()
+
+    def test_cancel_all(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a1 = Animation(x=100)
+        a2 = Animation(y=100)
+        w1 = Widget()
+        w2 = Widget()
+        a1.start(w1)
+        a1.start(w2)
+        a2.start(w1)
+        a2.start(w2)
+        assert not no_animations_being_played()
+        Animation.cancel_all(None)
+        assert no_animations_being_played()
+
+    def test_cancel_all_2(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a1 = Animation(x=100)
+        a2 = Animation(y=100)
+        w1 = Widget()
+        w2 = Widget()
+        a1.start(w1)
+        a1.start(w2)
+        a2.start(w1)
+        a2.start(w2)
+        assert not no_animations_being_played()
+        Animation.cancel_all(None, 'x', 'z')
+        assert not no_animations_being_played()
+        Animation.cancel_all(None, 'y')
+        assert no_animations_being_played()
+
+    def test_stop_animation(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=1)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        a.stop(w)
+        assert w.x != pytest.approx(100)
+        assert w.x != pytest.approx(0)
+        assert no_animations_being_played()
+
+    def test_stop_all(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=1)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        Animation.stop_all(w)
+        assert no_animations_being_played()
+
+    def test_stop_all_2(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=1)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        Animation.stop_all(w, 'x')
+        assert no_animations_being_played()
+
+    def test_duration(self):
+        from kivy.animation import Animation
+        a = Animation(x=100, d=1)
+        assert a.duration == 1
+
+    def test_transition(self):
+        from kivy.animation import Animation, AnimationTransition
+        a = Animation(x=100, t='out_bounce')
+        assert a.transition is AnimationTransition.out_bounce
+
+    def test_animated_properties(self):
+        from kivy.animation import Animation
+        a = Animation(x=100)
+        assert a.animated_properties == {'x': 100, }
+
+    def test_animated_instruction(self):
+        from kivy.graphics import Scale
+        from kivy.animation import Animation
+        a = Animation(x=100, d=1)
+        instruction = Scale(3, 3, 3)
+        a.start(instruction)
+        assert a.animated_properties == {'x': 100, }
+        assert instruction.x == pytest.approx(3)
+        sleep(1.5)
+        assert instruction.x == pytest.approx(100)
+        assert no_animations_being_played()
+
+    def test_weakref(self):
+        import gc
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        w = Widget()
+        a = Animation(x=100)
+        a.start(w.proxy_ref)
+        del w
+        gc.collect()
+        try:
+            sleep(1.)
+        except ReferenceError:
+            pass
+        assert no_animations_being_played()
+
+
+class TestSequence:
+
+    def test_cancel_all(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) + Animation(x=0)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        Animation.cancel_all(w)
+        assert no_animations_being_played()
+
+    def test_cancel_all_2(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) + Animation(x=0)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        Animation.cancel_all(w, 'x')
+        assert no_animations_being_played()
+
+    def test_stop_all(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) + Animation(x=0)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        Animation.stop_all(w)
+        assert no_animations_being_played()
+
+    def test_stop_all_2(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) + Animation(x=0)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        Animation.stop_all(w, 'x')
+        assert no_animations_being_played()
+
+    def test_count_events(self, ec_cls):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=.5) + Animation(x=0, d=.5)
+        w = Widget()
+        ec = ec_cls(a)
+        ec1 = ec_cls(a.anim1)
+        ec2 = ec_cls(a.anim2)
+        a.start(w)
+
+        # right after the animation starts
+        ec.assert_(1, False, 0)
+        ec1.assert_(1, False, 0)
+        ec2.assert_(0, False, 0)
+        sleep(.2)
+
+        # during the first half of the animation
+        ec.assert_(1, True, 0)
+        ec1.assert_(1, True, 0)
+        ec2.assert_(0, False, 0)
+        sleep(.5)
+
+        # during the second half of the animation
+        ec.assert_(1, True, 0)
+        ec1.assert_(1, True, 1)
+        ec2.assert_(1, True, 0)
+        sleep(.5)
+
+        # after the animation completed
+        ec.assert_(1, True, 1)
+        ec1.assert_(1, True, 1)
+        ec2.assert_(1, True, 1)
+        assert no_animations_being_played()
+
+    def test_have_properties_to_animate(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) + Animation(x=0)
+        w = Widget()
+        assert not a.have_properties_to_animate(w)
+        a.start(w)
+        assert a.have_properties_to_animate(w)
+        a.stop(w)
+        assert not a.have_properties_to_animate(w)
+        assert no_animations_being_played()
+
+    def test_animated_properties(self):
+        from kivy.animation import Animation
+        a = Animation(x=100, y=200) + Animation(x=0)
+        assert a.animated_properties == {'x': 0, 'y': 200, }
+
+    def test_transition(self):
+        from kivy.animation import Animation
+        a = Animation(x=100) + Animation(x=0)
+        with pytest.raises(AttributeError):
+            a.transition
+
+
+class TestRepetitiveSequence:
+
+    def test_stop(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) + Animation(x=0)
+        a.repeat = True
+        w = Widget()
+        a.start(w)
+        a.stop(w)
+        assert no_animations_being_played()
+
+    def test_count_events(self, ec_cls):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=.5) + Animation(x=0, d=.5)
+        a.repeat = True
+        w = Widget()
+        ec = ec_cls(a)
+        ec1 = ec_cls(a.anim1)
+        ec2 = ec_cls(a.anim2)
+        a.start(w)
+
+        # right after the animation starts
+        ec.assert_(1, False, 0)
+        ec1.assert_(1, False, 0)
+        ec2.assert_(0, False, 0)
+        sleep(.2)
+
+        # during the first half of the first round of the animation
+        ec.assert_(1, True, 0)
+        ec1.assert_(1, True, 0)
+        ec2.assert_(0, False, 0)
+        sleep(.5)
+
+        # during the second half of the first round of the animation
+        ec.assert_(1, True, 0)
+        ec1.assert_(1, True, 1)
+        ec2.assert_(1, True, 0)
+        sleep(.5)
+
+        # during the first half of the second round of the animation
+        ec.assert_(1, True, 0)
+        ec1.assert_(2, True, 1)
+        ec2.assert_(1, True, 1)
+        sleep(.5)
+
+        # during the second half of the second round of the animation
+        ec.assert_(1, True, 0)
+        ec1.assert_(2, True, 2)
+        ec2.assert_(2, True, 1)
+        a.stop(w)
+
+        # after the animation stopped
+        ec.assert_(1, True, 1)
+        ec1.assert_(2, True, 2)
+        ec2.assert_(2, True, 2)
+        assert no_animations_being_played()
+
+
+class TestParallel:
+
+    def test_have_properties_to_animate(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) & Animation(y=100)
+        w = Widget()
+        assert not a.have_properties_to_animate(w)
+        a.start(w)
+        assert a.have_properties_to_animate(w)
+        a.stop(w)
+        assert not a.have_properties_to_animate(w)
+        assert no_animations_being_played()
+
+    def test_cancel_property(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) & Animation(y=100)
+        w = Widget()
+        a.start(w)
+        a.cancel_property(w, 'x')
+        assert not no_animations_being_played()
+        a.stop(w)
+        assert no_animations_being_played()
+
+    def test_animated_properties(self):
+        from kivy.animation import Animation
+        a = Animation(x=100) & Animation(y=100)
+        assert a.animated_properties == {'x': 100, 'y': 100, }
+
+    def test_transition(self):
+        from kivy.animation import Animation
+        a = Animation(x=100) & Animation(y=100)
+        with pytest.raises(AttributeError):
+            a.transition
+
+    def test_count_events(self, ec_cls):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) & Animation(y=100, d=.5)
+        w = Widget()
+        ec = ec_cls(a)
+        ec1 = ec_cls(a.anim1)
+        ec2 = ec_cls(a.anim2)
+        a.start(w)
+
+        # right after the animation started
+        ec.assert_(1, False, 0)
+        ec1.assert_(1, False, 0)
+        ec2.assert_(1, False, 0)
+        sleep(.2)
+
+        # during the first half of the animation
+        ec.assert_(1, False, 0)  # n_progress is still 0 !!
+        ec1.assert_(1, True, 0)
+        ec2.assert_(1, True, 0)
+        sleep(.5)
+
+        # during the second half of the animation
+        ec.assert_(1, False, 0)  # n_progress is still 0 !!
+        ec1.assert_(1, True, 0)
+        ec2.assert_(1, True, 1)
+        sleep(.5)
+
+        # after the animation compeleted
+        ec.assert_(1, False, 1)  # n_progress is still 0 !
+        ec1.assert_(1, True, 1)
+        ec2.assert_(1, True, 1)
+        assert no_animations_being_played()

kivy/tests/test_app.py

@@ -0,0 +1,216 @@
+from os import name
+import os.path
+from math import isclose
+from textwrap import dedent
+
+from kivy.app import App
+from kivy.clock import Clock
+from kivy import lang
+from kivy.tests import GraphicUnitTest, async_run, UnitKivyApp
+
+
+class AppTest(GraphicUnitTest):
+    def test_start_raw_app(self):
+        lang._delayed_start = None
+        a = App()
+        Clock.schedule_once(a.stop, .1)
+        a.run()
+
+    def test_start_app_with_kv(self):
+        class TestKvApp(App):
+            pass
+
+        lang._delayed_start = None
+        a = TestKvApp()
+        Clock.schedule_once(a.stop, .1)
+        a.run()
+
+    def test_user_data_dir(self):
+        a = App()
+        data_dir = a.user_data_dir
+        assert os.path.exists(data_dir)
+
+    def test_directory(self):
+        a = App()
+        assert os.path.exists(a.directory)
+
+    def test_name(self):
+        class NameTest(App):
+            pass
+
+        a = NameTest()
+        assert a.name == 'nametest'
+
+
+def basic_app():
+    from kivy.app import App
+    from kivy.uix.label import Label
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            return Label(text='Hello, World!')
+
+    return TestApp()
+
+
+@async_run(app_cls_func=basic_app)
+async def test_basic_app(kivy_app):
+    assert kivy_app.root.text == 'Hello, World!'
+
+
+def button_app():
+    from kivy.app import App
+    from kivy.uix.togglebutton import ToggleButton
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            return ToggleButton(text='Hello, World!')
+
+    return TestApp()
+
+
+@async_run(app_cls_func=button_app)
+async def test_button_app(kivy_app):
+    assert kivy_app.root.text == 'Hello, World!'
+    assert kivy_app.root.state == 'normal'
+
+    async for state, touch_pos in kivy_app.do_touch_down_up(
+            widget=kivy_app.root, widget_jitter=True):
+        pass
+
+    assert kivy_app.root.state == 'down'
+
+
+def scatter_app():
+    from kivy.app import App
+    from kivy.uix.label import Label
+    from kivy.uix.scatter import Scatter
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            label = Label(text='Hello, World!', size=('200dp', '200dp'))
+            scatter = Scatter(do_scale=False, do_rotation=False)
+            scatter.add_widget(label)
+            return scatter
+
+    return TestApp()
+
+
+@async_run(app_cls_func=scatter_app)
+async def test_drag_app(kivy_app):
+    scatter = kivy_app.root
+    assert tuple(scatter.pos) == (0, 0)
+
+    async for state, touch_pos in kivy_app.do_touch_drag(
+            pos=(100, 100), target_pos=(200, 200)):
+        pass
+
+    assert isclose(scatter.x, 100)
+    assert isclose(scatter.y, 100)
+
+
+def text_app():
+    from kivy.app import App
+    from kivy.uix.textinput import TextInput
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            return TextInput()
+
+    return TestApp()
+
+
+@async_run(app_cls_func=text_app)
+async def test_text_app(kivy_app):
+    text = kivy_app.root
+    assert text.text == ''
+
+    # activate widget
+    async for state, touch_pos in kivy_app.do_touch_down_up(widget=text):
+        pass
+
+    async for state, value in kivy_app.do_keyboard_key(key='A', num_press=4):
+        pass
+    async for state, value in kivy_app.do_keyboard_key(key='q', num_press=3):
+        pass
+
+    assert text.text == 'AAAAqqq'
+
+
+def graphics_app():
+    from kivy.app import App
+    from kivy.uix.widget import Widget
+    from kivy.graphics import Color, Rectangle
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            widget = Widget()
+            with widget.canvas:
+                Color(1, 0, 0, 1)
+                Rectangle(pos=(0, 0), size=(100, 100))
+                Color(0, 1, 0, 1)
+                Rectangle(pos=(100, 0), size=(100, 100))
+            return widget
+
+    return TestApp()
+
+
+@async_run(app_cls_func=graphics_app)
+async def test_graphics_app(kivy_app):
+    widget = kivy_app.root
+    (r1, g1, b1, a1), (r2, g2, b2, a2) = kivy_app.get_widget_pos_pixel(
+        widget, [(50, 50), (150, 50)])
+
+    assert not g1 and not b1 and not r2 and not b2
+    assert r1 > 50 and a1 > 50 and g2 > 50 and a2 > 50
+
+
+def kv_app_ref_app():
+    from kivy.app import App
+    from kivy.lang import Builder
+    from kivy.properties import ObjectProperty
+    from kivy.uix.widget import Widget
+
+    class MyWidget(Widget):
+
+        obj = ObjectProperty(None)
+
+    Builder.load_string(dedent(
+        """
+        <MyWidget>:
+            obj: app.__self__
+        """))
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            return MyWidget()
+
+    return TestApp()
+
+
+@async_run(app_cls_func=kv_app_ref_app)
+async def test_leak_app_kv_property(kivy_app):
+    # just tests whether the app is gc'd after the test is complete
+    pass
+
+
+def kv_app_default_ref_app():
+    from kivy.app import App
+    from kivy.lang import Builder
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            # create property in kv and set app to it
+            return Builder.load_string(dedent(
+                """
+                Widget:
+                    obj: app.__self__
+                """))
+
+    return TestApp()
+
+
+@async_run(app_cls_func=kv_app_default_ref_app)
+async def test_leak_app_default_kv_property(kivy_app):
+    # just tests whether the app is gc'd after the test is complete
+    pass

kivy/tests/test_audio.py

@@ -0,0 +1,69 @@
+'''
+Audio tests
+===========
+'''
+
+import unittest
+import os
+import pytest
+if os.environ.get('KIVY_TEST_AUDIO') == '0':
+    pytestmark = pytest.mark.skip("Audio is not available")
+
+SAMPLE_FILE = os.path.join(os.path.dirname(__file__), 'sample1.ogg')
+SAMPLE_LENGTH = 1.402
+DELTA = SAMPLE_LENGTH * 0.01
+DELAY = 0.2
+
+
+class AudioTestCase(unittest.TestCase):
+
+    def get_sound(self):
+        import os
+        assert os.path.exists(SAMPLE_FILE)
+        from kivy.core import audio
+        return audio.SoundLoader.load(SAMPLE_FILE)
+
+    def test_length_simple(self):
+        sound = self.get_sound()
+        volume = sound.volume = 0.75
+        length = sound.length
+        self.assertAlmostEqual(SAMPLE_LENGTH, length, delta=DELTA)
+        # ensure that the gstreamer play/stop doesn't mess up the volume
+        assert volume == sound.volume
+
+    def test_length_playing(self):
+        import time
+        sound = self.get_sound()
+        sound.play()
+        try:
+            time.sleep(DELAY)
+            length = sound.length
+            self.assertAlmostEqual(SAMPLE_LENGTH, length, delta=DELTA)
+        finally:
+            sound.stop()
+        self.assertAlmostEqual(SAMPLE_LENGTH, length, delta=DELTA)
+
+    def test_length_stopped(self):
+        import time
+        sound = self.get_sound()
+        sound.play()
+        try:
+            time.sleep(DELAY)
+        finally:
+            sound.stop()
+        length = sound.length
+        self.assertAlmostEqual(SAMPLE_LENGTH, length, delta=DELTA)
+
+
+class AudioGstreamerTestCase(AudioTestCase):
+
+    def make_sound(self, source):
+        from kivy.core.audio import audio_gstreamer
+        return audio_gstreamer.SoundGstreamer(source)
+
+
+class AudioPygameTestCase(AudioTestCase):
+
+    def make_sound(self, source):
+        from kivy.core.audio import audio_pygame
+        return audio_pygame.SoundPygame(source)