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

kivy/tests/test_urlrequest/test_urlrequest_urllib.py

@@ -0,0 +1,155 @@
+'''
+UrlRequest tests
+================
+'''
+import os
+import threading
+from base64 import b64encode
+from datetime import datetime
+from time import sleep
+
+import pytest
+from kivy.network.urlrequest import UrlRequestUrllib as UrlRequest
+
+
+def wait_request_is_finished(kivy_clock, request, timeout=10):
+    start_time = datetime.now()
+    timed_out = False
+    while not request.is_finished and not timed_out:
+        kivy_clock.tick()
+        sleep(.1)
+        timed_out = (datetime.now() - start_time).total_seconds() > timeout
+    assert request.is_finished
+
+
+def ensure_called_from_thread(queue):
+    """Ensures the callback is called from this thread (main)."""
+    tid = threading.get_ident()
+    assert queue[0][0] == tid
+    assert queue[-2][0] == tid
+    assert queue[-1][0] == tid
+
+
+def check_queue_values(queue):
+    """Helper function verifying the queue contains the expected values."""
+    # we should have 2 progress minimum and one success
+    assert len(queue) >= 3
+
+    assert queue[0][1] == 'progress'
+    assert queue[-2][1] == 'progress'
+    assert queue[-1][1] in ('success', 'redirect')
+
+    assert queue[0][2][0] == 0
+    assert queue[-2][2][0] == queue[-2][2][1]
+
+
+class UrlRequestQueue:
+
+    def __init__(self, queue):
+        self.queue = queue
+
+    def _on_success(self, req, *args):
+        self.queue.append((threading.get_ident(), 'success', args))
+
+    def _on_redirect(self, req, *args):
+        self.queue.append((threading.get_ident(), 'redirect', args))
+
+    def _on_error(self, req, *args):
+        self.queue.append((threading.get_ident(), 'error', args))
+
+    def _on_progress(self, req, *args):
+        self.queue.append((threading.get_ident(), 'progress', args))
+
+
+@pytest.mark.skipif(os.environ.get('NONETWORK'), reason="No network")
+def test_callbacks(kivy_clock):
+    obj = UrlRequestQueue([])
+    queue = obj.queue
+    req = UrlRequest('http://google.com',
+                     on_success=obj._on_success,
+                     on_progress=obj._on_progress,
+                     on_error=obj._on_error,
+                     on_redirect=obj._on_redirect,
+                     debug=True)
+    wait_request_is_finished(kivy_clock, req)
+
+    if req.error and req.error.errno == 11001:
+        pytest.skip('Cannot connect to get address')
+
+    ensure_called_from_thread(queue)
+    check_queue_values(queue)
+
+
+@pytest.mark.skipif(os.environ.get('NONETWORK'), reason="No network")
+def test_auth_header(kivy_clock):
+    obj = UrlRequestQueue([])
+    queue = obj.queue
+    head = {
+        "Authorization": "Basic {}".format(b64encode(
+            "{}:{}".format('user', 'passwd').encode('utf-8')
+        ).decode('utf-8'))
+    }
+    req = UrlRequest(
+        'http://httpbin.org/basic-auth/user/passwd',
+        on_success=obj._on_success,
+        on_progress=obj._on_progress,
+        on_error=obj._on_error,
+        on_redirect=obj._on_redirect,
+        req_headers=head,
+        debug=True
+    )
+    wait_request_is_finished(kivy_clock, req, timeout=60)
+
+    if req.error and req.error.errno == 11001:
+        pytest.skip('Cannot connect to get address')
+
+    ensure_called_from_thread(queue)
+    check_queue_values(queue)
+    assert queue[-1][2] == ({'authenticated': True, 'user': 'user'}, )
+
+
+@pytest.mark.skipif(os.environ.get('NONETWORK'), reason="No network")
+def test_auth_auto(kivy_clock):
+    obj = UrlRequestQueue([])
+    queue = obj.queue
+    req = UrlRequest(
+        'http://user:passwd@httpbin.org/basic-auth/user/passwd',
+        on_success=obj._on_success,
+        on_progress=obj._on_progress,
+        on_error=obj._on_error,
+        on_redirect=obj._on_redirect,
+        debug=True
+    )
+    wait_request_is_finished(kivy_clock, req, timeout=60)
+
+    if req.error and req.error.errno == 11001:
+        pytest.skip('Cannot connect to get address')
+
+    ensure_called_from_thread(queue)
+    check_queue_values(queue)
+    assert queue[-1][2] == ({'authenticated': True, 'user': 'user'}, )
+
+
+@pytest.mark.skipif(os.environ.get('nonetwork'), reason="no network")
+@pytest.mark.parametrize("scheme", ("http", "https"))
+def test_ca_file(kivy_clock, scheme):
+    """Passing a `ca_file` should not crash on http scheme, refs #6946"""
+    import certifi
+    obj = UrlRequestQueue([])
+    queue = obj.queue
+    req = UrlRequest(
+        f"{scheme}://httpbin.org/get",
+        on_success=obj._on_success,
+        on_progress=obj._on_progress,
+        on_error=obj._on_error,
+        on_redirect=obj._on_redirect,
+        ca_file=certifi.where(),
+        debug=True
+    )
+    wait_request_is_finished(kivy_clock, req, timeout=60)
+
+    if req.error and req.error.errno == 11001:
+        pytest.skip('Cannot connect to get address')
+
+    ensure_called_from_thread(queue)
+    check_queue_values(queue)

kivy/tests/test_utils.py

@@ -0,0 +1,237 @@
+'''
+utils tests
+===========
+'''
+
+import os
+import unittest
+from unittest.mock import patch
+
+from kivy.utils import (boundary, escape_markup, format_bytes_to_human,
+        is_color_transparent, SafeList, get_random_color, get_hex_from_color,
+        get_color_from_hex, strtotuple, QueryDict, intersection, difference,
+        interpolate, _get_platform, deprecated, reify)
+from kivy import utils
+
+
+class UtilsTest(unittest.TestCase):
+
+    def test_escape_markup(self):
+        escaped = escape_markup('Sun [1] & Moon [2].')
+        self.assertEqual(escaped, 'Sun &bl;1&br; & Moon &bl;2&br;.')
+
+    def test_format_bytes_to_human(self):
+        a = format_bytes_to_human(6463)
+        self.assertEqual(a, '6.31 KB')
+        b = format_bytes_to_human(6463, precision=4)
+        self.assertEqual(b, '6.3115 KB')
+        c = format_bytes_to_human(646368746541)
+        self.assertEqual(c, '601.98 GB')
+
+    def test_boundary(self):
+        x = boundary(-1000, 0, 100)
+        self.assertEqual(x, 0)
+        x = boundary(1000, 0, 100)
+        self.assertEqual(x, 100)
+        x = boundary(50, 0, 100)
+        self.assertEqual(x, 50)
+
+    def test_is_color_transparent(self):
+        c = [1, 1, 1]
+        self.assertFalse(is_color_transparent(c))
+        c = [1, 1, 1, 1]
+        self.assertFalse(is_color_transparent(c))
+        c = [1, 1, 1, 0]
+        self.assertTrue(is_color_transparent(c))
+
+    @deprecated
+    def a_deprecated_function(self):
+        """ This one has doc string. """
+        pass
+
+    def test_deprecated(self):
+        self.a_deprecated_function()
+
+    def test_SafeList_iterate(self):  # deprecated
+        sl = SafeList(['1', 2, 3.])
+        self.assertTrue(isinstance(sl, list))
+        it = sl.iterate()
+        self.assertEqual(next(it), '1')
+        self.assertEqual(next(it), 2)
+        self.assertEqual(next(it), 3.)
+
+    def test_SafeList_iterate_reverse(self):  # deprecated
+        sl = SafeList(['1', 2, 3.])
+        self.assertTrue(isinstance(sl, list))
+        it = sl.iterate(reverse=True)
+        self.assertEqual(next(it), 3.)
+        self.assertEqual(next(it), 2)
+        self.assertEqual(next(it), '1')
+
+    def test_SafeList_clear(self):
+        sl = SafeList(['1', 2, 3.])
+        self.assertTrue(isinstance(sl, list))
+        sl.clear()
+        self.assertEqual(len(sl), 0)
+
+    def test_get_random_color_fixed_alpha(self):
+        actual = get_random_color()
+        self.assertEqual(len(actual), 4)
+        self.assertEqual(actual[3], 1.)
+
+        actual = get_random_color(alpha=.5)
+        self.assertEqual(len(actual), 4)
+        self.assertEqual(actual[3], .5)
+
+    def test_get_random_color_random_alpha(self):
+        actual = get_random_color(alpha='random')
+        self.assertEqual(len(actual), 4)
+
+    def test_get_hex_from_color_noalpha(self):
+        actual = get_hex_from_color([0, 1, 0])
+        expected = '#00ff00'
+        self.assertEqual(actual, expected)
+
+    def test_get_hex_from_color_alpha(self):
+        actual = get_hex_from_color([.25, .77, .90, .5])
+        expected = '#3fc4e57f'
+        self.assertEqual(actual, expected)
+
+    def test_get_color_from_hex_noalpha(self):
+        actual = get_color_from_hex('#d1a9c4')
+        expected = [0.81960784, 0.66274509, 0.76862745, 1.]
+        for i in range(4):
+            self.assertAlmostEqual(actual[i], expected[i])
+
+    def test_get_color_from_hex_alpha(self):
+        actual = get_color_from_hex('#00FF7F7F')
+        expected = [0., 1., 0.49803921, 0.49803921]  # can't get .5 from hex
+        for i in range(4):
+            self.assertAlmostEqual(actual[i], expected[i])
+
+    def test_strtotuple(self):
+        self.assertRaises(Exception, strtotuple, 'adis!_m%*+-=|')
+        self.assertRaises(Exception, strtotuple, '((12, 8, 473)')
+        self.assertRaises(Exception, strtotuple, '[12, 8, 473]]')
+        self.assertRaises(Exception, strtotuple, '128473')
+        actual = strtotuple('(12, 8, 473)')
+        expected = (12, 8, 473)
+        self.assertEqual(actual, expected)
+
+    def test_QueryDict(self):
+        qd = QueryDict()
+        self.assertTrue(isinstance(qd, dict))
+        # __setattr__
+        qd.toto = 1
+        self.assertEqual(qd.get('toto'), 1)
+        # __getattr__
+        toto = qd.toto
+        self.assertEqual(toto, 1)
+        with self.assertRaises(AttributeError):
+            foo = qd.not_an_attribute
+
+    def test_intersection(self):
+        abcd = ['a', 'b', 'c', 'd']
+        efgh = ['e', 'f', 'g', 'h']
+        fedc = ['c', 'd', 'e', 'f']  # cdef is cython keyword O_o)
+        feed = ['f', 'e', 'e', 'd']
+        self.assertEqual(intersection(abcd, efgh), [])
+        self.assertEqual(intersection(abcd, fedc), ['c', 'd'])
+        self.assertEqual(intersection(feed, feed), feed)
+        self.assertEqual(intersection([], []), [])
+        self.assertEqual(intersection(feed, fedc), feed)
+        self.assertEqual(intersection(fedc, feed), ['d', 'e', 'f'])
+        self.assertEqual(intersection(feed, efgh), ['f', 'e', 'e'])
+
+    def test_difference(self):
+        abcd = ['a', 'b', 'c', 'd']
+        efgh = ['e', 'f', 'g', 'h']
+        fedc = ['c', 'd', 'e', 'f']  # cdef is cython keyword O_o
+        feed = ['f', 'e', 'e', 'd']
+        self.assertEqual(difference(abcd, efgh), ['a', 'b', 'c', 'd'])
+        self.assertEqual(difference(efgh, fedc), ['g', 'h'])
+        self.assertEqual(difference([], []), [])
+        self.assertEqual(difference(abcd, abcd), [])
+        self.assertEqual(difference(fedc, feed), ['c'])
+        self.assertEqual(difference(feed, abcd), ['f', 'e', 'e'])
+        self.assertEqual(difference(abcd, feed), ['a', 'b', 'c'])
+
+    def test_interpolate_solo(self):
+        values = [10., 19., 27.1]
+        a = 0.
+        for i in range(0, 3):
+            a = interpolate(a, 100)
+            self.assertEqual(a, values[i])
+
+    def test_interpolate_multi(self):
+        x = [10., 19., 27.1]
+        y = [-10., -19., -27.1]
+        p = 0., 0.
+        for i in range(0, 3):
+            p = interpolate(p, [100, -100])
+            self.assertEqual(p, [x[i], y[i]])
+
+    @reify
+    def fib_100(self):
+        """ return 100th Fibonacci number
+        This uses modern view of F sub 1 = 0, F sub 2 = 1. """
+        # print("calculating...")
+        a, b = 0, 1
+        for n in range(2, 101):
+            a, b = b, a + b
+        return b
+
+    def test_reify(self):
+        # slow. self.fib_100 is a reify object making the lazy call.
+        first = self.fib_100
+        second = self.fib_100  # fast, self.fib_100 is a long.
+        assert first == second
+
+    def test_Platform_android(self):
+        with patch.dict('os.environ', {'KIVY_BUILD': 'android'}):
+            self.assertEqual(_get_platform(), 'android')
+        self.assertNotIn('KIVY_BUILD', os.environ)
+
+    def test_Platform_android_with_p4a(self):
+        with patch.dict('os.environ', {'P4A_BOOTSTRAP': 'sdl2'}):
+            self.assertEqual(_get_platform(), 'android')
+        self.assertNotIn('P4A_BOOTSTRAP', os.environ)
+
+    def test_Platform_android_with_android_argument(self):
+        with patch.dict('os.environ', {'ANDROID_ARGUMENT': ''}):
+            self.assertEqual(_get_platform(), 'android')
+        self.assertNotIn('ANDROID_ARGUMENT', os.environ)
+
+    def test_Platform_ios(self):
+        with patch.dict('os.environ', {'KIVY_BUILD': 'ios'}):
+            pf = _get_platform()
+            self.assertEqual(pf, 'ios')
+        self.assertNotIn('KIVY_BUILD', os.environ)
+
+    def test_Platform_win32(self):
+        self._test_platforms('win32', 'win')
+
+    def test_Platform_cygwin(self):
+        self._test_platforms('cygwin', 'win')
+
+    def test_Platform_linux2(self):
+        self._test_platforms('linux2', 'linux')
+
+    def test_Platform_darwin(self):
+        self._test_platforms('darwin', 'macosx')
+
+    def test_Platform_freebsd(self):
+        self._test_platforms('freebsd', 'linux')
+
+    def test_Platform_unknown(self):
+        self._test_platforms('randomdata', 'unknown')
+
+    def _test_platforms(self, input, testval):
+        utils._sys_platform = input
+        pf = _get_platform()
+        self.assertTrue(pf == testval)
+        # with patch('kivy.utils._sys_platform') as m:
+        #     m.__str__.return_value = input
+        #     m.__eq__ = lambda x, y: str(x) == y
+        #     pf = _get_platform()
+        #     self.assertTrue(str(pf) == testval)

kivy/tests/test_vector.py

@@ -0,0 +1,256 @@
+import unittest
+
+from kivy.vector import Vector
+from operator import truediv
+
+
+class VectorTestCase(unittest.TestCase):
+    def test_initializer_oneparameter_as_list(self):
+        vector = Vector([1])
+        self.assertEqual(vector.x, 1)
+        with self.assertRaises(IndexError):
+            vector.y
+
+    def test_initializer_oneparameter_as_int(self):
+        with self.assertRaises(TypeError):
+            Vector(1)
+
+    def test_initializer_twoparameters(self):
+        vector = Vector(1, 2)
+        self.assertEqual(vector.x, 1)
+        self.assertEqual(vector.y, 2)
+
+    def test_initializer_noparameter(self):
+        with self.assertRaises(Exception):
+            Vector()
+
+    def test_initializer_threeparameters(self):
+        with self.assertRaises(Exception):
+            Vector(1, 2, 3)
+
+    def test_sum_twovectors(self):
+        finalVector = Vector(1, 1) + Vector(1, 1)
+        self.assertEqual(finalVector.x, 2)
+        self.assertEqual(finalVector.y, 2)
+
+    def test_sum_inplace(self):
+        finalVector = Vector(1, 1)
+        finalVector += Vector(1, 1)
+        self.assertEqual(finalVector.x, 2)
+        self.assertEqual(finalVector.y, 2)
+
+    def test_sum_inplace_scalar(self):
+        finalVector = Vector(1, 1)
+        finalVector += 1
+        self.assertEqual(finalVector.x, 2)
+        self.assertEqual(finalVector.y, 2)
+
+    def test_sum_scalar(self):
+        with self.assertRaises(TypeError):
+            Vector(1, 1) + 1
+
+    def test_sub_twovectors(self):
+        finalVector = Vector(3, 3) - Vector(2, 2)
+        self.assertEqual(finalVector.x, 1)
+        self.assertEqual(finalVector.y, 1)
+
+    def test_sub_inplace(self):
+        finalVector = Vector(3, 3)
+        finalVector -= Vector(2, 2)
+        self.assertEqual(finalVector.x, 1)
+        self.assertEqual(finalVector.y, 1)
+
+    def test_sub_scalar(self):
+        with self.assertRaises(TypeError):
+            Vector(3, 3) - 2
+
+    def test_sub_inplace_scalar(self):
+        finalVector = Vector(3, 3)
+        finalVector -= 2
+        self.assertEqual(finalVector.x, 1)
+        self.assertEqual(finalVector.y, 1)
+
+    def test_mul_twovectors(self):
+        finalVector = Vector(2, 2) * Vector(3, 3)
+        self.assertEqual(finalVector.x, 6)
+        self.assertEqual(finalVector.y, 6)
+
+    def test_mul_inplace(self):
+        finalVector = Vector(2, 2)
+        finalVector *= Vector(3, 3)
+        self.assertEqual(finalVector.x, 6)
+        self.assertEqual(finalVector.y, 6)
+
+    def test_mul_inplace_scalar(self):
+        finalVector = Vector(2, 2)
+        finalVector *= 3
+        self.assertEqual(finalVector.x, 6)
+        self.assertEqual(finalVector.y, 6)
+
+    def test_mul_scalar(self):
+        finalVector = Vector(2, 2) * 3
+        self.assertEqual(finalVector.x, 6)
+        self.assertEqual(finalVector.y, 6)
+
+    def test_rmul_list(self):
+        finalVector = (3, 3) * Vector(2, 2)
+        self.assertEqual(finalVector.x, 6)
+        self.assertEqual(finalVector.y, 6)
+
+    def test_rmul_scalar(self):
+        finalVector = 3 * Vector(2, 2)
+        self.assertEqual(finalVector.x, 6)
+        self.assertEqual(finalVector.y, 6)
+
+    def test_div_twovectors(self):
+        finalVector = Vector(6, 6) / Vector(2, 2)
+        self.assertEqual(finalVector.x, 3)
+        self.assertEqual(finalVector.y, 3)
+
+    def test_truediv_twovectors(self):
+        finalVector = truediv(Vector(6, 6), Vector(2., 2.))
+        self.assertAlmostEqual(finalVector.x, 3.)
+        self.assertAlmostEqual(finalVector.y, 3.)
+
+    def test_truediv_scalar(self):
+        finalVector = truediv(Vector(6, 6), 2.)
+        self.assertAlmostEqual(finalVector.x, 3.)
+        self.assertAlmostEqual(finalVector.y, 3.)
+
+    def test_div_inplace(self):
+        finalVector = Vector(6, 6)
+        finalVector /= Vector(2, 2)
+        self.assertEqual(finalVector.x, 3)
+        self.assertEqual(finalVector.y, 3)
+
+    def test_div_inplace_scalar(self):
+        finalVector = Vector(6, 6)
+        finalVector /= 2
+        self.assertEqual(finalVector.x, 3)
+        self.assertEqual(finalVector.y, 3)
+
+    def test_div_scalar(self):
+        finalVector = Vector(6, 6) / 2
+        self.assertEqual(finalVector.x, 3)
+        self.assertEqual(finalVector.y, 3)
+
+    def test_rdiv_list(self):
+        finalVector = (6.0, 6.0) / Vector(3.0, 3.0)
+        self.assertEqual(finalVector.x, 2)
+        self.assertEqual(finalVector.y, 2)
+
+    def test_rdiv_scalar(self):
+        finalVector = 6 / Vector(3, 3)
+        self.assertEqual(finalVector.x, 2)
+        self.assertEqual(finalVector.y, 2)
+
+    def test_sum_oversizedlist(self):
+        Vector(6, 6) + (1, 2)
+
+    def test_negation(self):
+        vector = - Vector(1, 1)
+        self.assertEqual(vector.x, -1)
+        self.assertEqual(vector.y, -1)
+
+    def test_length(self):
+        length = Vector(10, 10).length()
+        self.assertEqual(length, 14.142135623730951)
+
+    def test_length_zerozero(self):
+        length = Vector(0, 0).length()
+        self.assertEqual(length, 0)
+
+    def test_length2(self):
+        length = Vector(10, 10).length2()
+        self.assertEqual(length, 200)
+
+    def test_distance(self):
+        distance = Vector(10, 10).distance((5, 10))
+        self.assertEqual(distance, 5)
+
+    def test_distance2(self):
+        distance = Vector(10, 10).distance2((5, 10))
+        self.assertEqual(distance, 25)
+
+    def test_normalize(self):
+        vector = Vector(88, 33).normalize()
+        self.assertAlmostEqual(vector.x, 0.93632917756904444)
+        self.assertAlmostEqual(vector.y, 0.3511234415883917)
+        self.assertAlmostEqual(vector.length(), 1.0)
+
+    def test_normalize_zerovector(self):
+        vector = Vector(0, 0).normalize()
+        self.assertEqual(vector.x, 0)
+        self.assertEqual(vector.y, 0)
+        self.assertEqual(vector.length(), 0)
+
+    def test_dot(self):
+        result = Vector(2, 4).dot((2, 2))
+        self.assertEqual(result, 12)
+
+    def test_angle(self):
+        result = Vector(100, 0).angle((0, 100))
+        self.assertAlmostEqual(result, -90.0)
+
+    def test_rotate(self):
+        v = Vector(100, 0)
+        v = v.rotate(45)
+        self.assertAlmostEqual(v.x, 70.710678118654755)
+        self.assertAlmostEqual(v.y, 70.710678118654741)
+
+    def test_(self):
+        a = (98, 28)
+        b = (72, 33)
+        c = (10, -5)
+        d = (20, 88)
+        result = Vector.line_intersection(a, b, c, d)
+        self.assertAlmostEqual(result.x, 15.25931928687196)
+        self.assertAlmostEqual(result.y, 43.911669367909241)
+
+    def test_inbbox(self):
+        bmin = (0, 0)
+        bmax = (100, 100)
+        result = Vector.in_bbox((50, 50), bmin, bmax)
+        self.assertTrue(result)
+        result = Vector.in_bbox((647, -10), bmin, bmax)
+        self.assertFalse(result)
+
+    def test_intersection_roundingerror(self):
+        # ref #2983, #5568
+
+        v1 = (25.0, 200.0)
+        v2 = (25.0, 400.0)
+        v3 = (36.75, 300.0)
+        result = [25.0, 300.0]
+
+        def almost(a, b):
+            # 300.0 sometimes is 299.9.. or 300.1.. however
+            # we just want to know that it's really close
+            self.assertIsNotNone(a)
+            self.assertIsNotNone(b)
+            self.assertAlmostEqual(a[0], b[0], places=0)
+            self.assertAlmostEqual(a[1], b[1], places=0)
+
+        for i in range(1, 100):
+            st = "6.4" + "9" * i
+            v = (float(st), 300.0)
+            almost(result, Vector.segment_intersection(v1, v2, v3, v))
+
+        for i in range(1, 100):
+            st = "6.1" + "1" * i
+            v = (float(st), 300.0)
+            almost(result, Vector.segment_intersection(v1, v2, v3, v))
+
+        for i in range(1, 100):
+            st = "6.4" + "4" * i
+            v = (float(st), 300.0)
+            almost(result, Vector.segment_intersection(v1, v2, v3, v))
+
+        for i in range(1, 100):
+            st = "300.4" + "9" * i
+            v = (6.5, float(st))
+            almost(result, Vector.segment_intersection(v1, v2, v3, v))
+
+
+if __name__ == '__main__':
+    unittest.main()

kivy/tests/test_video.py

@@ -0,0 +1,25 @@
+
+import unittest
+
+
+class VideoTestCase(unittest.TestCase):
+
+    def test_video_unload(self):
+        # fix issue https://github.com/kivy/kivy/issues/2275
+        # AttributeError: 'NoneType' object has no attribute 'texture'
+        from kivy.uix.video import Video
+        from kivy.clock import Clock
+        from kivy.base import runTouchApp, stopTouchApp
+        from kivy import kivy_examples_dir
+        from os.path import join, dirname, abspath
+        source = abspath(join(kivy_examples_dir, "widgets", "cityCC0.mpg"))
+        video = Video(source=source, play=True)
+        Clock.schedule_once(lambda x: stopTouchApp(), 1)
+
+        def unload_video(video, position):
+            if position > 0.01:
+                video.unload()
+                Clock.schedule_once(lambda x: stopTouchApp(), 0.1)
+
+        video.bind(position=unload_video)
+        runTouchApp(video)