split test files

Author: Matt Land

adafruit_imageload/pnm/pgm/__init__.py

@@ -28,16 +28,15 @@
 * Author(s): Matt Land, Brooke Storm, Sam McGahan
 
 """
-#import logging
+
 
 def load(file, magic_number, header, *, bitmap=None, palette=None):
     # TODO: remove unused variables later
     width = header[0]
     height = header[1]
-    max_colors = header[2]
+    max_colors = 6 #header[2]
     bitmap = bitmap(width, height, max_colors)
     colors = set()
-    pixel = bytearray()
 
 
     if max_colors > 256:
@@ -48,27 +47,24 @@ def load(file, magic_number, header, *, bitmap=None, palette=None):
         # Handle ascii
         for y in range(height):
             for x in range(width):
-            # Takes int and converts to an 8 bit
+                pixel = bytearray()
+                # Takes int and converts to an 8 bit
                 while True:
                     byte = file.read(1)  # type: byte
                     if not byte.isdigit():
                         break
                     pixel += byte
-
-                int_pixel = int("".join(["%c" % char for char in pixel]))
+                # convert b'255' to b'\xff'
+                int_pixel = bytes([int("".join(["%c" % char for char in pixel]))])
                 bitmap[x, y] = int_pixel
                 colors.add(int_pixel)
                 # logging.info(f'{x}, {y}, {byte}, {int_pixel}')
         if palette:
             palette = palette(len(colors))
             for counter, color in enumerate(colors):
-                color_bytearray = bytearray()
-                for i in range(3):
-                    color_bytearray += bytes([color])
-                palette[counter] = color_bytearray
+                palette[counter] = color
         return bitmap, palette
 
-
     if magic_number == b'P5': # To handle binary PGM files.
         for y in range(height):
             for x in range(width):
@@ -79,7 +75,6 @@ def load(file, magic_number, header, *, bitmap=None, palette=None):
                 bitmap[x, y] = int_pixel
                 colors.add(int_pixel)
 
-
         if palette:
             palette = palette(len(colors))
             for counter, color in enumerate(colors):
@@ -90,4 +85,4 @@ def load(file, magic_number, header, *, bitmap=None, palette=None):
 
         return bitmap, palette
 
-    raise NotImplementedError("Was not able to send image")
+    raise NotImplementedError("Was not able to send image")

adafruit_imageload/tests/displayio_shared_bindings.py

@@ -0,0 +1,87 @@
+
+
+class Bitmap_C_Interface(object):
+    """
+    Simulates the displayio.Bitmap class for testing
+    """
+    def __init__(self, width, height, colors):
+        self.width = width
+        self.height = height
+        self.colors = colors
+        self.data = {}
+
+    def _abs_pos(self, width: int, height: int) -> int:
+        if height > self.height - 1:
+            raise ValueError("height > max")
+        if width > self.width - 1:
+            raise ValueError("width > max")
+        return width + (height * self.width)
+
+    def _decode(self, position: int) -> tuple:
+        return position % self.width, position // self.width
+
+    def __setitem__(self, key: tuple, value: int):
+        if isinstance(key, tuple):
+            # order is X, Y from the docs https://github.com/adafruit/circuitpython/blob/master/shared-bindings/displayio/Bitmap.c
+            self.__setitem__(self._abs_pos(key[0], key[1]), value)
+            return
+        if not isinstance(value, (int,bytes)):
+            raise RuntimeError(f"set value as int or bytes, not {type(value)}")
+        if isinstance(value, int) and value > 255:
+            raise ValueError(f'pixel value {value} too large')
+        if isinstance(value, bytes) and value > b'\xff':
+            raise ValueError(f'pixel value {value} too large')
+        self.data[key] = value
+
+    def __getitem__(self, item: tuple) -> bytearray:
+        if isinstance(item, tuple):
+            return self.__getitem__(self._abs_pos(item[0], item[1]))
+        # if item > self.height * self.width:
+        #    raise RuntimeError('illegal item position {}'.format(item))
+        try:
+            return self.data[item]
+        except KeyError:
+            raise RuntimeError("no data at {} [{}]".format(self._decode(item), item))
+
+    def validate(self):
+        if not self.data:
+            raise ValueError("no rows were set / no data in memory")
+        for i in range(self.height * self.width, 0):
+            try:
+                self.data[i]
+            except KeyError:
+                raise ValueError("missing data at {i}")
+
+    def __str__(self):
+        out = "\n"
+        for y in range(self.height):
+            for x in range(self.width):
+                data = self[x, y]
+                out += f"{data:>4}"
+            out += "\n"
+        return out
+
+
+class Palette_C_Interface(object):
+    """
+    Simulates the displayio.Palette class for testing
+    """
+    def __init__(self, num_colors):
+        self.num_colors = num_colors
+        self.colors = {}
+
+    def __setitem__(self, key, value):
+        self.colors[key] = value
+
+    def validate(self):
+        if not self.colors:
+            raise ValueError("no palette colors were set")
+        if len(self.colors) > self.num_colors:
+            raise ValueError("too many colors inserted into palette")
+        if len(self.colors) < self.num_colors:
+            raise ValueError("too few colors inserted into palette")
+        for i in range(self.num_colors):
+            try:
+                self.colors
+            except IndexError:
+                raise ValueError('missing color `{}` in palette color list'.format(i))

adafruit_imageload/tests/shared_binding_interface.py

@@ -0,0 +1,78 @@
+from unittest import TestCase
+from .displayio_shared_bindings import Bitmap_C_Interface
+
+
+class TestBitmap_C(TestCase):
+    def test_init(self):
+        b = Bitmap_C_Interface(2, 4, 1)
+        self.assertEqual(2, b.width)
+        self.assertEqual(4, b.height)
+        self.assertEqual(1, b.colors)
+
+    def test_abs(self):
+        b = Bitmap_C_Interface(5, 2, 1)
+        self.assertEqual(9, b._abs_pos(4,1))
+
+    def test_set_tuple(self):
+        b = Bitmap_C_Interface(2, 4, 1)
+        b[1, 3] = 67
+        self.assertEqual(b[1, 3], 67)
+
+    def test_set_abs(self):
+        b = Bitmap_C_Interface(2, 4, 1)
+        b[0] = 42
+        self.assertEqual(b[0], 42)
+
+    def test_abs_and_tuple(self):
+        b = Bitmap_C_Interface(2, 4, 1)
+        b[7] = 101
+        self.assertEqual(101, b[1, 3])
+
+    def test_non_zero(self):
+        b = Bitmap_C_Interface(2, 4, 1)
+        b[1, 1] = 100
+        self.assertEqual(100, b[1, 1])
+
+    def test_throws_x_out_of_range(self):
+        b = Bitmap_C_Interface(2, 4, 1)
+        try:
+            b[2, 1] = 100
+            self.fail("should have thrown")
+        except ValueError:
+            pass
+
+    def test_max(self):
+        b = Bitmap_C_Interface(2, 4, 1)
+        b[1, 1] = 66
+        self.assertEqual(66, b[1, 1])
+
+    def test_uninitialized(self):
+        b = Bitmap_C_Interface(2, 4, 1)
+        try:
+            b[1, 1]
+            self.fail("should have thrown")
+        except RuntimeError:
+            pass
+
+    def test_validate_throws(self):
+        b = Bitmap_C_Interface(2, 4, 1)
+        try:
+            b.validate()
+        except ValueError:
+            pass
+
+    def test_repr(self):
+        b = Bitmap_C_Interface(3, 2, 1)
+        b[0, 0] = 1
+        b[1, 0] = 0
+        b[2, 0] = 0
+        b[0, 1] = 1
+        b[1, 1] = 1
+        b[2, 1] = 0
+        self.assertEqual("\n   1   0   0\n   1   1   0\n", str(b))
+
+    def test_decode(self):
+        b = Bitmap_C_Interface(4, 4, 1)
+        self.assertEqual((0, 0), b._decode(0))
+        encoded = b._abs_pos(3, 3)
+        self.assertEqual((3, 3), b._decode(encoded))

adafruit_imageload/tests/test_bitmap_c_interface.py

@@ -0,0 +1,80 @@
+from unittest import TestCase
+from adafruit_imageload import pnm
+from io import BytesIO
+import os
+from .displayio_shared_bindings import Bitmap_C_Interface, Palette_C_Interface
+
+
+class TestPnmLoad(TestCase):
+    def test_load_fails_with_no_header_data(self):
+        f = BytesIO(b"some initial binary data: \x00\x01")
+        try:
+            pnm.load(f, b"P1", bitmap=Bitmap_C_Interface, palette=Palette_C_Interface)
+            self.fail("should have failed")
+        except Exception as e:
+            if "Unsupported image format" not in str(e):
+                raise
+
+    def test_load_works_p1_ascii(self):
+        test_file = os.path.join(
+            os.path.dirname(__file__),
+            "..",
+            "..",
+            "examples",
+            "images",
+            "netpbm_p1_mono_ascii.pbm",
+        )
+        with open(test_file, "rb") as f:
+            bitmap, palette = pnm.load(f, b"P1", bitmap=Bitmap_C_Interface, palette=Palette_C_Interface)
+        self.assertTrue(isinstance(bitmap, Bitmap_C_Interface), bitmap)
+        self.assertEqual(1, bitmap.colors)
+        self.assertEqual(13, bitmap.width)
+        self.assertEqual(21, bitmap.height)
+
+        bitmap.validate()
+        self.assertEqual(0, bitmap[0])  # check first row
+        self.assertEqual(1, bitmap[11, 1])  # check second row
+
+        self.assertEqual(1, palette.num_colors)
+        palette.validate()
+
+    def test_load_works_p4_in_mem(self):
+        f = BytesIO(b"P4\n4 2\n\x55")
+        bitmap, palette = pnm.load(f, b"P4", bitmap=Bitmap_C_Interface)
+        self.assertEqual(4, bitmap.width)
+        self.assertEqual(2, bitmap.height)
+        bitmap.validate()
+        self.assertEqual("\n   1   0   1   0\n   1   0   1   0\n", str(bitmap))
+
+    def test_load_works_p4_binary(self):
+        test_file = os.path.join(
+            os.path.dirname(__file__),
+            "..",
+            "..",
+            "examples",
+            "images",
+            "netpbm_p4_mono_binary.pbm",
+        )
+        with open(test_file, "rb") as f:
+            bitmap, palette = pnm.load(f, b"P4", bitmap=Bitmap_C_Interface)
+        self.assertTrue(isinstance(bitmap, Bitmap_C_Interface))
+        self.assertEqual(1, bitmap.colors)
+        self.assertEqual(32, bitmap.width)
+        self.assertEqual(15, bitmap.height)
+        bitmap.validate()
+
+    def test_load_works_p4_binary_high_res(self):
+        test_file = os.path.join(
+            os.path.dirname(__file__),
+            "..",
+            "..",
+            "examples",
+            "images",
+            "netpbm_p4_mono_large.pbm",
+        )
+        with open(test_file, "rb") as f:
+            bitmap, palette = pnm.load(f, b"P4", bitmap=Bitmap_C_Interface)
+        self.assertTrue(isinstance(bitmap, Bitmap_C_Interface))
+        self.assertEqual(1, bitmap.colors)
+        self.assertEqual(320, bitmap.width)
+        self.assertEqual(240, bitmap.height)

adafruit_imageload/tests/test_pbm_load.py

@@ -0,0 +1,47 @@
+import os
+import logging
+from unittest import TestCase
+from adafruit_imageload import pnm
+from .displayio_shared_bindings import Bitmap_C_Interface, Palette_C_Interface
+
+logging.getLogger().setLevel(logging.DEBUG)
+
+
+class TestPgmLoad(TestCase):
+    def test_load_works_p2_ascii(self):
+        test_file = os.path.join(
+            os.path.dirname(__file__),
+            "..",
+            "..",
+            "examples",
+            "images",
+            "netpbm_p2_ascii.pgm",
+        )
+        with open(test_file, "rb") as f:
+            bitmap, palette = pnm.load(f, b"P2", bitmap=Bitmap_C_Interface, palette=Palette_C_Interface)
+        self.assertTrue(isinstance(bitmap, Bitmap_C_Interface), bitmap)
+        self.assertEqual(6, bitmap.colors)
+        self.assertEqual(8, bitmap.width)
+        self.assertEqual(8, bitmap.height)
+        bitmap.validate()
+        self.assertEqual(6, palette.num_colors)
+        palette.validate()
+
+    def test_load_works_p5_binary(self):
+        test_file = os.path.join(
+            os.path.dirname(__file__),
+            "..",
+            "..",
+            "examples",
+            "images",
+            "netpbm_p5_binary.pgm",
+        )
+        with open(test_file, "rb") as f:
+            bitmap, palette = pnm.load(f, b"P5", bitmap=Bitmap_C_Interface, palette=Palette_C_Interface)
+        self.assertTrue(isinstance(bitmap, Bitmap_C_Interface), bitmap)
+        self.assertEqual(8, bitmap.colors)
+        self.assertEqual(8, bitmap.width)
+        self.assertEqual(8, bitmap.height)
+        bitmap.validate()
+        self.assertEqual(8, palette.num_colors)
+        palette.validate()