diff --git a/python/setup.py b/python/setup.py index 9a83072..e01f330 100644 --- a/python/setup.py +++ b/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', ) + diff --git a/python/test/__init__.py b/python/test/__init__.py new file mode 100644 index 0000000..5e1dc93 --- /dev/null +++ b/python/test/__init__.py @@ -0,0 +1,66 @@ +# -*- coding: utf8 -*- +# +# libcaca Colour ASCII Art library +# Python language bindings +# Copyright (c) 2012 Alex Foulon +# 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]) + diff --git a/python/test/canvas.py b/python/test/canvas.py new file mode 100644 index 0000000..542f5b1 --- /dev/null +++ b/python/test/canvas.py @@ -0,0 +1,329 @@ +# -*- coding: utf8 -*- +# +# libcaca Colour ASCII Art library +# Python language bindings +# Copyright (c) 2012 Alex Foulon +# 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) +