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

kivy/tests/test_graphics_svg.py

@@ -0,0 +1,84 @@
+'''
+Svg tests
+==============
+
+Testing Svg rendering.
+'''
+
+from kivy.tests.common import GraphicUnitTest
+
+
+SIMPLE_SVG = """<?xml version="1.0" standalone="no"?>
+<svg width="256" height="256" viewBox="0 0 256 256" version="1.1"
+    xmlns="http://www.w3.org/2000/svg">
+<rect stroke="blue" stroke-width="4" x="24" y="30" width="92" height="166"
+    fill="none" stroke-opacity="0.5" />
+</svg>
+"""
+
+SCALE_SVG = """<?xml version="1.0" standalone="no"?>
+<svg width="256" height="256" viewBox="0 0 256 256" version="1.1"
+    xmlns="http://www.w3.org/2000/svg">
+<rect stroke="red" stroke-width="4" x="24" y="30" width="10" height="10"
+    fill="none" stroke-opacity="0.5" transform="scale(2, 3)"/>
+</svg>
+"""
+
+ROTATE_SVG = """<?xml version="1.0" standalone="no"?>
+<svg width="256" height="256" viewBox="0 0 256 256" version="1.1"
+    xmlns="http://www.w3.org/2000/svg">
+<rect stroke="green" stroke-width="4" x="24" y="30" width="50" height="100"
+    stroke-opacity="0.75" transform="rotate(60 128 128)" />
+</svg>
+"""
+
+
+class SvgTest(GraphicUnitTest):
+
+    def test_simple(self):
+        import xml.etree.ElementTree as ET
+        from kivy.uix.widget import Widget
+        from kivy.graphics.svg import Svg
+
+        # create a root widget
+        wid = Widget()
+
+        # put some graphics instruction on it
+        with wid.canvas:
+            svg = Svg()
+            svg.set_tree(ET.ElementTree(ET.fromstring(SIMPLE_SVG)))
+
+        # render, and capture it directly
+        self.render(wid)
+
+    def test_scale(self):
+        import xml.etree.ElementTree as ET
+        from kivy.uix.widget import Widget
+        from kivy.graphics.svg import Svg
+
+        # create a root widget
+        wid = Widget()
+
+        # put some graphics instruction on it
+        with wid.canvas:
+            svg = Svg()
+            svg.set_tree(ET.ElementTree(ET.fromstring(SCALE_SVG)))
+
+        # render, and capture it directly
+        self.render(wid)
+
+    def test_rotate(self):
+        import xml.etree.ElementTree as ET
+        from kivy.uix.widget import Widget
+        from kivy.graphics.svg import Svg
+
+        # create a root widget
+        wid = Widget()
+
+        # put some graphics instruction on it
+        with wid.canvas:
+            svg = Svg()
+            svg.set_tree(ET.ElementTree(ET.fromstring(ROTATE_SVG)))
+
+        # render, and capture it directly
+        self.render(wid)

kivy/tests/test_image.py

@@ -0,0 +1,74 @@
+import unittest
+import io
+import os
+import tempfile
+from kivy import setupconfig
+
+
+class ImageTestCase(unittest.TestCase):
+
+    def setUp(self):
+        from kivy.core.window import Window
+        from kivy.core.image import Image
+        import os
+        self.cls = Image
+        self.image = os.path.join(os.path.dirname(__file__), 'test_button.png')
+        print(self.image)
+        self.root = Image(self.image)
+
+    def test_keep_data(self):
+        root = self.root
+        texture = root.texture
+        self.assertEqual(root._image._data[0].data, None)
+        i1 = self.cls(self.image, keep_data=True)
+        if not i1._image._data[0].data:
+            self.fail('Image has no data even with keep_data = True')
+
+    @unittest.skip("Travis on Xenial don't have SDL_image >= 2.0.5")
+    def test_save_into_bytesio(self):
+        Image = self.cls
+
+        if setupconfig.PLATFORM == "darwin":
+            # XXX on OSX CI Builder, img_sdl2 is not used
+            # therefore the test below wont work yet with imageio only.
+            return
+
+        # load kivy logo
+        img = Image.load("data/logo/kivy-icon-512.png")
+        self.assertIsNotNone(img)
+
+        # try to save without any format
+        with self.assertRaises(Exception) as context:
+            bio = io.BytesIO()
+            img.save(bio)
+
+        # save it in png
+        bio = io.BytesIO()
+        # if False, then there is no provider
+        self.assertTrue(img.save(bio, fmt="png"))
+        pngdata = bio.read()
+        self.assertTrue(len(pngdata) > 0)
+
+        # try to save in a filename
+        try:
+            _, filename = tempfile.mkstemp(suffix=".png")
+            self.assertTrue(img.save(filename, fmt="png"))
+        finally:
+            os.unlink(filename)
+
+        # XXX Test wrote but temporary commented
+        # XXX because of the issue #6123 on OSX
+        # XXX https://github.com/kivy/kivy/issues/6123
+        # with open(filename, "rb") as fd2:
+        #     pngdatafile = fd2.read()
+        # # check the png file data is the same as bytesio
+        # self.assertTrue(pngdata == pngdatafile)
+
+        # save it in jpeg
+        bio = io.BytesIO()
+        # if False, then there is no provider
+        self.assertTrue(img.save(bio, fmt="jpg"))
+        self.assertTrue(len(bio.read()) > 0)
+
+        with tempfile.NamedTemporaryFile(suffix=".jpg") as fd:
+            self.assertTrue(img.save(fd.name))

kivy/tests/test_imageloader.py

@@ -0,0 +1,485 @@
+# You need an image testsuite to run this, for information see:
+# kivy/tools/image-testsuite/README.md
+
+import os
+import re
+import sys
+import unittest
+from collections import defaultdict
+from kivy.core.image import ImageLoader
+
+DEBUG = False
+ASSETDIR = 'image-testsuite'
+LOADERS = {x.__name__: x for x in ImageLoader.loaders}
+
+if 'ImageLoaderPygame' not in LOADERS:
+    try:
+        from kivy.core.image.img_pygame import ImageLoaderPygame
+        LOADERS['ImageLoaderPygame'] = ImageLoaderPygame
+    except:
+        pass
+
+# Kivy image test protocol v0: Pixel values
+v0_PIXELS = {  # NOTE: 't' is not included here, see match_prediction()
+    'w': [0xFF, 0xFF, 0xFF], 'x': [0x00, 0x00, 0x00], 'r': [0xFF, 0x00, 0x00],
+    'g': [0x00, 0xFF, 0x00], 'b': [0x00, 0x00, 0xFF], 'y': [0xFF, 0xFF, 0x00],
+    'c': [0x00, 0xFF, 0xFF], 'p': [0xFF, 0x00, 0xFF], '0': [0x00, 0x00, 0x00],
+    '1': [0x11, 0x11, 0x11], '2': [0x22, 0x22, 0x22], '3': [0x33, 0x33, 0x33],
+    '4': [0x44, 0x44, 0x44], '5': [0x55, 0x55, 0x55], '6': [0x66, 0x66, 0x66],
+    '7': [0x77, 0x77, 0x77], '8': [0x88, 0x88, 0x88], '9': [0x99, 0x99, 0x99],
+    'A': [0xAA, 0xAA, 0xAA], 'B': [0xBB, 0xBB, 0xBB], 'C': [0xCC, 0xCC, 0xCC],
+    'D': [0xDD, 0xDD, 0xDD], 'E': [0xEE, 0xEE, 0xEE], 'F': [0xFF, 0xFF, 0xFF]}
+
+# Kivy image test protocol v0: File name
+# width x height _ pattern _ alpha _ fmtinfo _ testname _ encoder . ext
+v0_FILE_RE = re.compile(r'^v0_(\d+)x(\d+)_' r'([wxrgbycptA-F0-9]+)_'
+                        r'([0-9a-fA-F]{2})_' r'([a-zA-Z0-9-]+)_'
+                        r'([a-zA-Z0-9-]+)_' r'([a-zA-Z0-9-]+)'
+                        r'\.([a-z]+)$')
+
+
+def asset(*fn):
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), *fn))
+
+
+def has_alpha(fmt):
+    return fmt in ('rgba', 'bgra', 'argb', 'abgr')
+
+
+def bytes_per_pixel(fmt):
+    if fmt in ('rgb', 'bgr'):
+        return 3
+    if fmt in ('rgba', 'bgra', 'argb', 'abgr'):
+        return 4
+    raise Exception('bytes_per_pixel: unknown format {}'.format(fmt))
+
+
+def get_pixel_alpha(pix, fmt):
+    if fmt in ('rgba', 'bgra'):
+        return pix[3]
+    elif fmt in ('abgr', 'argb'):
+        return pix[0]
+    return 0xFF
+
+
+# Converts (predicted) rgba pixels to the format claimed by image loader
+def rgba_to(pix_in, target_fmt, w, h, pitch=None):
+    if not isinstance(pix_in, (bytes, bytearray)):
+        pix_in = bytearray(pix_in)
+    assert w > 0 and h > 0, "Must specify w and h"
+    assert len(pix_in) == w * h * 4, "Invalid rgba data {}".format(pix_in)
+    assert target_fmt in ('rgba', 'bgra', 'argb', 'abgr', 'rgb', 'bgr')
+
+    if target_fmt == 'rgba':
+        return pix_in
+
+    pixels = [pix_in[i:i + 4] for i in range(0, len(pix_in), 4)]
+    if target_fmt == 'bgra':
+        return b''.join([bytes(p[:3][::-1] + p[3:]) for p in pixels])
+    elif target_fmt == 'abgr':
+        return b''.join([bytes(p[3:] + p[:3][::-1]) for p in pixels])
+    elif target_fmt == 'argb':
+        return b''.join([bytes(p[3:] + p[:3]) for p in pixels])
+
+    # rgb/bgr, default to 4 byte alignment
+    if pitch is None:
+        pitch = ((3 * w) + 3) & ~3
+    # Assume pitch 0 == unaligned
+    elif pitch == 0:
+        pitch = 3 * w
+
+    out = b''
+    padding = b'\x00' * (pitch - w * 3)
+    for row in [pix_in[i:i + w * 4] for i in range(0, len(pix_in), w * 4)]:
+        pixelrow = [row[i:i + 4] for i in range(0, len(row), 4)]
+        if target_fmt == 'rgb':
+            out += b''.join([bytes(p[:3]) for p in pixelrow])
+        elif target_fmt == 'bgr':
+            out += b''.join([bytes(p[:3][::-1]) for p in pixelrow])
+        out += padding
+    return out
+
+
+def match_prediction(pixels, fmt, fd, pitch):
+    assert len(fd['alpha']) == 2
+    assert len(fd['pattern']) > 0
+
+    bpp = bytes_per_pixel(fmt)
+    rowlen = fd['w'] * bpp
+    if pitch is None:
+        pitch = (rowlen + 3) & ~3
+    elif pitch == 0:
+        pitch = fd['w'] * bpp
+    pitchalign = pitch - rowlen
+
+    errors = []
+    fail = errors.append
+
+    if len(pixels) != pitch * fd['h']:
+        fail("Pitch error: pitch {} * {} height != {} pixelbytes"
+             .format(pitch, fd['h'], len(pixels)))
+
+    ptr = 0
+    pixnum = 0
+    for char in fd['pattern']:
+        pix = list(bytearray(pixels[ptr:ptr + bpp]))
+#        print("PIXNUM {} ptr={} bpp={} : {}".format(pixnum, ptr, bpp, pix))
+        if len(pix) != bpp:
+            fail("Want {} bytes per pixel, got {}: {}"
+                 .format(bpp, len(pix), pix))
+            break
+
+        if char == 't':
+            if get_pixel_alpha(pix, fmt) != 0:
+                fail("pixel {} nonzero 't' pixel alpha {:02X}: {}".format(
+                      pixnum, get_pixel_alpha(pix, fmt), pix))
+        else:
+            srcpix = v0_PIXELS[char] + list(bytearray.fromhex(fd['alpha']))
+            predict = rgba_to(srcpix, fmt, 1, 1, pitch=0)
+            predict = list(bytearray(predict))
+            if not predict or not pix or predict != pix:
+                fail("pixel {} {} format mismatch: want {} ({}) -- got {}"
+                     .format(pixnum, fmt, predict, char, pix))
+
+        if pitchalign and (pixnum + 1) % fd['w'] == 0:
+            check = list(bytearray(pixels[ptr + bpp:ptr + bpp + pitchalign]))
+            if check != [0] * pitchalign:
+                fail("Want {} 0x00 pitch align pixnum={}, pos={} got: {}"
+                     .format(pitchalign, pixnum, ptr + bpp, check))
+            ptr += pitchalign
+        ptr += bpp
+        pixnum += 1
+
+    if ptr != len(pixels):
+        fail("Excess data: pixnum={} ptr={} bytes={}, bpp={} pitchalign={}"
+             .format(pixnum, ptr, len(pixels), bpp, pitchalign))
+    return (len(errors) == 0, errors)
+
+
+class _TestContext(object):
+    def __init__(self, loadercls):
+        self.loadercls = loadercls
+        self._fd = None
+        self._fn = None
+        self._ok = 0
+        self._skip = 0
+        self._fail = 0
+        self._stats = defaultdict(dict)
+
+    @property
+    def stats(self):
+        return self._stats
+
+    @property
+    def results(self):
+        return (self._ok, self._skip, self._fail, self._stats)
+
+    def start(self, fn, fd):
+        assert not self._fn, "unexpected ctx.start(), already started"
+        assert isinstance(fd, dict)
+        self._fn = fn
+        self._fd = fd
+
+    def end(self, fn=None):
+        assert not fn or self._fn == fn, "unexpected ctx.end(), fn mismatch"
+        self._fn = None
+        self._fd = None
+
+    def ok(self, info):
+        assert self._fn, "unexpected ctx.ok(), fn=None"
+        self._ok += 1
+        self.dbg('PASS', info)
+        self._incstat('ok')
+        self.end(self._fn)
+
+    def skip(self, info):
+        assert self._fn, "unexpected ctx.skip(), fn=None"
+        self._skip += 1
+        self.dbg('SKIP', info)
+        self._incstat('skip')
+        self.end(self._fn)
+
+    def fail(self, info):
+        assert self._fn, "unexpected ctx.fail(), fn=None"
+        self._fail += 1
+        self.dbg('FAIL', info)
+        self._incstat('fail')
+        self.end(self._fn)
+
+    def dbg(self, msgtype, info):
+        assert self._fn, "unexpected ctx.dbg(), fn=None"
+        if DEBUG:
+            print("{} {} {}: {}"
+                  .format(self.loadercls.__name__, msgtype, self._fn, info))
+
+    def _incstat(self, s):
+        assert self._fd, "unexpected ctx._incstat(), fd=None"
+        fd = self._fd
+
+        def IS(key):
+            self._stats.setdefault(s, defaultdict(int))[key] += 1
+
+        IS('total')
+        IS('extension:{}'.format(fd['ext']))
+        IS('encoder:{}'.format(fd['encoder']))
+        IS('fmtinfo:{}'.format(fd['fmtinfo']))
+        IS('testname:{}'.format(fd['testname']))
+        IS('testname+ext:{}+{}'.format(fd['testname'], fd['ext']))
+        IS('encoder+ext:{}+{}'.format(fd['encoder'], fd['ext']))
+        IS('encoder+testname:{}+{}'.format(fd['encoder'], fd['testname']))
+        IS('fmtinfo+ext:{}+{}'.format(fd['fmtinfo'], fd['ext']))
+
+
+@unittest.skipIf(not os.path.isdir(asset(ASSETDIR)),
+                 "Need 'make image-testsuite' to run test")
+class ImageLoaderTestCase(unittest.TestCase):
+    def setUp(self):
+        self._context = None
+        self._prepare_images()
+
+    def tearDown(self):
+        if not DEBUG or not self._context:
+            return
+        ctx = self._context
+        il = ctx.loadercls.__name__
+        stats = ctx.stats
+        keys = set([k for x in stats.values() for k in x.keys()])
+        sg = stats.get
+        for k in sorted(keys):
+            ok, skip, fail = sg('ok', {}), sg('skip', {}), sg('fail', {})
+            print("REPORT {} {}: ok={}, skip={}, fail={}".format(
+                  il, k, ok.get(k, 0), skip.get(k, 0), fail.get(k, 0)))
+
+    def _prepare_images(self):
+        if hasattr(self, '_image_files'):
+            return
+        self._image_files = {}
+        for filename in os.listdir(asset(ASSETDIR)):
+            matches = v0_FILE_RE.match(filename)
+            if not matches:
+                continue
+            w, h, pat, alpha, fmtinfo, tst, encoder, ext = matches.groups()
+            self._image_files[filename] = {
+                'filename': filename,
+                'w': int(w),
+                'h': int(h),
+                'pattern': pat,
+                'alpha': alpha,
+                'fmtinfo': fmtinfo,
+                'testname': tst,
+                'encoder': encoder,
+                'ext': ext,
+                'require_alpha': 'BINARY' in tst or 'ALPHA' in tst,
+            }
+
+    def _test_imageloader(self, loadercls, extensions=None):
+        if not loadercls:
+            return
+        if not extensions:
+            extensions = loadercls.extensions()
+
+        ctx = _TestContext(loadercls)
+        self._context = ctx
+        for filename in sorted(self._image_files.keys()):
+            filedata = self._image_files[filename]
+
+            if filedata['ext'] not in extensions:
+                continue
+            try:
+                ctx.start(filename, filedata)
+                result = loadercls(asset(ASSETDIR, filename), keep_data=True)
+                if not result:
+                    raise Exception('invalid result')
+            except:
+                ctx.skip('Error loading file, result=None')
+                continue
+            self._test_image(filedata, ctx, loadercls, result)
+            ctx.end()
+
+        ok, skip, fail, stats = ctx.results
+        if fail:
+            self.fail('{}: {} passed, {} skipped, {} failed'
+                      .format(loadercls.__name__, ok, skip, fail))
+        return ctx
+
+    def _test_image(self, fd, ctx, loadercls, imgdata):
+        w, h, pixels, pitch = imgdata._data[0].get_mipmap(0)
+        fmt = imgdata._data[0].fmt
+
+        # required for FFPy memview
+        # FIXME: bytearray() for py2 compat, I can't be bothered to research
+        if not isinstance(pixels, bytes):
+            pixels = bytearray(pixels)
+
+        def debug():
+            if not DEBUG:
+                return
+            print("    format: {}x{} {}".format(w, h, fmt))
+            print("     pitch: got {}, want {}".format(pitch, want_pitch))
+            print("      want: {} in {}".format(fd['pattern'], fmt))
+            print("       got: {}".format(bytearray(pixels)))
+
+        # Assume pitch 0 = unaligned
+        want_pitch = (pitch == 0) and bytes_per_pixel(fmt) * w or pitch
+        if pitch == 0 and bytes_per_pixel(fmt) * w * h != len(pixels):
+            ctx.dbg("PITCH", "pitch=0, expected fmt={} to be "
+                             "unaligned @ ({}bpp) = {} bytes, got {}"
+                             .format(fmt, bytes_per_pixel(fmt),
+                                     bytes_per_pixel(fmt) * w * h,
+                                     len(pixels)))
+        elif pitch and want_pitch != pitch:
+            ctx.dbg("PITCH", "fmt={}, pitch={}, expected {}"
+                             .format(fmt, pitch, want_pitch))
+
+        success, msgs = match_prediction(pixels, fmt, fd, pitch)
+        if not success:
+            if not msgs:
+                ctx.fail("Unknown error")
+            elif len(msgs) == 1:
+                ctx.fail(msgs[0])
+            else:
+                for m in msgs:
+                    ctx.dbg('PREDICT', m)
+                ctx.fail('{} errors, see debug output: {}'
+                         .format(len(msgs), msgs[-1]))
+            debug()
+        elif fd['require_alpha'] and not has_alpha(fmt):
+            ctx.fail('Missing expected alpha channel')
+            debug()
+        elif fd['w'] != w:
+            ctx.fail('Width mismatch, want {} got {}'
+                     .format(fd['w'], w))
+            debug()
+        elif fd['h'] != h:
+            ctx.fail('Height mismatch, want {} got {}'
+                     .format(fd['h'], h))
+            debug()
+        elif w != 1 and h != 1:
+            ctx.fail('v0 test protocol mandates w=1 or h=1')
+            debug()
+        else:
+            ctx.ok("Passed test as {}x{} {}".format(w, h, fmt))
+        sys.stdout.flush()
+
+    def test_ImageLoaderSDL2(self):
+        loadercls = LOADERS.get('ImageLoaderSDL2')
+        # GIF format not listed as supported in sdl2 loader
+        if loadercls:
+            exts = list(loadercls.extensions()) + ['gif']
+            ctx = self._test_imageloader(loadercls, exts)
+
+    def test_ImageLoaderPIL(self):
+        loadercls = LOADERS.get('ImageLoaderPIL')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_ImageLoaderPygame(self):
+        loadercls = LOADERS.get('ImageLoaderPygame')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_ImageLoaderFFPy(self):
+        loadercls = LOADERS.get('ImageLoaderFFPy')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_ImageLoaderGIF(self):
+        loadercls = LOADERS.get('ImageLoaderGIF')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_ImageLoaderDDS(self):
+        loadercls = LOADERS.get('ImageLoaderDDS')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_ImageLoaderTex(self):
+        loadercls = LOADERS.get('ImageLoaderTex')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_ImageLoaderImageIO(self):
+        loadercls = LOADERS.get('ImageLoaderImageIO')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_missing_tests(self):
+        for loader in ImageLoader.loaders:
+            key = 'test_{}'.format(loader.__name__)
+            msg = "Missing ImageLoader test case: {}".format(key)
+            self.assertTrue(hasattr(self, key), msg)
+            self.assertTrue(callable(getattr(self, key)), msg)
+
+
+class ConverterTestCase(unittest.TestCase):
+    def test_internal_converter_2x1(self):
+        correct = {
+            'rgba': b'\x01\x02\x03\xA1\x04\x05\x06\xA2',
+            'abgr': b'\xA1\x03\x02\x01\xA2\x06\x05\x04',
+            'bgra': b'\x03\x02\x01\xA1\x06\x05\x04\xA2',
+            'argb': b'\xA1\x01\x02\x03\xA2\x04\x05\x06',
+            'rgb': b'\x01\x02\x03\x04\x05\x06',
+            'bgr': b'\x03\x02\x01\x06\x05\x04',
+            'rgb_align4': b'\x01\x02\x03\x04\x05\x06\x00\x00',
+            'bgr_align4': b'\x03\x02\x01\x06\x05\x04\x00\x00'}
+        src = correct.get
+        rgba = src('rgba')
+        self.assertEqual(rgba_to(rgba, 'rgba', 2, 1, 0), src('rgba'))
+        self.assertEqual(rgba_to(rgba, 'abgr', 2, 1, 0), src('abgr'))
+        self.assertEqual(rgba_to(rgba, 'bgra', 2, 1, 0), src('bgra'))
+        self.assertEqual(rgba_to(rgba, 'argb', 2, 1, 0), src('argb'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 2, 1, 0), src('rgb'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 2, 1, 0), src('bgr'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 2, 1, None), src('rgb_align4'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 2, 1, None), src('bgr_align4'))
+
+    def test_internal_converter_3x1(self):
+        pad6 = b'\x00' * 6
+        correct = {
+            'rgba': b'\x01\x02\x03\xFF\x04\x05\x06\xFF\x07\x08\x09\xFF',
+            'abgr': b'\xFF\x03\x02\x01\xFF\x06\x05\x04\xFF\x09\x08\x07',
+            'bgra': b'\x03\x02\x01\xFF\x06\x05\x04\xFF\x09\x08\x07\xFF',
+            'argb': b'\xFF\x01\x02\x03\xFF\x04\x05\x06\xFF\x07\x08\x09',
+            'rgb_align2': b'\x01\x02\x03\x04\x05\x06\x07\x08\x09\x00',
+            'bgr_align2': b'\x03\x02\x01\x06\x05\x04\x09\x08\x07\x00',
+            'rgb_align8': b'\x01\x02\x03\x04\x05\x06\x07\x08\x09\x00' + pad6,
+            'bgr_align8': b'\x03\x02\x01\x06\x05\x04\x09\x08\x07\x00' + pad6}
+        src = correct.get
+        rgba = src('rgba')
+        self.assertEqual(rgba_to(rgba, 'bgra', 3, 1, 0), src('bgra'))
+        self.assertEqual(rgba_to(rgba, 'argb', 3, 1, 0), src('argb'))
+        self.assertEqual(rgba_to(rgba, 'abgr', 3, 1, 0), src('abgr'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 3, 1, 10), src('rgb_align2'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 3, 1, 10), src('bgr_align2'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 3, 1, 16), src('rgb_align8'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 3, 1, 16), src('bgr_align8'))
+
+    def test_internal_converter_1x3(self):
+        pad5 = b'\x00' * 5
+        correct = {
+            'rgba': b'\x01\x02\x03\xFF\x04\x05\x06\xFF\x07\x08\x09\xFF',
+            'rgb_raw': b'\x01\x02\x03\x04\x05\x06\x07\x08\x09',
+            'bgr_raw': b'\x03\x02\x01\x06\x05\x04\x09\x08\x07',
+            'rgb_align2': b'\x01\x02\x03\x00\x04\x05\x06\x00\x07\x08\x09\x00',
+            'bgr_align2': b'\x03\x02\x01\x00\x06\x05\x04\x00\x09\x08\x07\x00',
+            'rgb_align4': b'\x01\x02\x03\x00\x04\x05\x06\x00\x07\x08\x09\x00',
+            'bgr_align4': b'\x03\x02\x01\x00\x06\x05\x04\x00\x09\x08\x07\x00',
+            'rgb_align8': (b'\x01\x02\x03' + pad5 +
+                           b'\x04\x05\x06' + pad5 +
+                           b'\x07\x08\x09' + pad5),
+            'bgr_align8': (b'\x03\x02\x01' + pad5 +
+                           b'\x06\x05\x04' + pad5 +
+                           b'\x09\x08\x07' + pad5),
+        }
+        src = correct.get
+        rgba = src('rgba')
+        self.assertEqual(rgba_to(rgba, 'rgb', 1, 3, 4), src('rgb_align2'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 1, 3, 4), src('bgr_align2'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 1, 3, None), src('rgb_align4'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 1, 3, None), src('bgr_align4'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 1, 3, 0), src('rgb_raw'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 1, 3, 0), src('bgr_raw'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 1, 3, 8), src('rgb_align8'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 1, 3, 8), src('bgr_align8'))
+
+
+if __name__ == '__main__':
+    accept_filter = ['ImageLoader{}'.format(x) for x in sys.argv[1:]]
+    if accept_filter:
+        LOADERS = {x: LOADERS[x] for x in accept_filter}
+
+    DEBUG = True
+    unittest.main(argv=sys.argv[:1])

kivy/tests/test_invalid_lang.py

@@ -0,0 +1,42 @@
+
+import unittest
+
+
+class InvalidLangTestCase(unittest.TestCase):
+
+    def test_invalid_childname(self):
+        from kivy.lang import Builder, ParserException
+        from kivy.factory import FactoryException
+        try:
+            Builder.load_string('''
+Widget:
+    FloatLayout:
+        size: self.parent.size
+        Button:
+            text: "text"
+            size_hint:(0.1, 0.1)
+            pos_hint:{'x':0.45, 'y':0.45}
+    thecursor.Cursor:
+            ''')
+            self.fail('Invalid children name')
+        except ParserException:
+            pass
+        except FactoryException:
+            pass
+
+    def test_invalid_childname_before(self):
+        from kivy.lang import Builder, ParserException
+        try:
+            Builder.load_string('''
+Widget:
+    thecursor.Cursor:
+    FloatLayout:
+        size: self.parent.size
+        Button:
+            text: "text"
+            size_hint:(0.1, 0.1)
+            pos_hint:{'x':0.45, 'y':0.45}
+            ''')
+            self.fail('Invalid children name')
+        except ParserException:
+            pass