Add unittest for canvas module.

python/setup.py

@@ -1,12 +1,21 @@
 #!/usr/bin/env python
+#
+# Minimal setup.py script
+#
 
 from setuptools import setup
 
+import caca
+
 setup(
     name='caca',
-    version='0.0',
+    author='Alex Foulon',
+    author_email='alxf@lavabit.com',
+    version=caca.get_version(),
     packages=['caca'],
     package_dir={
         'caca': 'caca',
     },
+    test_suite='test.alltests',
 )
+

python/test/__init__.py

@@ -0,0 +1,66 @@
+# -*- coding: utf8 -*-
+#
+# libcaca            Colour ASCII Art library
+#                    Python language bindings
+# Copyright (c) 2012 Alex Foulon <alxf@lavabit.com>
+#                    All Rights Reserved
+#
+# This program is free software. It comes without any warranty, to
+# the extent permitted by applicable law. You can redistribute it
+# and/or modify it under the terms of the Do What The Fuck You Want
+# To Public License, Version 2, as published by Sam Hocevar. See
+# http://sam.zoy.org/wtfpl/COPYING for more details.
+#
+
+""" Test module """
+
+#standard module
+import unittest
+
+#test modules
+import canvas
+
+#create modules test suite
+canvas_t = unittest.TestSuite()
+
+#define tests for canvas_t test suite
+canvas_t.addTest(canvas.CanvasTestCase('test_create'))
+canvas_t.addTest(canvas.CanvasTestCase('test_get_width'))
+canvas_t.addTest(canvas.CanvasTestCase('test_get_height'))
+canvas_t.addTest(canvas.CanvasTestCase('test_set_size'))
+canvas_t.addTest(canvas.CanvasTestCase('test_get_char'))
+canvas_t.addTest(canvas.CanvasTestCase('test_put_char'))
+canvas_t.addTest(canvas.CanvasTestCase('test_put_str'))
+canvas_t.addTest(canvas.CanvasTestCase('test_printf'))
+canvas_t.addTest(canvas.CanvasTestCase('test_wherex'))
+canvas_t.addTest(canvas.CanvasTestCase('test_wherey'))
+canvas_t.addTest(canvas.CanvasTestCase('test_gotoxy'))
+canvas_t.addTest(canvas.CanvasTestCase('test_clear'))
+canvas_t.addTest(canvas.CanvasTestCase('test_get_handle_x'))
+canvas_t.addTest(canvas.CanvasTestCase('test_get_handle_y'))
+canvas_t.addTest(canvas.CanvasTestCase('test_set_handle'))
+canvas_t.addTest(canvas.CanvasTestCase('test_blit'))
+canvas_t.addTest(canvas.CanvasTestCase('test_blit_mask'))
+canvas_t.addTest(canvas.CanvasTestCase('test_set_boundaries'))
+canvas_t.addTest(canvas.CanvasTestCase('test_enable_dirty_rect'))
+canvas_t.addTest(canvas.CanvasTestCase('test_add_dirty_rect'))
+canvas_t.addTest(canvas.CanvasTestCase('test_remove_dirty_rect'))
+canvas_t.addTest(canvas.CanvasTestCase('test_draw_line'))
+canvas_t.addTest(canvas.CanvasTestCase('test_draw_thin_line'))
+canvas_t.addTest(canvas.CanvasTestCase('test_draw_polyline'))
+canvas_t.addTest(canvas.CanvasTestCase('test_draw_thin_polyline'))
+canvas_t.addTest(canvas.CanvasTestCase('test_draw_circle'))
+canvas_t.addTest(canvas.CanvasTestCase('test_draw_ellipse'))
+canvas_t.addTest(canvas.CanvasTestCase('test_draw_thin_ellipse'))
+canvas_t.addTest(canvas.CanvasTestCase('test_fill_ellipse'))
+canvas_t.addTest(canvas.CanvasTestCase('test_draw_box'))
+canvas_t.addTest(canvas.CanvasTestCase('test_draw_thin_box'))
+canvas_t.addTest(canvas.CanvasTestCase('test_draw_cp437_box'))
+canvas_t.addTest(canvas.CanvasTestCase('test_fill_box'))
+canvas_t.addTest(canvas.CanvasTestCase('test_draw_triangle'))
+canvas_t.addTest(canvas.CanvasTestCase('test_draw_thin_triangle'))
+canvas_t.addTest(canvas.CanvasTestCase('test_fill_triangle'))
+
+#configure all tests in a single suite
+alltests = unittest.TestSuite([canvas_t])
+

python/test/canvas.py

@@ -0,0 +1,329 @@
+# -*- coding: utf8 -*-
+#
+# libcaca            Colour ASCII Art library
+#                    Python language bindings
+# Copyright (c) 2012 Alex Foulon <alxf@lavabit.com>
+#                    All Rights Reserved
+#
+# This program is free software. It comes without any warranty, to
+# the extent permitted by applicable law. You can redistribute it
+# and/or modify it under the terms of the Do What The Fuck You Want
+# To Public License, Version 2, as published by Sam Hocevar. See
+# http://sam.zoy.org/wtfpl/COPYING for more details.
+#
+
+""" Libcaca canvas test suite """
+
+import unittest
+
+from caca.canvas import Canvas, CanvasError
+
+class CanvasTestCase(unittest.TestCase):
+    """ Class to test canvas functions.
+    """
+    def test_create(self):
+        """ module canvas: Canvas.__init__()
+        """
+        self.assertTrue(isinstance(Canvas(), Canvas))
+        self.assertTrue(isinstance(Canvas(10, 10), Canvas))
+        self.assertRaises(CanvasError, Canvas, "a", 12)
+        self.assertRaises(CanvasError, Canvas, 12, "a")
+
+    def test_get_width(self):
+        """ module canvas: Canvas.get_width()
+        """
+        cv = Canvas(5, 10)
+        self.assertEqual(5, cv.get_width())
+
+    def test_get_height(self):
+        """ module canvas: Canvas.get_width()
+        """
+        cv = Canvas(5, 10)
+        self.assertEqual(10, cv.get_height())
+
+    def test_set_size(self):
+        """ module canvas: Canvas.set_size()
+        """
+        cv = Canvas(0, 0)
+        cv.set_size(1234, 1001)
+
+        self.assertEqual((1234, 1001), (cv.get_width(), cv.get_height()))
+        self.assertRaises(CanvasError, cv.set_size, "a", 12)
+        self.assertRaises(CanvasError, cv.set_size, 12, "a")
+
+    def test_get_char(self):
+        """ module canvas: Canvas.get_char()
+        """
+        cv = Canvas(1, 1)
+        self.assertEqual(" ", cv.get_char(0, 0))
+
+    def test_put_char(self):
+        """ module canvas: Canvas.put_char()
+        """
+        cv = Canvas(10, 1)
+        self.assertEqual(1, cv.put_char(0, 0, "z"))
+        self.assertEqual(1, cv.put_char(1, 0, "é"))
+        self.assertEqual("z", cv.get_char(0, 0))
+        self.assertEqual("é", cv.get_char(1, 0))
+        self.assertRaises(CanvasError, cv.put_char, "a", 1, 2)
+        self.assertRaises(CanvasError, cv.put_char, "a", 1, "b")
+
+    def test_put_str(self):
+        """ module canvas: Canvas.put_str()
+        """
+        cv = Canvas(10, 1)
+        self.assertEqual(10, cv.put_str(0, 0, "teststring"))
+        liststring = []
+        for i in xrange(0, 10):
+            liststring.append(cv.get_char(i, 0))
+
+        self.assertEqual("teststring", "".join(liststring))
+        self.assertRaises(CanvasError, cv.put_str, 0, 0, 111)
+        self.assertRaises(CanvasError, cv.put_str, 0, "z", "abc")
+
+    def test_printf(self):
+        """ module canvas: Canvas.printf()
+        """
+        word1, word2 = "test", "string"
+        cv = Canvas(10, 1)
+        self.assertEqual(10, cv.printf(0, 0, "%s%s", word1, word2))
+        liststring = []
+        for i in xrange(0, 10):
+            liststring.append(cv.get_char(i, 0))
+        self.assertEqual("teststring", "".join(liststring))
+        self.assertRaises(CanvasError, cv.printf, 0, 0, 111)
+        self.assertRaises(CanvasError, cv.printf, 0, "z", "abc %s", "def")
+
+    def test_wherex(self):
+        """ module canvas: Canvas.wherex()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.wherex())
+
+    def test_wherey(self):
+        """ module canvas: Canvas.wherey()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.wherey())
+
+    def test_gotoxy(self):
+        """ module canvas: Canvas.gotoxy()
+        """
+        cv = Canvas(10, 10)
+        cv.gotoxy(5, 5)
+        self.assertEqual((5, 5), (cv.wherex(), cv.wherey()))
+        self.assertRaises(CanvasError, cv.gotoxy, "a", 9)
+        self.assertRaises(CanvasError, cv.gotoxy, 9, "a")
+
+    def test_clear(self):
+        """ module canvas: Canvas.clear()
+        """
+        cv = Canvas(5, 1)
+        cv.put_str(0, 0, "test!")
+        cv.clear()
+        data = cv.export_to_memory("utf8").strip('\n')
+        self.assertEqual("     ", data)
+
+    def test_get_handle_x(self):
+        """ module canvas: Canvas.get_handle_x()
+        """
+        cv = Canvas()
+        self.assertEqual(0, cv.get_handle_x())
+
+    def test_get_handle_y(self):
+        """ module canvas: Canvas.get_handle_y()
+        """
+        cv = Canvas()
+        self.assertEqual(0, cv.get_handle_y())
+
+    def test_set_handle(self):
+        """ module canvas: Canvas.set_handle()
+        """
+        cv = Canvas(10, 5)
+        self.assertEqual(0, cv.set_handle(3, 3))
+        self.assertEqual((3, 3), (cv.get_handle_x(), cv.get_handle_y()))
+        self.assertRaises(CanvasError, cv.set_handle, "a", 1)
+        self.assertRaises(CanvasError, cv.set_handle, 1, "a")
+
+    def test_blit(self):
+        """ module canvas: Canvas.blit()
+        """
+        cv1 = Canvas(10, 1)
+        cv2 = Canvas(10, 1)
+        cv2.put_str(0, 0, "teststring")
+        self.assertEqual(0, cv1.blit(0, 0, cv2))
+        self.assertEqual("teststring", cv1.export_to_memory("utf8").strip('\n'))
+        self.assertRaises(CanvasError, cv1.blit, 0, 0, "abc")
+        self.assertRaises(CanvasError, cv1.blit, "a", 0, cv2)
+
+    def test_blit_mask(self):
+        """ module canvas: Canvas.blit() (with mask)
+        """
+        cv1 = Canvas(10, 1)
+        cv2 = Canvas(10, 1)
+        mask = Canvas(10, 1)
+        badm = Canvas()
+        cv2.put_str(0, 0, "teststring")
+        mask.put_str(0, 0, "####")
+        self.assertEqual(0, cv1.blit(0, 0, cv2, mask))
+        self.assertEqual("test      ", cv1.export_to_memory("utf8").strip("\n"))
+        self.assertRaises(CanvasError, cv1.blit, 0, 0, cv2, badm)
+
+    def test_set_boundaries(self):
+        """ module canvas: Canvas.set_boundaries()
+        """
+        cv = Canvas()
+        self.assertEqual(0, cv.set_boundaries(0, 0, 10, 10))
+        self.assertEqual((10, 10), (cv.get_width(), cv.get_height()))
+        self.assertEqual(0, cv.set_boundaries(0, 0, 5, 5))
+        self.assertEqual((5, 5), (cv.get_width(), cv.get_height()))
+        self.assertRaises(CanvasError, cv.set_boundaries, "a", 0, 10, 10)
+        self.assertRaises(CanvasError, cv.set_boundaries, 0, 0, "abc", 10)
+
+    def test_enable_dirty_rect(self):
+        """ module canvas: Canvas.enable_dirty_rect()
+        """
+        cv = Canvas()
+        self.assertRaises(CanvasError, cv.enable_dirty_rect)
+        cv.disable_dirty_rect()
+        self.assertEqual(0, cv.enable_dirty_rect())
+
+    def test_add_dirty_rect(self):
+        """ module canvas: Canvas.add_dirty_rect()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.add_dirty_rect(4, 4, 2, 2))
+        self.assertRaises(CanvasError, cv.add_dirty_rect, 11, 11, 20, 20)
+
+    def test_remove_dirty_rect(self):
+        """ module canvas: Canvas.remove_dirty_rect()
+        """
+        cv = Canvas(10, 10)
+        cv.add_dirty_rect(4, 4, 2, 2)
+        self.assertEqual(0, cv.remove_dirty_rect(4, 4, 2, 2))
+        self.assertRaises(CanvasError, cv.remove_dirty_rect, 11, 11, 20, 20)
+
+    def test_draw_line(self):
+        """ module canvas: Canvas.draw_line()
+        """
+        cv = Canvas(10, 1)
+        cv.draw_line(0, 0, 10, 1, "#")
+        self.assertEqual("#" * 10, cv.export_to_memory("utf8").strip('\n'))
+        self.assertRaises(CanvasError, cv.draw_line, 0, 0, 10, 1, 7)
+        self.assertRaises(CanvasError, cv.draw_line, 0, "a", 10, 1, "#")
+
+    def test_draw_thin_line(self):
+        """ module canvas: Canvas.draw_thin_line()
+        """
+        cv = Canvas(10, 1)
+        cv.draw_thin_line(0, 0, 10, 1)
+        self.assertEqual("-" * 10, cv.export_to_memory("utf8").strip('\n'))
+        self.assertRaises(CanvasError, cv.draw_thin_line, 0, "a", 10, 1)
+
+    def test_draw_polyline(self):
+        """ module canvas: Canvas.draw_polyline()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.draw_polyline([(0, 0), (2, 2), (5, 2), (0, 0)],
+                                              '#'))
+        self.assertRaises(CanvasError, cv.draw_polyline, [], '#')
+        self.assertRaises(CanvasError, cv.draw_polyline, [0, 1, 2, 4], '#')
+
+    def test_draw_thin_polyline(self):
+        """ module canvas: Canvas.draw_thin_polyline()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.draw_thin_polyline([(0, 0), (2, 2),
+                                                   (5, 2), (0, 0)]))
+        self.assertRaises(CanvasError, cv.draw_thin_polyline, [])
+        self.assertRaises(CanvasError, cv.draw_thin_polyline, [0, 1, 2, 4])
+
+    def test_draw_circle(self):
+        """ module canvas: Canvas.draw_circle()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.draw_circle(5, 5, 3, '#'))
+        self.assertRaises(CanvasError, cv.draw_circle, 0, 0, '#', '#')
+        self.assertRaises(CanvasError, cv.draw_circle, 0, 0, 3, 0)
+
+    def test_draw_ellipse(self):
+        """ module canvas: Canvas.draw_ellipse()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.draw_ellipse(5, 5, 3, 4, '#'))
+        self.assertRaises(CanvasError, cv.draw_ellipse, 0, 0, 3, '#', '#')
+        self.assertRaises(CanvasError, cv.draw_ellipse, 0, 0, 3, 5, 0)
+
+    def test_draw_thin_ellipse(self):
+        """ module canvas: Canvas.draw_thin_ellipse()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.draw_thin_ellipse(5, 5, 3, 4))
+        self.assertRaises(CanvasError, cv.draw_thin_ellipse, 0, 0, 3, '#')
+
+    def test_fill_ellipse(self):
+        """ module canvas: Canvas.fill_ellipse()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.fill_ellipse(5, 5, 3, 3, '#'))
+        self.assertRaises(CanvasError, cv.fill_ellipse, 0, 0, 3, '#', '#')
+        self.assertRaises(CanvasError, cv.fill_ellipse, 0, 0, 3, 3, 0)
+
+    def test_draw_box(self):
+        """ module canvas: Canvas.draw_box()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.draw_box(0, 0, 2, 2, '#'))
+        self.assertRaises(CanvasError, cv.draw_box, 0, 0, 2, '#', '#')
+        self.assertRaises(CanvasError, cv.draw_box, 0, 0, 2, 2, 0)
+
+    def test_draw_thin_box(self):
+        """ module canvas: Canvas.draw_thin_box()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.draw_thin_box(0, 0, 2, 2))
+        self.assertRaises(CanvasError, cv.draw_thin_box, 0, 0, 2, '#')
+
+    def test_draw_cp437_box(self):
+        """ module canvas: Canvas.draw_cp437_box()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.draw_cp437_box(0, 0, 2, 2))
+        self.assertRaises(CanvasError, cv.draw_cp437_box, 0, 0, 2, '#')
+
+    def test_fill_box(self):
+        """ module canvas: Canvas.fill_box()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.fill_box(0, 0, 2, 2, '#'))
+        self.assertRaises(CanvasError, cv.fill_box, 0, 0, 2, '#', '#')
+        self.assertRaises(CanvasError, cv.fill_box, 0, 0, 2, 2, 0)
+
+    def test_draw_triangle(self):
+        """ module canvas: Canvas.draw_triangle()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.draw_triangle(0, 0, 2, 2, 4, 0, '#'))
+        self.assertRaises(CanvasError, cv.draw_triangle,
+                          0, 0, 2, 2, 4, '#', '#')
+        self.assertRaises(CanvasError, cv.draw_triangle,
+                          0, 0, 2, 2, 4, 0, 0)
+
+    def test_draw_thin_triangle(self):
+        """ module canvas: Canvas.draw_thin_triangle()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.draw_thin_triangle(0, 0, 2, 2, 4, 0))
+        self.assertRaises(CanvasError, cv.draw_thin_triangle,
+                          0, 0, 2, 2, 4, '#')
+
+    def test_fill_triangle(self):
+        """ module canvas: Canvas.fill_triangle()
+        """
+        cv = Canvas(10, 10)
+        self.assertEqual(0, cv.fill_triangle(0, 0, 2, 2, 4, 0, '#'))
+        self.assertRaises(CanvasError, cv.fill_triangle,
+                          0, 0, 2, 2, 4, '#', '#')
+        self.assertRaises(CanvasError, cv.fill_triangle,
+                          0, 0, 2, 2, 4, 0, 0)
+