Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
devel:languages:python:misc
python-djvulibre
remove-all-dependencies-on-nose-in-the-code.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File remove-all-dependencies-on-nose-in-the-code.patch of Package python-djvulibre
From 732f72871f38640e3e9931b4d1e1250b47072b48 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mat=C4=9Bj=20Cepl?= <mcepl@cepl.eu> Date: Mon, 26 Jul 2021 09:24:45 +0200 Subject: [PATCH] Remove all dependencies on nose in the code. --- tests/test_const.py | 72 ++-- tests/test_decode.py | 955 +++++++++++++++++++++---------------------- tests/test_sexpr.py | 520 ++++++++++++----------- tests/tools.py | 133 +----- 4 files changed, 763 insertions(+), 917 deletions(-) diff --git a/tests/test_const.py b/tests/test_const.py index 6679bcc..4c40b27 100644 --- a/tests/test_const.py +++ b/tests/test_const.py @@ -13,6 +13,8 @@ # or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for # more details. +import unittest + from djvu.const import ( TEXT_ZONE_CHARACTER, TEXT_ZONE_COLUMN, @@ -29,21 +31,10 @@ from djvu.sexpr import ( Symbol, ) -from tools import ( - assert_equal, - assert_is, - assert_is_instance, - assert_list_equal, - assert_not_equal, - assert_raises_str, - assert_repr, - wildcard_import, - # Python 2/3 compat: - cmp, -) - -class test_text_zones(): +# Py2, Py3 compatibility shim +from tools import cmp +class test_text_zones(unittest.TestCase): zones = [ TEXT_ZONE_PAGE, TEXT_ZONE_COLUMN, @@ -56,42 +47,42 @@ class test_text_zones(): def test_type(self): for zone in self.zones: - assert_equal(type(zone), TextZoneType) - assert_is_instance(zone, Symbol) + self.assertEqual(type(zone), TextZoneType) + self.assertIsInstance(zone, Symbol) def test_repr(self): - assert_repr(TEXT_ZONE_PAGE, '<djvu.const.TextZoneType: page>') - assert_repr(TEXT_ZONE_COLUMN, '<djvu.const.TextZoneType: column>') - assert_repr(TEXT_ZONE_REGION, '<djvu.const.TextZoneType: region>') - assert_repr(TEXT_ZONE_PARAGRAPH, '<djvu.const.TextZoneType: para>') - assert_repr(TEXT_ZONE_LINE, '<djvu.const.TextZoneType: line>') - assert_repr(TEXT_ZONE_WORD, '<djvu.const.TextZoneType: word>') - assert_repr(TEXT_ZONE_CHARACTER, '<djvu.const.TextZoneType: char>') + self.assertEqual(repr(TEXT_ZONE_PAGE), '<djvu.const.TextZoneType: page>') + self.assertEqual(repr(TEXT_ZONE_COLUMN), '<djvu.const.TextZoneType: column>') + self.assertEqual(repr(TEXT_ZONE_REGION), '<djvu.const.TextZoneType: region>') + self.assertEqual(repr(TEXT_ZONE_PARAGRAPH), '<djvu.const.TextZoneType: para>') + self.assertEqual(repr(TEXT_ZONE_LINE), '<djvu.const.TextZoneType: line>') + self.assertEqual(repr(TEXT_ZONE_WORD), '<djvu.const.TextZoneType: word>') + self.assertEqual(repr(TEXT_ZONE_CHARACTER), '<djvu.const.TextZoneType: char>') def test_identity(self): - assert_is(TEXT_ZONE_PAGE, get_text_zone_type(Symbol('page'))) - assert_is(TEXT_ZONE_COLUMN, get_text_zone_type(Symbol('column'))) - assert_is(TEXT_ZONE_REGION, get_text_zone_type(Symbol('region'))) - assert_is(TEXT_ZONE_PARAGRAPH, get_text_zone_type(Symbol('para'))) - assert_is(TEXT_ZONE_LINE, get_text_zone_type(Symbol('line'))) - assert_is(TEXT_ZONE_WORD, get_text_zone_type(Symbol('word'))) - assert_is(TEXT_ZONE_CHARACTER, get_text_zone_type(Symbol('char'))) + self.assertIs(TEXT_ZONE_PAGE, get_text_zone_type(Symbol('page'))) + self.assertIs(TEXT_ZONE_COLUMN, get_text_zone_type(Symbol('column'))) + self.assertIs(TEXT_ZONE_REGION, get_text_zone_type(Symbol('region'))) + self.assertIs(TEXT_ZONE_PARAGRAPH, get_text_zone_type(Symbol('para'))) + self.assertIs(TEXT_ZONE_LINE, get_text_zone_type(Symbol('line'))) + self.assertIs(TEXT_ZONE_WORD, get_text_zone_type(Symbol('word'))) + self.assertIs(TEXT_ZONE_CHARACTER, get_text_zone_type(Symbol('char'))) def test_comparison1(self): - assert_not_equal(TEXT_ZONE_PAGE, '') - assert_not_equal(TEXT_ZONE_PAGE, 42) - with assert_raises_str(TypeError, 'cannot compare text zone type with other object'): + self.assertNotEqual(TEXT_ZONE_PAGE, '') + self.assertNotEqual(TEXT_ZONE_PAGE, 42) + with self.assertRaisesRegex(TypeError, 'cannot compare text zone type with other object'): TEXT_ZONE_PAGE < 42 - with assert_raises_str(TypeError, 'cannot compare text zone type with other object'): + with self.assertRaisesRegex(TypeError, 'cannot compare text zone type with other object'): TEXT_ZONE_PAGE <= 42 - with assert_raises_str(TypeError, 'cannot compare text zone type with other object'): + with self.assertRaisesRegex(TypeError, 'cannot compare text zone type with other object'): TEXT_ZONE_PAGE > 42 - with assert_raises_str(TypeError, 'cannot compare text zone type with other object'): + with self.assertRaisesRegex(TypeError, 'cannot compare text zone type with other object'): TEXT_ZONE_PAGE >= 42 def test_comparison2(self): - assert_equal(self.zones, sorted(self.zones, reverse=True)) - assert_equal( + self.assertEqual(self.zones, sorted(self.zones, reverse=True)) + self.assertEqual( [[cmp(z1, z2) for z1 in self.zones] for z2 in self.zones], [ [0, -1, -1, -1, -1, -1, -1], [+1, 0, -1, -1, -1, -1, -1], @@ -104,8 +95,9 @@ class test_text_zones(): ) def test_wildcard_import(): - ns = wildcard_import('djvu.const') - assert_list_equal( + ns = {} + exec("from djvu.const import *", {}, ns) + self.assertEqual( sorted(ns.keys()), [ 'ANNOTATION_ALIGN', 'ANNOTATION_BACKGROUND', diff --git a/tests/test_decode.py b/tests/test_decode.py index 44a4418..a90f4e1 100644 --- a/tests/test_decode.py +++ b/tests/test_decode.py @@ -21,6 +21,7 @@ import shutil import sys import tempfile import warnings +import unittest if sys.version_info >= (3, 2): import subprocess @@ -86,18 +87,6 @@ from djvu.sexpr import ( ) from tools import ( - assert_equal, - assert_false, - assert_is, - assert_is_instance, - assert_list_equal, - assert_multi_line_equal, - assert_raises, - assert_raises_regex, - assert_raises_str, - assert_repr, - assert_true, - SkipTest, skip_unless_c_messages, skip_unless_command_exists, skip_unless_translation_exists, @@ -114,71 +103,70 @@ from tools import ( images = os.path.join(os.path.dirname(__file__), 'images', '') -if sys.version_info >= (3, 2): - array_tobytes = array.array.tobytes -else: - array_tobytes = array.array.tostring +class TestBase(unittest.TestCase): + @staticmethod + def run_cmd(*cmd, **kwargs): + stdin = kwargs.pop('stdin', None) + env = dict(os.environ) + for key, value in kwargs.items(): + if key.isupper(): + env[key] = value + continue + raise TypeError('{key!r} is an invalid keyword argument for this function'.format(key=key)) + kwargs = dict( + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + env=env, + ) + if stdin is not None: + kwargs.update(stdin=subprocess.PIPE) + child = subprocess.Popen(list(cmd), **kwargs) + (stdout, stderr) = child.communicate(stdin) + if child.returncode != 0: + raise subprocess.CalledProcessError(child.returncode, cmd[0]) + return (stdout, stderr) -if sys.version_info < (2, 7): - memoryview = None # make pyflakes happy + def create_djvu(self, commands='', sexpr=''): + skip_unless_command_exists('djvused') + if sexpr: + commands += '\nset-ant\n{sexpr}\n.\n'.format(sexpr=sexpr) + file = tempfile.NamedTemporaryFile(prefix='test', suffix='djvu') + file.seek(0) + file.write( + b'\x41\x54\x26\x54\x46\x4F\x52\x4D\x00\x00\x00\x22\x44\x4A\x56\x55' + b'\x49\x4E\x46\x4F\x00\x00\x00\x0A\x00\x01\x00\x01\x18\x00\x2C\x01' + b'\x16\x01\x53\x6A\x62\x7A\x00\x00\x00\x04\xBC\x73\x1B\xD7' + ) + file.flush() + (stdout, stderr) = self.run_cmd('djvused', '-s', file.name, stdin=commands.encode(locale_encoding)) + self.assertEqual(stdout, ''.encode(locale_encoding)) + self.assertEqual(stderr, ''.encode(locale_encoding)) + return file -def run(*cmd, **kwargs): - stdin = kwargs.pop('stdin', None) - env = dict(os.environ) - for key, value in kwargs.items(): - if key.isupper(): - env[key] = value - continue - raise TypeError('{key!r} is an invalid keyword argument for this function'.format(key=key)) - kwargs = dict( - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, - env=env, - ) - if stdin is not None: - kwargs.update(stdin=subprocess.PIPE) - child = subprocess.Popen(list(cmd), **kwargs) - (stdout, stderr) = child.communicate(stdin) - if child.returncode != 0: - raise subprocess.CalledProcessError(child.returncode, cmd[0]) - return (stdout, stderr) - -def create_djvu(commands='', sexpr=''): - skip_unless_command_exists('djvused') - if sexpr: - commands += '\nset-ant\n{sexpr}\n.\n'.format(sexpr=sexpr) - file = tempfile.NamedTemporaryFile(prefix='test', suffix='djvu') - file.seek(0) - file.write( - b'\x41\x54\x26\x54\x46\x4F\x52\x4D\x00\x00\x00\x22\x44\x4A\x56\x55' - b'\x49\x4E\x46\x4F\x00\x00\x00\x0A\x00\x01\x00\x01\x18\x00\x2C\x01' - b'\x16\x01\x53\x6A\x62\x7A\x00\x00\x00\x04\xBC\x73\x1B\xD7' - ) - file.flush() - (stdout, stderr) = run('djvused', '-s', file.name, stdin=commands.encode(locale_encoding)) - assert_equal(stdout, ''.encode(locale_encoding)) - assert_equal(stderr, ''.encode(locale_encoding)) - return file - -def test_context_cache(): - context = Context() - assert_equal(context.cache_size, 10 << 20) - for n in -100, 0, 1 << 31: - with assert_raises_str(ValueError, '0 < cache_size < (2 ** 31) must be satisfied'): + # Not used by anything + def test_context_cache(self): + context = Context() + self.assertEqual(context.cache_size, 10 << 20) + for n in -100, 0, 1 << 31: + with self.assertRaisesRegex( + ValueError, + r'0 < cache_size < \(2 \*\* 31\) must be satisfied'): + context.cache_size = n + with self.assertRaisesRegex( + ValueError, + r'0 < cache_size < \(2 \*\* 31\) must be satisfied'): + context.cache_size = 0 + n = 1 + while n < (1 << 31): context.cache_size = n - with assert_raises_str(ValueError, '0 < cache_size < (2 ** 31) must be satisfied'): - context.cache_size = 0 - n = 1 - while n < (1 << 31): - context.cache_size = n - assert_equal(context.cache_size, n) - n = (n + 1) * 2 - 1 - context.clear_cache() + self.assertEqual(context.cache_size, n) + n = (n + 1) * 2 - 1 + context.clear_cache() -class test_documents: +class test_documents(TestBase): def test_bad_new(self): - with assert_raises_str(TypeError, "cannot create 'djvu.decode.Document' instances"): + with self.assertRaisesRegex(TypeError, r"cannot create 'djvu.decode.Document' instances"): Document() def test_nonexistent(self): @@ -189,20 +177,20 @@ class test_documents: c_message = ex.args[1] else: raise OSError(errno.EEXIST, os.strerror(errno.EEXIST), path) - c_message.encode('ASCII') + c_message.encode('utf-8') skip_unless_c_messages() context = Context() - with assert_raises(JobFailed): + with self.assertRaises(JobFailed): context.new_document(FileUri(path)) message = context.get_message() - assert_equal(type(message), ErrorMessage) - assert_equal(type(message.message), unicode) - assert_equal( + self.assertEqual(type(message), ErrorMessage) + self.assertEqual(type(message.message), unicode) + self.assertEqual( message.message, "[1-11711] Failed to open '{path}': {msg}.".format(path=path, msg=c_message) ) - assert_equal(str(message), message.message) - assert_equal(unicode(message), message.message) + self.assertEqual(str(message), message.message) + self.assertEqual(unicode(message), message.message) def test_nonexistent_ja(self): skip_unless_c_messages() @@ -225,57 +213,57 @@ class test_documents: 'ja_JP error message is ASCII-only: {msg!r}'.format(msg=c_message) ) with interim_locale(LC_ALL='ja_JP.UTF-8'): - with assert_raises(JobFailed): + with self.assertRaises(JobFailed): context.new_document(FileUri(path)) message = context.get_message() - assert_equal(type(message), ErrorMessage) - assert_equal(type(message.message), unicode) - assert_equal( + self.assertEqual(type(message), ErrorMessage) + self.assertEqual(type(message.message), unicode) + self.assertEqual( message.message, u("[1-11711] Failed to open '{path}': {msg}.".format(path=path, msg=c_message)) ) - assert_equal( + self.assertEqual( str(message), "[1-11711] Failed to open '{path}': {msg}.".format(path=path, msg=c_message) ) - assert_equal(unicode(message), message.message) + self.assertEqual(unicode(message), message.message) def test_new_document(self): context = Context() document = context.new_document(FileUri(images + 'test1.djvu')) - assert_equal(type(document), Document) + self.assertEqual(type(document), Document) message = document.get_message() - assert_equal(type(message), DocInfoMessage) - assert_true(document.decoding_done) - assert_false(document.decoding_error) - assert_equal(document.decoding_status, JobOK) - assert_equal(document.type, DOCUMENT_TYPE_SINGLE_PAGE) - assert_equal(len(document.pages), 1) - assert_equal(len(document.files), 1) + self.assertEqual(type(message), DocInfoMessage) + self.assertTrue(document.decoding_done) + self.assertFalse(document.decoding_error) + self.assertEqual(document.decoding_status, JobOK) + self.assertEqual(document.type, DOCUMENT_TYPE_SINGLE_PAGE) + self.assertEqual(len(document.pages), 1) + self.assertEqual(len(document.files), 1) decoding_job = document.decoding_job - assert_true(decoding_job.is_done) - assert_false(decoding_job.is_error) - assert_equal(decoding_job.status, JobOK) + self.assertTrue(decoding_job.is_done) + self.assertFalse(decoding_job.is_error) + self.assertEqual(decoding_job.status, JobOK) file = document.files[0] - assert_is(type(file), File) - assert_is(file.document, document) - assert_is(file.get_info(), None) - assert_equal(file.type, 'P') - assert_equal(file.n_page, 0) + self.assertIs(type(file), File) + self.assertIs(file.document, document) + self.assertIs(file.get_info(), None) + self.assertEqual(file.type, 'P') + self.assertEqual(file.n_page, 0) page = file.page - assert_equal(type(page), Page) - assert_is(page.document, document) - assert_equal(page.n, 0) - assert_is(file.size, None) - assert_equal(file.id, u('test1.djvu')) - assert_equal(type(file.id), unicode) - assert_equal(file.name, u('test1.djvu')) - assert_equal(type(file.name), unicode) - assert_equal(file.title, u('test1.djvu')) - assert_equal(type(file.title), unicode) + self.assertEqual(type(page), Page) + self.assertIs(page.document, document) + self.assertEqual(page.n, 0) + self.assertIs(file.size, None) + self.assertEqual(file.id, u('test1.djvu')) + self.assertEqual(type(file.id), unicode) + self.assertEqual(file.name, u('test1.djvu')) + self.assertEqual(type(file.name), unicode) + self.assertEqual(file.title, u('test1.djvu')) + self.assertEqual(type(file.title), unicode) dump = document.files[0].dump - assert_equal(type(dump), unicode) - assert_equal( + self.assertEqual(type(dump), unicode) + self.assertEqual( [line for line in dump.splitlines()], [ u(' FORM:DJVU [83] '), u(' INFO [10] DjVu 64x48, v24, 300 dpi, gamma=2.2'), @@ -283,40 +271,40 @@ class test_documents: ] ) page = document.pages[0] - assert_equal(type(page), Page) - assert_is(page.document, document) - assert_is(page.get_info(), None) - assert_equal(page.width, 64) - assert_equal(page.height, 48) - assert_equal(page.size, (64, 48)) - assert_equal(page.dpi, 300) - assert_equal(page.rotation, 0) - assert_equal(page.version, 24) + self.assertEqual(type(page), Page) + self.assertIs(page.document, document) + self.assertIs(page.get_info(), None) + self.assertEqual(page.width, 64) + self.assertEqual(page.height, 48) + self.assertEqual(page.size, (64, 48)) + self.assertEqual(page.dpi, 300) + self.assertEqual(page.rotation, 0) + self.assertEqual(page.version, 24) file = page.file - assert_equal(type(file), File) - assert_equal(file.id, u('test1.djvu')) - assert_equal(type(file.id), unicode) + self.assertEqual(type(file), File) + self.assertEqual(file.id, u('test1.djvu')) + self.assertEqual(type(file.id), unicode) dump = document.files[0].dump - assert_equal(type(dump), unicode) - assert_equal( + self.assertEqual(type(dump), unicode) + self.assertEqual( [line for line in dump.splitlines()], [ u(' FORM:DJVU [83] '), u(' INFO [10] DjVu 64x48, v24, 300 dpi, gamma=2.2'), u(' Sjbz [53] JB2 bilevel data'), ] ) - assert_is(document.get_message(wait=False), None) - assert_is(context.get_message(wait=False), None) - with assert_raises_str(IndexError, 'file number out of range'): + self.assertIs(document.get_message(wait=False), None) + self.assertIs(context.get_message(wait=False), None) + with self.assertRaisesRegex(IndexError, 'file number out of range'): document.files[-1].get_info() - assert_is(document.get_message(wait=False), None) - assert_is(context.get_message(wait=False), None) - with assert_raises_str(IndexError, 'page number out of range'): + self.assertIs(document.get_message(wait=False), None) + self.assertIs(context.get_message(wait=False), None) + with self.assertRaisesRegex(IndexError, 'page number out of range'): document.pages[-1] - with assert_raises_str(IndexError, 'page number out of range'): + with self.assertRaisesRegex(IndexError, 'page number out of range'): document.pages[1] - assert_is(document.get_message(wait=False), None) - assert_is(context.get_message(wait=False), None) + self.assertIs(document.get_message(wait=False), None) + self.assertIs(context.get_message(wait=False), None) def test_save(self): skip_unless_command_exists('djvudump') @@ -324,28 +312,28 @@ class test_documents: original_filename = images + 'test0.djvu' document = context.new_document(FileUri(original_filename)) message = document.get_message() - assert_equal(type(message), DocInfoMessage) - assert_true(document.decoding_done) - assert_false(document.decoding_error) - assert_equal(document.decoding_status, JobOK) - assert_equal(document.type, DOCUMENT_TYPE_BUNDLED) - assert_equal(len(document.pages), 2) - assert_equal(len(document.files), 3) - (stdout0, stderr0) = run('djvudump', original_filename, LC_ALL='C') - assert_equal(stderr0, b'') + self.assertEqual(type(message), DocInfoMessage) + self.assertTrue(document.decoding_done) + self.assertFalse(document.decoding_error) + self.assertEqual(document.decoding_status, JobOK) + self.assertEqual(document.type, DOCUMENT_TYPE_BUNDLED) + self.assertEqual(len(document.pages), 2) + self.assertEqual(len(document.files), 3) + (stdout0, stderr0) = self.run_cmd('djvudump', original_filename, LC_ALL='C') + self.assertEqual(stderr0, b'') stdout0 = stdout0.replace(b'\r\n', b'\n') tmpdir = tempfile.mkdtemp() try: tmp = open(os.path.join(tmpdir, 'tmp.djvu'), 'wb') job = document.save(tmp) - assert_equal(type(job), SaveJob) - assert_true(job.is_done) - assert_false(job.is_error) + self.assertEqual(type(job), SaveJob) + self.assertTrue(job.is_done) + self.assertFalse(job.is_error) tmp.close() - (stdout, stderr) = run('djvudump', tmp.name, LC_ALL='C') - assert_equal(stderr, b'') + (stdout, stderr) = self.run_cmd('djvudump', tmp.name, LC_ALL='C') + self.assertEqual(stderr, b'') stdout = stdout.replace(b'\r\n', b'\n') - assert_equal(stdout, stdout0) + self.assertEqual(stdout, stdout0) finally: shutil.rmtree(tmpdir) tmp = None @@ -353,19 +341,19 @@ class test_documents: try: tmp = open(os.path.join(tmpdir, 'tmp.djvu'), 'wb') job = document.save(tmp, pages=(0,)) - assert_equal(type(job), SaveJob) - assert_true(job.is_done) - assert_false(job.is_error) + self.assertEqual(type(job), SaveJob) + self.assertTrue(job.is_done) + self.assertFalse(job.is_error) tmp.close() - stdout, stderr = run('djvudump', tmp.name, LC_ALL='C') - assert_equal(stderr, b'') + stdout, stderr = self.run_cmd('djvudump', tmp.name, LC_ALL='C') + self.assertEqual(stderr, b'') stdout = stdout.replace(b'\r\n', b'\n') stdout0 = stdout0.split(b'\n') stdout = stdout.split(b'\n') stdout[4] = stdout[4].replace(b' (1)', b'') - assert_equal(len(stdout), 10) - assert_equal(stdout[3:-1], stdout0[4:10]) - assert_equal(stdout[-1], b'') + self.assertEqual(len(stdout), 10) + self.assertEqual(stdout[3:-1], stdout0[4:10]) + self.assertEqual(stdout[-1], b'') finally: shutil.rmtree(tmpdir) tmp = None @@ -373,37 +361,37 @@ class test_documents: try: tmpfname = os.path.join(tmpdir, 'index.djvu') job = document.save(indirect=tmpfname) - assert_equal(type(job), SaveJob) - assert_true(job.is_done) - assert_false(job.is_error) - (stdout, stderr) = run('djvudump', tmpfname, LC_ALL='C') - assert_equal(stderr, b'') + self.assertEqual(type(job), SaveJob) + self.assertTrue(job.is_done) + self.assertFalse(job.is_error) + (stdout, stderr) = self.run_cmd('djvudump', tmpfname, LC_ALL='C') + self.assertEqual(stderr, b'') stdout = stdout.replace(b'\r\n', b'\n') stdout = stdout.split(b'\n') stdout0 = ( [b' shared_anno.iff -> shared_anno.iff'] + [b(' p{n:04}.djvu -> p{n:04}.djvu'.format(n=n)) for n in range(1, 3)] ) - assert_equal(len(stdout), 7) - assert_equal(stdout[2:-2], stdout0) - assert_equal(stdout[-1], b'') + self.assertEqual(len(stdout), 7) + self.assertEqual(stdout[2:-2], stdout0) + self.assertEqual(stdout[-1], b'') finally: shutil.rmtree(tmpdir) tmpdir = tempfile.mkdtemp() try: tmpfname = os.path.join(tmpdir, 'index.djvu') job = document.save(indirect=tmpfname, pages=(0,)) - assert_equal(type(job), SaveJob) - assert_true(job.is_done) - assert_false(job.is_error) - (stdout, stderr) = run('djvudump', tmpfname, LC_ALL='C') + self.assertEqual(type(job), SaveJob) + self.assertTrue(job.is_done) + self.assertFalse(job.is_error) + (stdout, stderr) = self.run_cmd('djvudump', tmpfname, LC_ALL='C') stdout = stdout.replace(b'\r\n', b'\n') - assert_equal(stderr, b'') + self.assertEqual(stderr, b'') stdout = stdout.split(b'\n') - assert_equal(len(stdout), 5) - assert_equal(stdout[2], b' shared_anno.iff -> shared_anno.iff') - assert_equal(stdout[3], b' p0001.djvu -> p0001.djvu') - assert_equal(stdout[-1], b'') + self.assertEqual(len(stdout), 5) + self.assertEqual(stdout[2], b' shared_anno.iff -> shared_anno.iff') + self.assertEqual(stdout[3], b' p0001.djvu -> p0001.djvu') + self.assertEqual(stdout[-1], b'') finally: shutil.rmtree(tmpdir) @@ -412,63 +400,63 @@ class test_documents: context = Context() document = context.new_document(FileUri(images + 'test0.djvu')) message = document.get_message() - assert_equal(type(message), DocInfoMessage) - assert_true(document.decoding_done) - assert_false(document.decoding_error) - assert_equal(document.decoding_status, JobOK) - assert_equal(document.type, DOCUMENT_TYPE_BUNDLED) - assert_equal(len(document.pages), 2) - assert_equal(len(document.files), 3) + self.assertEqual(type(message), DocInfoMessage) + self.assertTrue(document.decoding_done) + self.assertFalse(document.decoding_error) + self.assertEqual(document.decoding_status, JobOK) + self.assertEqual(document.type, DOCUMENT_TYPE_BUNDLED) + self.assertEqual(len(document.pages), 2) + self.assertEqual(len(document.files), 3) with tempfile.NamedTemporaryFile() as tmp: job = document.export_ps(tmp.file) - assert_equal(type(job), SaveJob) - assert_true(job.is_done) - assert_false(job.is_error) - stdout, stderr = run('ps2ascii', tmp.name, LC_ALL='C') - assert_equal(stderr, b'') + self.assertEqual(type(job), SaveJob) + self.assertTrue(job.is_done) + self.assertFalse(job.is_error) + stdout, stderr = self.run_cmd('ps2ascii', tmp.name, LC_ALL='C') + self.assertEqual(stderr, b'') stdout = re.sub(br'[\x00\s]+', b' ', stdout) - assert_equal(stdout, b' ') + self.assertEqual(stdout, b' ') with tempfile.NamedTemporaryFile() as tmp: job = document.export_ps(tmp.file, pages=(0,), text=True) - assert_equal(type(job), SaveJob) - assert_true(job.is_done) - assert_false(job.is_error) - stdout, stderr = run('ps2ascii', tmp.name, LC_ALL='C') - assert_equal(stderr, b'') + self.assertEqual(type(job), SaveJob) + self.assertTrue(job.is_done) + self.assertFalse(job.is_error) + stdout, stderr = self.run_cmd('ps2ascii', tmp.name, LC_ALL='C') + self.assertEqual(stderr, b'') stdout = stdout.decode('ASCII') stdout = re.sub(r'[\x00\s]+', ' ', stdout) stdout = ' '.join(stdout.split()[:3]) expected = '1 Lorem ipsum' - assert_multi_line_equal(stdout, expected) + self.assertEqual(stdout, expected) -class test_pixel_formats(): +class test_pixel_formats(TestBase): def test_bad_new(self): - with assert_raises_str(TypeError, "cannot create 'djvu.decode.PixelFormat' instances"): + with self.assertRaisesRegex(TypeError, r"cannot create 'djvu.decode.PixelFormat' instances"): PixelFormat() def test_rgb(self): pf = PixelFormatRgb() - assert_repr(pf, "djvu.decode.PixelFormatRgb(byte_order = 'RGB', bpp = 24)") + self.assertEqual(repr(pf), "djvu.decode.PixelFormatRgb(byte_order = 'RGB', bpp = 24)") pf = PixelFormatRgb('RGB') - assert_repr(pf, "djvu.decode.PixelFormatRgb(byte_order = 'RGB', bpp = 24)") + self.assertEqual(repr(pf), "djvu.decode.PixelFormatRgb(byte_order = 'RGB', bpp = 24)") pf = PixelFormatRgb('BGR') - assert_repr(pf, "djvu.decode.PixelFormatRgb(byte_order = 'BGR', bpp = 24)") + self.assertEqual(repr(pf), "djvu.decode.PixelFormatRgb(byte_order = 'BGR', bpp = 24)") def test_rgb_mask(self): pf = PixelFormatRgbMask(0xFF, 0xF00, 0x1F000, 0, 16) - assert_repr(pf, "djvu.decode.PixelFormatRgbMask(red_mask = 0x00ff, green_mask = 0x0f00, blue_mask = 0xf000, xor_value = 0x0000, bpp = 16)") + self.assertEqual(repr(pf), "djvu.decode.PixelFormatRgbMask(red_mask = 0x00ff, green_mask = 0x0f00, blue_mask = 0xf000, xor_value = 0x0000, bpp = 16)") pf = PixelFormatRgbMask(0xFF000000, 0xFF0000, 0xFF00, 0xFF, 32) - assert_repr(pf, "djvu.decode.PixelFormatRgbMask(red_mask = 0xff000000, green_mask = 0x00ff0000, blue_mask = 0x0000ff00, xor_value = 0x000000ff, bpp = 32)") + self.assertEqual(repr(pf), "djvu.decode.PixelFormatRgbMask(red_mask = 0xff000000, green_mask = 0x00ff0000, blue_mask = 0x0000ff00, xor_value = 0x000000ff, bpp = 32)") def test_grey(self): pf = PixelFormatGrey() - assert_repr(pf, "djvu.decode.PixelFormatGrey(bpp = 8)") + self.assertEqual(repr(pf), "djvu.decode.PixelFormatGrey(bpp = 8)") def test_palette(self): - with assert_raises(KeyError) as ecm: + with self.assertRaises(KeyError) as ecm: pf = PixelFormatPalette({}) - assert_equal( + self.assertEqual( ecm.exception.args, ((0, 0, 0),) ) @@ -477,272 +465,271 @@ class test_pixel_formats(): data_repr = ', '.join( '{k!r}: 0x{v:02x}'.format(k=k, v=v) for k, v in sorted(data.items()) ) - assert_equal( + self.assertEqual( repr(pf), 'djvu.decode.PixelFormatPalette({{{data}}}, bpp = 8)'.format(data=data_repr) ) def test_packed_bits(self): pf = PixelFormatPackedBits('<') - assert_repr(pf, "djvu.decode.PixelFormatPackedBits('<')") - assert_equal(pf.bpp, 1) + self.assertEqual(repr(pf), "djvu.decode.PixelFormatPackedBits('<')") + self.assertEqual(pf.bpp, 1) pf = PixelFormatPackedBits('>') - assert_repr(pf, "djvu.decode.PixelFormatPackedBits('>')") - assert_equal(pf.bpp, 1) + self.assertEqual(repr(pf), "djvu.decode.PixelFormatPackedBits('>')") + self.assertEqual(pf.bpp, 1) -class test_page_jobs(): +class test_page_jobs(TestBase): def test_bad_new(self): - with assert_raises_str(TypeError, "cannot create 'djvu.decode.PageJob' instances"): + with self.assertRaisesRegex(TypeError, r"cannot create 'djvu.decode.PageJob' instances"): PageJob() def test_decode(self): context = Context() document = context.new_document(FileUri(images + 'test1.djvu')) message = document.get_message() - assert_equal(type(message), DocInfoMessage) + self.assertEqual(type(message), DocInfoMessage) page_job = document.pages[0].decode() - assert_true(page_job.is_done) - assert_equal(type(page_job), PageJob) - assert_true(page_job.is_done) - assert_false(page_job.is_error) - assert_equal(page_job.status, JobOK) - assert_equal(page_job.width, 64) - assert_equal(page_job.height, 48) - assert_equal(page_job.size, (64, 48)) - assert_equal(page_job.dpi, 300) - assert_equal(page_job.gamma, 2.2) - assert_equal(page_job.version, 24) - assert_equal(page_job.type, PAGE_TYPE_BITONAL) - assert_equal((page_job.rotation, page_job.initial_rotation), (0, 0)) - with assert_raises_str(ValueError, 'rotation must be equal to 0, 90, 180, or 270'): + self.assertTrue(page_job.is_done) + self.assertEqual(type(page_job), PageJob) + self.assertTrue(page_job.is_done) + self.assertFalse(page_job.is_error) + self.assertEqual(page_job.status, JobOK) + self.assertEqual(page_job.width, 64) + self.assertEqual(page_job.height, 48) + self.assertEqual(page_job.size, (64, 48)) + self.assertEqual(page_job.dpi, 300) + self.assertEqual(page_job.gamma, 2.2) + self.assertEqual(page_job.version, 24) + self.assertEqual(page_job.type, PAGE_TYPE_BITONAL) + self.assertEqual((page_job.rotation, page_job.initial_rotation), (0, 0)) + with self.assertRaisesRegex(ValueError, 'rotation must be equal to 0, 90, 180, or 270'): page_job.rotation = 100 page_job.rotation = 180 - assert_equal((page_job.rotation, page_job.initial_rotation), (180, 0)) + self.assertEqual((page_job.rotation, page_job.initial_rotation), (180, 0)) del page_job.rotation - assert_equal((page_job.rotation, page_job.initial_rotation), (0, 0)) + self.assertEqual((page_job.rotation, page_job.initial_rotation), (0, 0)) - with assert_raises_str(ValueError, 'page_rect width/height must be a positive integer'): + with self.assertRaisesRegex(ValueError, 'page_rect width/height must be a positive integer'): page_job.render(RENDER_COLOR, (0, 0, -1, -1), (0, 0, 10, 10), PixelFormatRgb()) - with assert_raises_str(ValueError, 'render_rect width/height must be a positive integer'): + with self.assertRaisesRegex(ValueError, 'render_rect width/height must be a positive integer'): page_job.render(RENDER_COLOR, (0, 0, 10, 10), (0, 0, -1, -1), PixelFormatRgb()) - with assert_raises_str(ValueError, 'render_rect must be inside page_rect'): + with self.assertRaisesRegex(ValueError, 'render_rect must be inside page_rect'): page_job.render(RENDER_COLOR, (0, 0, 10, 10), (2, 2, 10, 10), PixelFormatRgb()) - with assert_raises_str(ValueError, 'row_alignment must be a positive integer'): + with self.assertRaisesRegex(ValueError, 'row_alignment must be a positive integer'): page_job.render(RENDER_COLOR, (0, 0, 10, 10), (0, 0, 10, 10), PixelFormatRgb(), -1) - with assert_raises_regex(MemoryError, r'\AUnable to allocate [0-9]+ bytes for an image memory\Z'): + with self.assertRaisesRegex(MemoryError, r'\AUnable to allocate [0-9]+ bytes for an image memory\Z'): x = int((sys.maxsize // 2) ** 0.5) page_job.render(RENDER_COLOR, (0, 0, x, x), (0, 0, x, x), PixelFormatRgb(), 8) s = page_job.render(RENDER_COLOR, (0, 0, 10, 10), (0, 0, 4, 4), PixelFormatGrey(), 1) - assert_equal(s, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xEF\xFF\xFF\xFF\xA4\xFF\xFF\xFF\xB8') + self.assertEqual(s, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xEF\xFF\xFF\xFF\xA4\xFF\xFF\xFF\xB8') buffer = array.array('B', b'\0') - with assert_raises_str(ValueError, 'Image buffer is too small (16 > 1)'): + with self.assertRaisesRegex(ValueError, r'Image buffer is too small \(16 > 1\)'): page_job.render(RENDER_COLOR, (0, 0, 10, 10), (0, 0, 4, 4), PixelFormatGrey(), 1, buffer) buffer = array.array('B', b'\0' * 16) - assert_is(page_job.render(RENDER_COLOR, (0, 0, 10, 10), (0, 0, 4, 4), PixelFormatGrey(), 1, buffer), buffer) - s = array_tobytes(buffer) - assert_equal(s, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xEF\xFF\xFF\xFF\xA4\xFF\xFF\xFF\xB8') + self.assertIs(page_job.render(RENDER_COLOR, (0, 0, 10, 10), (0, 0, 4, 4), PixelFormatGrey(), 1, buffer), buffer) + s = buffer.tobytes() + self.assertEqual(s, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xEF\xFF\xFF\xFF\xA4\xFF\xFF\xFF\xB8') buffer = array.array('I', [0] * 4) pixel_format = PixelFormatRgbMask(0xFF0000, 0xFF00, 0xFF, bpp=32) - assert_is(page_job.render(RENDER_COLOR, (0, 0, 10, 10), (0, 0, 2, 2), pixel_format, 1, buffer), buffer) - s = array_tobytes(buffer) - assert_equal(s, b'\xFF\xFF\xFF\x00' * 4) + self.assertIs(page_job.render(RENDER_COLOR, (0, 0, 10, 10), (0, 0, 2, 2), pixel_format, 1, buffer), buffer) + s = buffer.tobytes() + self.assertEqual(s, b'\xFF\xFF\xFF\x00' * 4) if sys.version_info >= (3, 3): buffer = bytearray(16) memview = memoryview(buffer).cast('I', shape=(2, 2)) - assert_is(page_job.render(RENDER_COLOR, (0, 0, 10, 10), (0, 0, 2, 2), pixel_format, 1, memview), memview) + self.assertIs(page_job.render(RENDER_COLOR, (0, 0, 10, 10), (0, 0, 2, 2), pixel_format, 1, memview), memview) s = bytes(buffer) - assert_equal(s, b'\xFF\xFF\xFF\x00' * 4) + self.assertEqual(s, b'\xFF\xFF\xFF\x00' * 4) -class test_thumbnails: +class test_thumbnails(TestBase): def test(self): context = Context() document = context.new_document(FileUri(images + 'test1.djvu')) message = document.get_message() - assert_equal(type(message), DocInfoMessage) + self.assertEqual(type(message), DocInfoMessage) thumbnail = document.pages[0].thumbnail - assert_equal(thumbnail.status, JobOK) - assert_equal(thumbnail.calculate(), JobOK) + self.assertEqual(thumbnail.status, JobOK) + self.assertEqual(thumbnail.calculate(), JobOK) message = document.get_message() - assert_equal(type(message), ThumbnailMessage) - assert_equal(message.thumbnail.page.n, 0) + self.assertEqual(type(message), ThumbnailMessage) + self.assertEqual(message.thumbnail.page.n, 0) (w, h, r), pixels = thumbnail.render((5, 5), PixelFormatGrey(), dry_run=True) - assert_equal((w, h, r), (5, 3, 5)) - assert_is(pixels, None) + self.assertEqual((w, h, r), (5, 3, 5)) + self.assertIs(pixels, None) (w, h, r), pixels = thumbnail.render((5, 5), PixelFormatGrey()) - assert_equal((w, h, r), (5, 3, 5)) - assert_equal(pixels[:15], b'\xFF\xEB\xA7\xF2\xFF\xFF\xBF\x86\xBE\xFF\xFF\xE7\xD6\xE7\xFF') + self.assertEqual((w, h, r), (5, 3, 5)) + self.assertEqual(pixels[:15], b'\xFF\xEB\xA7\xF2\xFF\xFF\xBF\x86\xBE\xFF\xFF\xE7\xD6\xE7\xFF') buffer = array.array('B', b'\0') - with assert_raises_str(ValueError, 'Image buffer is too small (25 > 1)'): + with self.assertRaisesRegex(ValueError, r'Image buffer is too small \(25 > 1\)'): (w, h, r), pixels = thumbnail.render((5, 5), PixelFormatGrey(), buffer=buffer) buffer = array.array('B', b'\0' * 25) (w, h, r), pixels = thumbnail.render((5, 5), PixelFormatGrey(), buffer=buffer) - assert_is(pixels, buffer) - s = array_tobytes(buffer[:15]) - assert_equal(s, b'\xFF\xEB\xA7\xF2\xFF\xFF\xBF\x86\xBE\xFF\xFF\xE7\xD6\xE7\xFF') + self.assertIs(pixels, buffer) + s = buffer[:15].tobytes() + self.assertEqual(s, b'\xFF\xEB\xA7\xF2\xFF\xFF\xBF\x86\xBE\xFF\xFF\xE7\xD6\xE7\xFF') -def test_jobs(): + def test_jobs(self): + with self.assertRaisesRegex(TypeError, "cannot create 'djvu.decode.Job' instances"): + Job() + with self.assertRaisesRegex(TypeError, "cannot create 'djvu.decode.DocumentDecodingJob' instances"): + DocumentDecodingJob() - with assert_raises_str(TypeError, "cannot create 'djvu.decode.Job' instances"): - Job() - - with assert_raises_str(TypeError, "cannot create 'djvu.decode.DocumentDecodingJob' instances"): - DocumentDecodingJob() - -class test_affine_transforms(): +class test_affine_transforms(TestBase): def test_bad_args(self): - with assert_raises_str(ValueError, 'need more than 2 values to unpack'): + with self.assertRaisesRegex(ValueError, 'need more than 2 values to unpack'): AffineTransform((1, 2), (3, 4, 5)) def test1(self): af = AffineTransform((0, 0, 10, 10), (17, 42, 42, 100)) - assert_equal(type(af), AffineTransform) - assert_equal(af((0, 0)), (17, 42)) - assert_equal(af((0, 10)), (17, 142)) - assert_equal(af((10, 0)), (59, 42)) - assert_equal(af((10, 10)), (59, 142)) - assert_equal(af((0, 0, 10, 10)), (17, 42, 42, 100)) - assert_equal(af(x for x in (0, 0, 10, 10)), (17, 42, 42, 100)) - assert_equal(af.apply((123, 456)), af((123, 456))) - assert_equal(af.apply((12, 34, 56, 78)), af((12, 34, 56, 78))) - assert_equal(af.inverse((17, 42)), (0, 0)) - assert_equal(af.inverse((17, 142)), (0, 10)) - assert_equal(af.inverse((59, 42)), (10, 0)) - assert_equal(af.inverse((59, 142)), (10, 10)) - assert_equal(af.inverse((17, 42, 42, 100)), (0, 0, 10, 10)) - assert_equal(af.inverse(x for x in (17, 42, 42, 100)), (0, 0, 10, 10)) - assert_equal(af.inverse(af((234, 567))), (234, 567)) - assert_equal(af.inverse(af((23, 45, 67, 78))), (23, 45, 67, 78)) + self.assertEqual(type(af), AffineTransform) + self.assertEqual(af((0, 0)), (17, 42)) + self.assertEqual(af((0, 10)), (17, 142)) + self.assertEqual(af((10, 0)), (59, 42)) + self.assertEqual(af((10, 10)), (59, 142)) + self.assertEqual(af((0, 0, 10, 10)), (17, 42, 42, 100)) + self.assertEqual(af(x for x in (0, 0, 10, 10)), (17, 42, 42, 100)) + self.assertEqual(af.apply((123, 456)), af((123, 456))) + self.assertEqual(af.apply((12, 34, 56, 78)), af((12, 34, 56, 78))) + self.assertEqual(af.inverse((17, 42)), (0, 0)) + self.assertEqual(af.inverse((17, 142)), (0, 10)) + self.assertEqual(af.inverse((59, 42)), (10, 0)) + self.assertEqual(af.inverse((59, 142)), (10, 10)) + self.assertEqual(af.inverse((17, 42, 42, 100)), (0, 0, 10, 10)) + self.assertEqual(af.inverse(x for x in (17, 42, 42, 100)), (0, 0, 10, 10)) + self.assertEqual(af.inverse(af((234, 567))), (234, 567)) + self.assertEqual(af.inverse(af((23, 45, 67, 78))), (23, 45, 67, 78)) -class test_messages(): +class test_messages(TestBase): def test_bad_new(self): - with assert_raises_str(TypeError, "cannot create 'djvu.decode.Message' instances"): + with self.assertRaisesRegex(TypeError, "cannot create 'djvu.decode.Message' instances"): Message() -class test_streams: +class test_streams(TestBase): def test_bad_new(self): - with assert_raises_str(TypeError, "Argument 'document' has incorrect type (expected djvu.decode.Document, got NoneType)"): - Stream(None, 42) + with self.assertRaisesRegex( + TypeError, + r"Argument 'document' has incorrect type \(expected djvu.decode.Document, got NoneType\)"): + Stream(None, 42) def test(self): context = Context() document = context.new_document('dummy://dummy.djvu') message = document.get_message() - assert_equal(type(message), NewStreamMessage) - assert_equal(message.name, 'dummy.djvu') - assert_equal(message.uri, 'dummy://dummy.djvu') - assert_equal(type(message.stream), Stream) - with assert_raises(NotAvailable): + self.assertEqual(type(message), NewStreamMessage) + self.assertEqual(message.name, 'dummy.djvu') + self.assertEqual(message.uri, 'dummy://dummy.djvu') + self.assertEqual(type(message.stream), Stream) + with self.assertRaises(NotAvailable): document.outline.sexpr - with assert_raises(NotAvailable): + with self.assertRaises(NotAvailable): document.annotations.sexpr - with assert_raises(NotAvailable): + with self.assertRaises(NotAvailable): document.pages[0].text.sexpr - with assert_raises(NotAvailable): + with self.assertRaises(NotAvailable): document.pages[0].annotations.sexpr try: with open(images + 'test1.djvu', 'rb') as fp: message.stream.write(fp.read()) finally: message.stream.close() - with assert_raises_str(IOError, 'I/O operation on closed file'): + with self.assertRaisesRegex(IOError, 'I/O operation on closed file'): message.stream.write(b'eggs') message = document.get_message() - assert_equal(type(message), DocInfoMessage) + self.assertEqual(type(message), DocInfoMessage) outline = document.outline outline.wait() x = outline.sexpr - assert_equal(x, Expression([])) + self.assertEqual(x, Expression([])) anno = document.annotations anno.wait() x = anno.sexpr - assert_equal(x, Expression([])) + self.assertEqual(x, Expression([])) text = document.pages[0].text text.wait() x = text.sexpr - assert_equal(x, Expression([])) + self.assertEqual(x, Expression([])) anno = document.pages[0].annotations anno.wait() x = anno.sexpr - assert_equal(x, Expression([])) + self.assertEqual(x, Expression([])) -def test_metadata(): - - model_metadata = { - 'English': 'eggs', - u('Русский'): u('яйца'), - } - meta = '\n'.join(u('|{k}| {v}').format(k=k, v=v) for k, v in model_metadata.items()) - test_script = u('set-meta\n{meta}\n.\n').format(meta=meta) - try: - test_file = create_djvu(test_script) - except UnicodeEncodeError: - raise SkipTest('you need to run this test with LC_CTYPE=C or LC_CTYPE=<lang>.UTF-8') - try: - context = Context() - document = context.new_document(FileUri(test_file.name)) - message = document.get_message() - assert_equal(type(message), DocInfoMessage) - annotations = document.annotations - assert_equal(type(annotations), DocumentAnnotations) - annotations.wait() - metadata = annotations.metadata - assert_equal(type(metadata), Metadata) - assert_equal(len(metadata), len(model_metadata)) - assert_equal(sorted(metadata), sorted(model_metadata)) - if not py3k: - assert_equal(sorted(metadata.iterkeys()), sorted(model_metadata.iterkeys())) - assert_equal(sorted(metadata.keys()), sorted(model_metadata.keys())) - if not py3k: - assert_equal(sorted(metadata.itervalues()), sorted(model_metadata.itervalues())) - assert_equal(sorted(metadata.values()), sorted(model_metadata.values())) - if not py3k: - assert_equal(sorted(metadata.iteritems()), sorted(model_metadata.iteritems())) - assert_equal(sorted(metadata.items()), sorted(model_metadata.items())) - for k in metadata: - assert_equal(type(k), unicode) - assert_equal(type(metadata[k]), unicode) - for k in None, 42, '+'.join(model_metadata): - with assert_raises(KeyError) as ecm: - metadata[k] - assert_equal(ecm.exception.args, (k,)) - finally: - test_file.close() - -class test_sexpr: +class TestMetadata(TestBase): + def test_metadata(self): + model_metadata = { + 'English': 'eggs', + u('Русский'): u('яйца'), + } + meta = '\n'.join(u('|{k}| {v}').format(k=k, v=v) for k, v in model_metadata.items()) + test_script = u('set-meta\n{meta}\n.\n').format(meta=meta) + try: + test_file = self.create_djvu(test_script) + except UnicodeEncodeError: + raise unittest.SkipTest('you need to run this test with LC_CTYPE=C or LC_CTYPE=<lang>.UTF-8') + try: + context = Context() + document = context.new_document(FileUri(test_file.name)) + message = document.get_message() + self.assertEqual(type(message), DocInfoMessage) + annotations = document.annotations + self.assertEqual(type(annotations), DocumentAnnotations) + annotations.wait() + metadata = annotations.metadata + self.assertEqual(type(metadata), Metadata) + self.assertEqual(len(metadata), len(model_metadata)) + self.assertEqual(sorted(metadata), sorted(model_metadata)) + if not py3k: + self.assertEqual(sorted(metadata.iterkeys()), sorted(model_metadata.iterkeys())) + self.assertEqual(sorted(metadata.keys()), sorted(model_metadata.keys())) + if not py3k: + self.assertEqual(sorted(metadata.itervalues()), sorted(model_metadata.itervalues())) + self.assertEqual(sorted(metadata.values()), sorted(model_metadata.values())) + if not py3k: + self.assertEqual(sorted(metadata.iteritems()), sorted(model_metadata.iteritems())) + self.assertEqual(sorted(metadata.items()), sorted(model_metadata.items())) + for k in metadata: + self.assertEqual(type(k), unicode) + self.assertEqual(type(metadata[k]), unicode) + for k in None, 42, '+'.join(model_metadata): + with self.assertRaises(KeyError) as ecm: + metadata[k] + self.assertEqual(ecm.exception.args, (k,)) + finally: + test_file.close() +class test_sexpr(TestBase): def test(self): context = Context() document = context.new_document(FileUri(images + 'test0.djvu')) - assert_equal(type(document), Document) + self.assertEqual(type(document), Document) message = document.get_message() - assert_equal(type(message), DocInfoMessage) + self.assertEqual(type(message), DocInfoMessage) anno = DocumentAnnotations(document, shared=False) - assert_equal(type(anno), DocumentAnnotations) + self.assertEqual(type(anno), DocumentAnnotations) anno.wait() x = anno.sexpr - assert_equal(x, Expression([])) + self.assertEqual(x, Expression([])) anno = document.annotations - assert_equal(type(anno), DocumentAnnotations) + self.assertEqual(type(anno), DocumentAnnotations) anno.wait() - assert_is(anno.background_color, None) - assert_is(anno.horizontal_align, None) - assert_is(anno.vertical_align, None) - assert_is(anno.mode, None) - assert_is(anno.zoom, None) + self.assertIs(anno.background_color, None) + self.assertIs(anno.horizontal_align, None) + self.assertIs(anno.vertical_align, None) + self.assertIs(anno.mode, None) + self.assertIs(anno.zoom, None) expected_metadata = [ Symbol('metadata'), [Symbol('ModDate'), '2015-08-17 19:54:57+02:00'], @@ -766,20 +753,20 @@ class test_sexpr: '</rdf:Description>' '</rdf:RDF>\n' ] - assert_equal( + self.assertEqual( anno.sexpr, Expression([expected_metadata, expected_xmp]) ) metadata = anno.metadata - assert_equal(type(metadata), Metadata) + self.assertEqual(type(metadata), Metadata) hyperlinks = anno.hyperlinks - assert_equal(type(hyperlinks), Hyperlinks) - assert_equal(len(hyperlinks), 0) - assert_equal(list(hyperlinks), []) + self.assertEqual(type(hyperlinks), Hyperlinks) + self.assertEqual(len(hyperlinks), 0) + self.assertEqual(list(hyperlinks), []) outline = document.outline - assert_equal(type(outline), DocumentOutline) + self.assertEqual(type(outline), DocumentOutline) outline.wait() - assert_equal(outline.sexpr, Expression( + self.assertEqual(outline.sexpr, Expression( [Symbol('bookmarks'), ['Lorem ipsum', '#p0001.djvu'], ['Hyperlinks', '#p0002.djvu', @@ -790,41 +777,41 @@ class test_sexpr: )) page = document.pages[1] anno = page.annotations - assert_equal(type(anno), PageAnnotations) + self.assertEqual(type(anno), PageAnnotations) anno.wait() - assert_is(anno.background_color, None) - assert_is(anno.horizontal_align, None) - assert_is(anno.vertical_align, None) - assert_is(anno.mode, None) - assert_is(anno.zoom, None) + self.assertIs(anno.background_color, None) + self.assertIs(anno.horizontal_align, None) + self.assertIs(anno.vertical_align, None) + self.assertIs(anno.mode, None) + self.assertIs(anno.zoom, None) expected_hyperlinks = [ [Symbol('maparea'), '#p0001.djvu', '', [Symbol('rect'), 520, 2502, 33, 42], [Symbol('border'), Symbol('#ff0000')]], [Symbol('maparea'), 'http://jwilk.net/', '', [Symbol('rect'), 458, 2253, 516, 49], [Symbol('border'), Symbol('#00ffff')]] ] - assert_equal( + self.assertEqual( anno.sexpr, Expression([expected_metadata, expected_xmp] + expected_hyperlinks) ) page_metadata = anno.metadata - assert_equal(type(page_metadata), Metadata) - assert_equal(page_metadata.keys(), metadata.keys()) - assert_equal([page_metadata[k] == metadata[k] for k in metadata], [True, True, True, True, True]) + self.assertEqual(type(page_metadata), Metadata) + self.assertEqual(page_metadata.keys(), metadata.keys()) + self.assertEqual([page_metadata[k] == metadata[k] for k in metadata], [True, True, True, True, True]) hyperlinks = anno.hyperlinks - assert_equal(type(hyperlinks), Hyperlinks) - assert_equal(len(hyperlinks), 2) - assert_equal( + self.assertEqual(type(hyperlinks), Hyperlinks) + self.assertEqual(len(hyperlinks), 2) + self.assertEqual( list(hyperlinks), [Expression(h) for h in expected_hyperlinks] ) text = page.text - assert_equal(type(text), PageText) + self.assertEqual(type(text), PageText) text.wait() text_s = text.sexpr text_s_detail = [PageText(page, details).sexpr for details in (TEXT_DETAILS_PAGE, TEXT_DETAILS_COLUMN, TEXT_DETAILS_REGION, TEXT_DETAILS_PARAGRAPH, TEXT_DETAILS_LINE, TEXT_DETAILS_WORD, TEXT_DETAILS_CHARACTER, TEXT_DETAILS_ALL)] - assert_equal(text_s_detail[0], text_s_detail[1]) - assert_equal(text_s_detail[1], text_s_detail[2]) - assert_equal(text_s_detail[2], text_s_detail[3]) - assert_equal( + self.assertEqual(text_s_detail[0], text_s_detail[1]) + self.assertEqual(text_s_detail[1], text_s_detail[2]) + self.assertEqual(text_s_detail[2], text_s_detail[3]) + self.assertEqual( text_s_detail[0], Expression( [Symbol('page'), 0, 0, 2550, 3300, @@ -836,7 +823,7 @@ class test_sexpr: ] ) ) - assert_equal( + self.assertEqual( text_s_detail[4], Expression( [Symbol('page'), 0, 0, 2550, 3300, @@ -849,10 +836,10 @@ class test_sexpr: ] ) ) - assert_equal(text_s_detail[5], text_s) - assert_equal(text_s_detail[6], text_s) - assert_equal(text_s_detail[7], text_s) - assert_equal( + self.assertEqual(text_s_detail[5], text_s) + self.assertEqual(text_s_detail[6], text_s) + self.assertEqual(text_s_detail[7], text_s) + self.assertEqual( text_s, Expression( [Symbol('page'), 0, 0, 2550, 3300, @@ -865,106 +852,108 @@ class test_sexpr: ] ) ) - with assert_raises_str(TypeError, 'details must be a symbol or none'): + with self.assertRaisesRegex(TypeError, 'details must be a symbol or none'): PageText(page, 'eggs') - with assert_raises_str(ValueError, 'details must be equal to TEXT_DETAILS_PAGE, or TEXT_DETAILS_COLUMN, or TEXT_DETAILS_REGION, or TEXT_DETAILS_PARAGRAPH, or TEXT_DETAILS_LINE, or TEXT_DETAILS_WORD, or TEXT_DETAILS_CHARACTER or TEXT_DETAILS_ALL'): + with self.assertRaisesRegex(ValueError, 'details must be equal to TEXT_DETAILS_PAGE, or TEXT_DETAILS_COLUMN, or TEXT_DETAILS_REGION, or TEXT_DETAILS_PARAGRAPH, or TEXT_DETAILS_LINE, or TEXT_DETAILS_WORD, or TEXT_DETAILS_CHARACTER or TEXT_DETAILS_ALL'): PageText(page, Symbol('eggs')) -def test_version(): - assert_is_instance(__version__, str) - assert_equal(__version__, get_changelog_version()) - assert_is_instance(DDJVU_VERSION, int) +class TestGeneralSettings(TestBase): + def test_version(self): + self.assertIsInstance(__version__, str) + self.assertEqual(__version__, get_changelog_version()) + self.assertIsInstance(DDJVU_VERSION, int) -def test_wildcard_import(): - ns = wildcard_import('djvu.decode') - assert_list_equal( - sorted(ns.keys()), [ - 'AffineTransform', - 'Annotations', - 'ChunkMessage', - 'Context', - 'DDJVU_VERSION', - 'DOCUMENT_TYPE_BUNDLED', - 'DOCUMENT_TYPE_INDIRECT', - 'DOCUMENT_TYPE_OLD_BUNDLED', - 'DOCUMENT_TYPE_OLD_INDEXED', - 'DOCUMENT_TYPE_SINGLE_PAGE', - 'DOCUMENT_TYPE_UNKNOWN', - 'DocInfoMessage', - 'Document', - 'DocumentAnnotations', - 'DocumentDecodingJob', - 'DocumentExtension', - 'DocumentFiles', - 'DocumentOutline', - 'DocumentPages', - 'ErrorMessage', - 'FILE_TYPE_INCLUDE', - 'FILE_TYPE_PAGE', - 'FILE_TYPE_THUMBNAILS', - 'File', - 'FileURI', - 'FileUri', - 'Hyperlinks', - 'InfoMessage', - 'Job', - 'JobDone', - 'JobException', - 'JobFailed', - 'JobNotDone', - 'JobNotStarted', - 'JobOK', - 'JobStarted', - 'JobStopped', - 'Message', - 'Metadata', - 'NewStreamMessage', - 'NotAvailable', - 'PAGE_TYPE_BITONAL', - 'PAGE_TYPE_COMPOUND', - 'PAGE_TYPE_PHOTO', - 'PAGE_TYPE_UNKNOWN', - 'PRINT_BOOKLET_NO', - 'PRINT_BOOKLET_RECTO', - 'PRINT_BOOKLET_VERSO', - 'PRINT_BOOKLET_YES', - 'PRINT_ORIENTATION_AUTO', - 'PRINT_ORIENTATION_LANDSCAPE', - 'PRINT_ORIENTATION_PORTRAIT', - 'Page', - 'PageAnnotations', - 'PageInfoMessage', - 'PageJob', - 'PageText', - 'PixelFormat', - 'PixelFormatGrey', - 'PixelFormatPackedBits', - 'PixelFormatPalette', - 'PixelFormatRgb', - 'PixelFormatRgbMask', - 'ProgressMessage', - 'RENDER_BACKGROUND', - 'RENDER_BLACK', - 'RENDER_COLOR', - 'RENDER_COLOR_ONLY', - 'RENDER_FOREGROUND', - 'RENDER_MASK_ONLY', - 'RedisplayMessage', - 'RelayoutMessage', - 'SaveJob', - 'Stream', - 'TEXT_DETAILS_ALL', - 'TEXT_DETAILS_CHARACTER', - 'TEXT_DETAILS_COLUMN', - 'TEXT_DETAILS_LINE', - 'TEXT_DETAILS_PAGE', - 'TEXT_DETAILS_PARAGRAPH', - 'TEXT_DETAILS_REGION', - 'TEXT_DETAILS_WORD', - 'Thumbnail', - 'ThumbnailMessage', - 'cmp_text_zone' - ] - ) + def test_wildcard_import(self): + ns = {} + exec('from djvu.decode import *', {}, ns) + self.assertEqual( + sorted(ns.keys()), [ + 'AffineTransform', + 'Annotations', + 'ChunkMessage', + 'Context', + 'DDJVU_VERSION', + 'DOCUMENT_TYPE_BUNDLED', + 'DOCUMENT_TYPE_INDIRECT', + 'DOCUMENT_TYPE_OLD_BUNDLED', + 'DOCUMENT_TYPE_OLD_INDEXED', + 'DOCUMENT_TYPE_SINGLE_PAGE', + 'DOCUMENT_TYPE_UNKNOWN', + 'DocInfoMessage', + 'Document', + 'DocumentAnnotations', + 'DocumentDecodingJob', + 'DocumentExtension', + 'DocumentFiles', + 'DocumentOutline', + 'DocumentPages', + 'ErrorMessage', + 'FILE_TYPE_INCLUDE', + 'FILE_TYPE_PAGE', + 'FILE_TYPE_THUMBNAILS', + 'File', + 'FileURI', + 'FileUri', + 'Hyperlinks', + 'InfoMessage', + 'Job', + 'JobDone', + 'JobException', + 'JobFailed', + 'JobNotDone', + 'JobNotStarted', + 'JobOK', + 'JobStarted', + 'JobStopped', + 'Message', + 'Metadata', + 'NewStreamMessage', + 'NotAvailable', + 'PAGE_TYPE_BITONAL', + 'PAGE_TYPE_COMPOUND', + 'PAGE_TYPE_PHOTO', + 'PAGE_TYPE_UNKNOWN', + 'PRINT_BOOKLET_NO', + 'PRINT_BOOKLET_RECTO', + 'PRINT_BOOKLET_VERSO', + 'PRINT_BOOKLET_YES', + 'PRINT_ORIENTATION_AUTO', + 'PRINT_ORIENTATION_LANDSCAPE', + 'PRINT_ORIENTATION_PORTRAIT', + 'Page', + 'PageAnnotations', + 'PageInfoMessage', + 'PageJob', + 'PageText', + 'PixelFormat', + 'PixelFormatGrey', + 'PixelFormatPackedBits', + 'PixelFormatPalette', + 'PixelFormatRgb', + 'PixelFormatRgbMask', + 'ProgressMessage', + 'RENDER_BACKGROUND', + 'RENDER_BLACK', + 'RENDER_COLOR', + 'RENDER_COLOR_ONLY', + 'RENDER_FOREGROUND', + 'RENDER_MASK_ONLY', + 'RedisplayMessage', + 'RelayoutMessage', + 'SaveJob', + 'Stream', + 'TEXT_DETAILS_ALL', + 'TEXT_DETAILS_CHARACTER', + 'TEXT_DETAILS_COLUMN', + 'TEXT_DETAILS_LINE', + 'TEXT_DETAILS_PAGE', + 'TEXT_DETAILS_PARAGRAPH', + 'TEXT_DETAILS_REGION', + 'TEXT_DETAILS_WORD', + 'Thumbnail', + 'ThumbnailMessage', + 'cmp_text_zone' + ] + ) # vim:ts=4 sts=4 sw=4 et diff --git a/tests/test_sexpr.py b/tests/test_sexpr.py index 3e9631d..37725dc 100644 --- a/tests/test_sexpr.py +++ b/tests/test_sexpr.py @@ -21,12 +21,15 @@ import os import shutil import sys import tempfile +import unittest if sys.version_info >= (3, 3): import collections.abc as collections_abc else: import collections as collections_abc +from io import StringIO + import pickle try: import cPickle as cpickle @@ -42,23 +45,8 @@ from djvu.sexpr import ( ) from tools import ( - SkipTest, - assert_equal, - assert_false, - assert_in, - assert_is, - assert_is_instance, - assert_less, - assert_list_equal, - assert_not_equal, - assert_not_in, - assert_raises, - assert_raises_str, - assert_repr, get_changelog_version, - wildcard_import, # Python 2/3 compat: - StringIO, b, long, py3k, @@ -66,65 +54,66 @@ from tools import ( unicode, ) -def assert_pickle_equal(obj): - for pickle_module in pickle, cpickle: - if pickle_module is None: - continue - for protocol in range(pickle.HIGHEST_PROTOCOL + 1): - pickled_obj = pickle_module.dumps(obj, protocol=protocol) - repickled_obj = pickle_module.loads(pickled_obj) - assert_equal(obj, repickled_obj) -class test_int_expressions(): +class TestBase(unittest.TestCase): + def assert_pickle_equal(self, obj): + for pickle_module in pickle, cpickle: + if pickle_module is None: + continue + for protocol in range(pickle.HIGHEST_PROTOCOL + 1): + pickled_obj = pickle_module.dumps(obj, protocol=protocol) + repickled_obj = pickle_module.loads(pickled_obj) + self.assertEqual(obj, repickled_obj) +class test_int_expressions(TestBase): def t(self, n, x=None): if x is None: x = Expression(n) - assert_is(x, Expression(x)) + self.assertIs(x, Expression(x)) # __repr__(): - assert_repr(x, 'Expression({n})'.format(n=int(n))) + self.assertEqual(repr(x), 'Expression({n})'.format(n=int(n))) # value: v = x.value - assert_equal(type(v), int) - assert_equal(v, n) + self.assertEqual(type(v), int) + self.assertEqual(v, n) # lvalue: v = x.lvalue - assert_equal(type(v), int) - assert_equal(v, n) + self.assertEqual(type(v), int) + self.assertEqual(v, n) # __int__(): i = int(x) - assert_equal(type(i), int) - assert_equal(i, n) + self.assertEqual(type(i), int) + self.assertEqual(i, n) # __long__(): i = long(x) - assert_equal(type(i), long) - assert_equal(i, n) + self.assertEqual(type(i), long) + self.assertEqual(i, n) # __float__(): i = float(x) - assert_equal(type(i), float) - assert_equal(i, n) + self.assertEqual(type(i), float) + self.assertEqual(i, n) # __str__(): s = str(x) - assert_equal(s, str(n)) + self.assertEqual(s, str(n)) # __unicode__(): s = unicode(x) - assert_equal(s, str(n)) + self.assertEqual(s, str(n)) # __eq__(), __ne__(): - assert_equal(x, Expression(n)) - assert_not_equal(x, n) - assert_not_equal(x, Expression(n + 37)) + self.assertEqual(x, Expression(n)) + self.assertNotEqual(x, n) + self.assertNotEqual(x, Expression(n + 37)) # __hash__(): - assert_equal(hash(x), n) + self.assertEqual(hash(x), n) # __bool__() / __nonzero__(): obj = object() if n: - assert_is(x and obj, obj) - assert_is(x or obj, x) + self.assertIs(x and obj, obj) + self.assertIs(x or obj, x) else: - assert_is(x and obj, x) - assert_is(x or obj, obj) + self.assertIs(x and obj, x) + self.assertIs(x or obj, obj) # pickle: - assert_pickle_equal(x) + self.assert_pickle_equal(x) def test_int(self): self.t(42) @@ -145,24 +134,28 @@ class test_int_expressions(): self.t(long(42)) def test_limits(self): - assert_equal(Expression((1 << 29) - 1).value, (1 << 29) - 1) - assert_equal(Expression(-1 << 29).value, -1 << 29) - with assert_raises_str(ValueError, 'value not in range(-2 ** 29, 2 ** 29)'): - Expression(1 << 29) - with assert_raises_str(ValueError, 'value not in range(-2 ** 29, 2 ** 29)'): - Expression((-1 << 29) - 1) + self.assertEqual(Expression((1 << 29) - 1).value, (1 << 29) - 1) + self.assertEqual(Expression(-1 << 29).value, -1 << 29) + with self.assertRaisesRegex( + ValueError, + r'value not in range\(-2 \*\* 29, 2 \*\* 29\)'): + Expression(1 << 29) + with self.assertRaisesRegex( + ValueError, + r'value not in range\(-2 \*\* 29, 2 \*\* 29\)'): + Expression((-1 << 29) - 1) -class test_float_expressions(): +class test_float_expressions(TestBase): # TODO: float expressions are not implemented yet def test_parse(self): - with assert_raises(ExpressionSyntaxError): + with self.assertRaises(ExpressionSyntaxError): x = Expression.from_string('3.14') if isinstance(x.value, Symbol): raise ExpressionSyntaxError -class test_symbols(): +class test_symbols(TestBase): def t(self, name, sname=None): if sname is None: @@ -172,15 +165,15 @@ class test_symbols(): else: [uname, bname] = [sname.decode('UTF-8'), sname] symbol = Symbol(name) - assert_equal(type(symbol), Symbol) - assert_equal(symbol, Symbol(name)) - assert_is(symbol, Symbol(name)) - assert_equal(str(symbol), sname) - assert_equal(unicode(symbol), uname) - assert_not_equal(symbol, bname) - assert_not_equal(symbol, uname) - assert_equal(hash(symbol), hash(bname)) - assert_pickle_equal(symbol) + self.assertEqual(type(symbol), Symbol) + self.assertEqual(symbol, Symbol(name)) + self.assertIs(symbol, Symbol(name)) + self.assertEqual(str(symbol), sname) + self.assertEqual(unicode(symbol), uname) + self.assertNotEqual(symbol, bname) + self.assertNotEqual(symbol, uname) + self.assertEqual(hash(symbol), hash(bname)) + self.assert_pickle_equal(symbol) return symbol def test_ascii(self): @@ -192,12 +185,12 @@ class test_symbols(): assert x is y def test_inequality(self): - assert_less( + self.assertLess( Symbol('eggs'), Symbol('ham'), ) -class test_symbol_expressions(): +class test_symbol_expressions(TestBase): def t(self, name, sname): if sname is None: @@ -208,34 +201,34 @@ class test_symbol_expressions(): [uname, bname] = [sname.decode('UTF-8'), sname] sym = Symbol(name) x = Expression(sym) - assert_is(x, Expression(x)) + self.assertIs(x, Expression(x)) # __repr__(x) - assert_repr(x, 'Expression({sym!r})'.format(sym=sym)) + self.assertEqual(repr(x), 'Expression({sym!r})'.format(sym=sym)) # value: v = x.value - assert_equal(type(v), Symbol) - assert_equal(v, sym) + self.assertEqual(type(v), Symbol) + self.assertEqual(v, sym) # lvalue: v = x.lvalue - assert_equal(type(v), Symbol) - assert_equal(v, sym) + self.assertEqual(type(v), Symbol) + self.assertEqual(v, sym) # __str__(): - assert_equal(str(x), sname) - assert_repr(x, repr(Expression.from_string(sname))) + self.assertEqual(str(x), sname) + self.assertEqual(repr(x), repr(Expression.from_string(sname))) # __unicode__(): - assert_equal(unicode(x), uname) - assert_repr(x, repr(Expression.from_string(uname))) + self.assertEqual(unicode(x), uname) + self.assertEqual(repr(x), repr(Expression.from_string(uname))) # __eq__(), __ne__(): - assert_equal(x, Expression(sym)) - assert_not_equal(x, Expression(name)) - assert_not_equal(x, sym) + self.assertEqual(x, Expression(sym)) + self.assertNotEqual(x, Expression(name)) + self.assertNotEqual(x, sym) # __hash__(): - assert_equal( + self.assertEqual( hash(x), hash(bname.strip(b'|')) ) # pickle: - assert_pickle_equal(x) + self.assert_pickle_equal(x) return x def test_ascii(self): @@ -244,97 +237,97 @@ class test_symbol_expressions(): def test_nonascii(self): x = self.t(b('ветчина'), '|ветчина|') y = self.t(u('ветчина'), '|ветчина|') - assert_equal(x, y) - assert_equal(hash(x), hash(y)) + self.assertEqual(x, y) + self.assertEqual(hash(x), hash(y)) def test_string_expressions(): x = Expression('eggs') - assert_repr(x, "Expression('eggs')") - assert_is(x, Expression(x)) - assert_equal(x.value, 'eggs') - assert_equal(x.lvalue, 'eggs') - assert_equal(str(x), '"eggs"') - assert_repr(x, repr(Expression.from_string(str(x)))) - assert_equal(x, Expression('eggs')) - assert_not_equal(x, Expression(Symbol('eggs'))) - assert_not_equal(x, 'eggs') - assert_equal(hash(x), hash('eggs')) - assert_pickle_equal(x) + self.assertEqual(repr(x), "Expression('eggs')") + self.assertIs(x, Expression(x)) + self.assertEqual(x.value, 'eggs') + self.assertEqual(x.lvalue, 'eggs') + self.assertEqual(str(x), '"eggs"') + self.assertEqual(repr(x), repr(Expression.from_string(str(x)))) + self.assertEqual(x, Expression('eggs')) + self.assertNotEqual(x, Expression(Symbol('eggs'))) + self.assertNotEqual(x, 'eggs') + self.assertEqual(hash(x), hash('eggs')) + self.assert_pickle_equal(x) -class test_unicode_expressions(): +class test_unicode_expressions(TestBase): def test1(self): x = Expression(u('eggs')) - assert_repr(x, "Expression('eggs')") - assert_is(x, Expression(x)) + self.assertEqual(repr(x), "Expression('eggs')") + self.assertIs(x, Expression(x)) def test2(self): x = Expression(u('żółw')) if py3k: - assert_repr(x, "Expression('żółw')") + self.assertEqual(repr(x), "Expression('żółw')") else: - assert_repr(x, r"Expression('\xc5\xbc\xc3\xb3\xc5\x82w')") + self.assertEqual(repr(x), r"Expression('\xc5\xbc\xc3\xb3\xc5\x82w')") -class test_list_expressions(): +class test_list_expressions(TestBase): def test1(self): x = Expression(()) - assert_repr(x, "Expression([])") + self.assertEqual(repr(x), "Expression([])") y = Expression(x) - assert_is(x, y) - assert_equal(x.value, ()) - assert_equal(x.lvalue, []) - assert_equal(len(x), 0) - assert_equal(bool(x), False) - assert_equal(list(x), []) + self.assertIs(x, y) + self.assertEqual(x.value, ()) + self.assertEqual(x.lvalue, []) + self.assertEqual(len(x), 0) + self.assertEqual(bool(x), False) + self.assertEqual(list(x), []) def test2(self): x = Expression([[1, 2], 3, [4, 5, Symbol('baz')], ['quux']]) - assert_repr(x, "Expression([[1, 2], 3, [4, 5, Symbol('baz')], ['quux']])") + self.assertEqual(repr(x), "Expression([[1, 2], 3, [4, 5, Symbol('baz')], ['quux']])") y = Expression(x) - assert_repr(y, repr(x)) - assert_false(x is y) - assert_equal(x.value, ((1, 2), 3, (4, 5, Symbol('baz')), ('quux',))) - assert_equal(x.lvalue, [[1, 2], 3, [4, 5, Symbol('baz')], ['quux']]) - assert_equal(str(x), '((1 2) 3 (4 5 baz) ("quux"))') - assert_repr(x, repr(Expression.from_string(str(x)))) - assert_equal(len(x), 4) - assert_equal(bool(x), True) - assert_equal(tuple(x), (Expression((1, 2)), Expression(3), Expression((4, 5, Symbol('baz'))), Expression(('quux',)))) - with assert_raises_str(TypeError, 'key must be an integer or a slice'): + self.assertEqual(repr(y), repr(x)) + self.assertIsNot(x, y) + self.assertEqual(x.value, ((1, 2), 3, (4, 5, Symbol('baz')), ('quux',))) + self.assertEqual(x.lvalue, [[1, 2], 3, [4, 5, Symbol('baz')], ['quux']]) + self.assertEqual(str(x), '((1 2) 3 (4 5 baz) ("quux"))') + self.assertEqual(repr(x), repr(Expression.from_string(str(x)))) + self.assertEqual(len(x), 4) + self.assertEqual(bool(x), True) + self.assertEqual(tuple(x), (Expression((1, 2)), Expression(3), Expression((4, 5, Symbol('baz'))), Expression(('quux',)))) + with self.assertRaisesRegex(TypeError, 'key must be an integer or a slice'): x[object()] - assert_equal(x[1], Expression(3)) - assert_equal(x[-1][0], Expression('quux')) - with assert_raises_str(IndexError, 'list index of out range'): + self.assertEqual(x[1], Expression(3)) + self.assertEqual(x[-1][0], Expression('quux')) + with self.assertRaisesRegex(IndexError, 'list index of out range'): x[6] - with assert_raises_str(IndexError, 'list index of out range'): + with self.assertRaisesRegex(IndexError, 'list index of out range'): x[-6] - assert_equal(x[:].value, x.value) - assert_equal(x[:].lvalue, x.lvalue) - assert_repr(x[1:], "Expression([3, [4, 5, Symbol('baz')], ['quux']])") - assert_repr(x[-2:], "Expression([[4, 5, Symbol('baz')], ['quux']])") + self.assertEqual(x[:].value, x.value) + self.assertEqual(x[:].lvalue, x.lvalue) + self.assertEqual(repr(x[1:]), "Expression([3, [4, 5, Symbol('baz')], ['quux']])") + self.assertEqual(repr(x[-2:]), "Expression([[4, 5, Symbol('baz')], ['quux']])") x[-2:] = 4, 5, 6 - assert_repr(x, 'Expression([[1, 2], 3, 4, 5, 6])') + self.assertEqual(repr(x), 'Expression([[1, 2], 3, 4, 5, 6])') x[0] = 2 - assert_repr(x, 'Expression([2, 3, 4, 5, 6])') + self.assertEqual(repr(x), 'Expression([2, 3, 4, 5, 6])') x[:] = (1, 3, 5) - assert_repr(x, 'Expression([1, 3, 5])') + self.assertEqual(repr(x), 'Expression([1, 3, 5])') x[3:] = 7, - assert_repr(x, 'Expression([1, 3, 5, 7])') - with assert_raises_str(NotImplementedError, 'only [n:] slices are supported'): + self.assertEqual(repr(x), 'Expression([1, 3, 5, 7])') + with self.assertRaisesRegex(NotImplementedError, r'only \[n:\] slices are supported'): x[object():] - with assert_raises_str(NotImplementedError, 'only [n:] slices are supported'): + with self.assertRaisesRegex(NotImplementedError, r'only \[n:\] slices are supported'): x[:2] - with assert_raises_str(NotImplementedError, 'only [n:] slices are supported'): + with self.assertRaisesRegex(NotImplementedError, r'only \[n:\] slices are supported'): x[object():] = [] - with assert_raises_str(NotImplementedError, 'only [n:] slices are supported'): + with self.assertRaisesRegex(NotImplementedError, r'only \[n:\] slices are supported'): x[:2] = [] - with assert_raises_str(TypeError, 'can only assign a list expression'): + with self.assertRaisesRegex(TypeError, 'can only assign a list expression'): x[:] = 0 - assert_equal(x, Expression((1, 3, 5, 7))) - assert_not_equal(x, Expression((2, 4, 6))) - assert_not_equal(x, (1, 3, 5, 7)) - with assert_raises_str(TypeError, "unhashable type: 'ListExpression'"): + self.assertEqual(x, Expression((1, 3, 5, 7))) + self.assertNotEqual(x, Expression((2, 4, 6))) + self.assertNotEqual(x, (1, 3, 5, 7)) + with self.assertRaisesRegex(TypeError, "unhashable type: 'ListExpression'"): hash(x) def test_insert(self): @@ -342,16 +335,16 @@ class test_list_expressions(): expr = Expression(()) for pos in [-8, 4, 6, -5, -7, 5, 7, 2, -3, 8, 10, -2, 1, -9, -10, -4, -6, 0, 9, 3, -1]: lst.insert(pos, pos) - assert_is(expr.insert(pos, pos), None) - assert_equal(expr, Expression(lst)) - assert_equal(expr.lvalue, lst) + self.assertIs(expr.insert(pos, pos), None) + self.assertEqual(expr, Expression(lst)) + self.assertEqual(expr.lvalue, lst) def test_append(self): expr = Expression(()) for i in range(10): - assert_is(expr.append(i), None) - assert_equal(expr, Expression(range(i + 1))) - assert_equal(expr.lvalue, list(range(i + 1))) + self.assertIs(expr.append(i), None) + self.assertEqual(expr, Expression(range(i + 1))) + self.assertEqual(expr.lvalue, list(range(i + 1))) def test_extend(self): lst = [] @@ -359,9 +352,9 @@ class test_list_expressions(): for ext in [1], [], [2, 3]: lst.extend(ext) expr.extend(ext) - assert_equal(expr, Expression(lst)) - assert_equal(expr.lvalue, lst) - with assert_raises_str(TypeError, "'int' object is not iterable"): + self.assertEqual(expr, Expression(lst)) + self.assertEqual(expr.lvalue, lst) + with self.assertRaisesRegex(TypeError, r"'int' object is not iterable"): expr.extend(0) def test_inplace_add(self): @@ -370,96 +363,96 @@ class test_list_expressions(): for ext in [], [1], [], [2, 3]: lst += ext expr += ext - assert_equal(expr, Expression(lst)) - assert_equal(expr.lvalue, lst) - assert_is(expr, expr0) - with assert_raises_str(TypeError, "'int' object is not iterable"): + self.assertEqual(expr, Expression(lst)) + self.assertEqual(expr.lvalue, lst) + self.assertIs(expr, expr0) + with self.assertRaisesRegex(TypeError, r"'int' object is not iterable"): expr += 0 def test_pop(self): expr = Expression([0, 1, 2, 3, 4, 5, 6]) - assert_equal(expr.pop(0), Expression(0)) - assert_equal(expr, Expression([1, 2, 3, 4, 5, 6])) - with assert_raises_str(IndexError, 'pop index of out range'): + self.assertEqual(expr.pop(0), Expression(0)) + self.assertEqual(expr, Expression([1, 2, 3, 4, 5, 6])) + with self.assertRaisesRegex(IndexError, 'pop index of out range'): expr.pop(6) - assert_equal(expr.pop(5), Expression(6)) - assert_equal(expr, Expression([1, 2, 3, 4, 5])) - assert_equal(expr.pop(-1), Expression(5)) - assert_equal(expr, Expression([1, 2, 3, 4])) - assert_equal(expr.pop(-2), Expression(3)) - assert_equal(expr, Expression([1, 2, 4])) - assert_equal(expr.pop(1), Expression(2)) - assert_equal(expr, Expression([1, 4])) + self.assertEqual(expr.pop(5), Expression(6)) + self.assertEqual(expr, Expression([1, 2, 3, 4, 5])) + self.assertEqual(expr.pop(-1), Expression(5)) + self.assertEqual(expr, Expression([1, 2, 3, 4])) + self.assertEqual(expr.pop(-2), Expression(3)) + self.assertEqual(expr, Expression([1, 2, 4])) + self.assertEqual(expr.pop(1), Expression(2)) + self.assertEqual(expr, Expression([1, 4])) expr.pop() expr.pop() - with assert_raises_str(IndexError, 'pop from empty list'): + with self.assertRaisesRegex(IndexError, 'pop from empty list'): expr.pop() for i in range(-2, 3): - with assert_raises_str(IndexError, 'pop from empty list'): + with self.assertRaisesRegex(IndexError, 'pop from empty list'): expr.pop(i) def test_delitem(self): expr = Expression([0, 1, 2, 3, 4, 5, 6]) del expr[0] - assert_equal(expr, Expression([1, 2, 3, 4, 5, 6])) - with assert_raises_str(IndexError, 'pop index of out range'): + self.assertEqual(expr, Expression([1, 2, 3, 4, 5, 6])) + with self.assertRaisesRegex(IndexError, 'pop index of out range'): expr.pop(6) del expr[5] - assert_equal(expr, Expression([1, 2, 3, 4, 5])) + self.assertEqual(expr, Expression([1, 2, 3, 4, 5])) del expr[-1] - assert_equal(expr, Expression([1, 2, 3, 4])) + self.assertEqual(expr, Expression([1, 2, 3, 4])) del expr[-2] - assert_equal(expr, Expression([1, 2, 4])) + self.assertEqual(expr, Expression([1, 2, 4])) del expr[1] - assert_equal(expr, Expression([1, 4])) + self.assertEqual(expr, Expression([1, 4])) del expr[1:] - assert_equal(expr, Expression([1])) + self.assertEqual(expr, Expression([1])) del expr[:] - assert_equal(expr, Expression([])) + self.assertEqual(expr, Expression([])) for i in range(-2, 3): - with assert_raises_str(IndexError, 'pop from empty list'): + with self.assertRaisesRegex(IndexError, 'pop from empty list'): del expr[i] def test_remove(self): expr = Expression([0, 1, 2, 3, 4, 5, 6]) expr.remove(Expression(0)) - assert_equal(expr, Expression([1, 2, 3, 4, 5, 6])) - with assert_raises_str(IndexError, 'item not in list'): + self.assertEqual(expr, Expression([1, 2, 3, 4, 5, 6])) + with self.assertRaisesRegex(IndexError, 'item not in list'): expr.remove(Expression(0)) expr.remove(Expression(6)) - assert_equal(expr, Expression([1, 2, 3, 4, 5])) + self.assertEqual(expr, Expression([1, 2, 3, 4, 5])) expr.remove(Expression(5)) - assert_equal(expr, Expression([1, 2, 3, 4])) + self.assertEqual(expr, Expression([1, 2, 3, 4])) expr.remove(Expression(3)) - assert_equal(expr, Expression([1, 2, 4])) + self.assertEqual(expr, Expression([1, 2, 4])) expr.remove(Expression(2)) - assert_equal(expr, Expression([1, 4])) + self.assertEqual(expr, Expression([1, 4])) expr.remove(Expression(4)) expr.remove(Expression(1)) - with assert_raises_str(IndexError, 'item not in list'): + with self.assertRaisesRegex(IndexError, 'item not in list'): expr.remove(Expression(-1)) def test_contains(self): expr = Expression(()) - assert_not_in(Expression(42), expr) + self.assertNotIn(Expression(42), expr) lst = (1, 2, 3) expr = Expression(lst) for x in lst: - assert_not_in(x, expr) - assert_in(Expression(x), expr) - assert_not_in(Expression(max(lst) + 1), expr) + self.assertNotIn(x, expr) + self.assertIn(Expression(x), expr) + self.assertNotIn(Expression(max(lst) + 1), expr) def test_index(self): expr = Expression(()) - with assert_raises_str(ValueError, 'value not in list'): + with self.assertRaisesRegex(ValueError, 'value not in list'): expr.index(Expression(42)) lst = [1, 2, 3] expr = Expression(lst) for x in lst: i = lst.index(x) j = expr.index(Expression(x)) - assert_equal(i, j) - with assert_raises_str(ValueError, 'value not in list'): + self.assertEqual(i, j) + with self.assertRaisesRegex(ValueError, 'value not in list'): expr.index(Expression(max(lst) + 1)) def test_count(self): @@ -468,25 +461,25 @@ class test_list_expressions(): for x in lst + [max(lst) + 1]: i = lst.count(x) j = expr.count(Expression(x)) - assert_equal(i, j) + self.assertEqual(i, j) def test_reverse(self): for lst in (), (1, 2, 3): expr = Expression(lst) - assert_equal( + self.assertEqual( Expression(reversed(expr)), Expression(reversed(lst)) ) - assert_equal( + self.assertEqual( Expression(reversed(expr)).value, tuple(reversed(lst)) ) - assert_is(expr.reverse(), None) - assert_equal( + self.assertIs(expr.reverse(), None) + self.assertEqual( expr, Expression(reversed(lst)) ) - assert_equal( + self.assertEqual( expr.value, tuple(reversed(lst)) ) @@ -495,67 +488,67 @@ class test_list_expressions(): x = Expression([1, [2], 3]) y = Expression(x) x[1][0] = 0 - assert_repr(x, 'Expression([1, [0], 3])') - assert_repr(y, 'Expression([1, [0], 3])') + self.assertEqual(repr(x), 'Expression([1, [0], 3])') + self.assertEqual(repr(y), 'Expression([1, [0], 3])') x[1] = 0 - assert_repr(x, 'Expression([1, 0, 3])') - assert_repr(y, 'Expression([1, [0], 3])') + self.assertEqual(repr(x), 'Expression([1, 0, 3])') + self.assertEqual(repr(y), 'Expression([1, [0], 3])') def test_copy2(self): x = Expression([1, [2], 3]) y = copy.copy(x) x[1][0] = 0 - assert_repr(x, 'Expression([1, [0], 3])') - assert_repr(y, 'Expression([1, [0], 3])') + self.assertEqual(repr(x), 'Expression([1, [0], 3])') + self.assertEqual(repr(y), 'Expression([1, [0], 3])') x[1] = 0 - assert_repr(x, 'Expression([1, 0, 3])') - assert_repr(y, 'Expression([1, [0], 3])') + self.assertEqual(repr(x), 'Expression([1, 0, 3])') + self.assertEqual(repr(y), 'Expression([1, [0], 3])') def test_copy3(self): x = Expression([1, [2], 3]) y = copy.deepcopy(x) x[1][0] = 0 - assert_repr(x, 'Expression([1, [0], 3])') - assert_repr(y, 'Expression([1, [2], 3])') + self.assertEqual(repr(x), 'Expression([1, [0], 3])') + self.assertEqual(repr(y), 'Expression([1, [2], 3])') x[1] = 0 - assert_repr(x, 'Expression([1, 0, 3])') - assert_repr(y, 'Expression([1, [2], 3])') + self.assertEqual(repr(x), 'Expression([1, 0, 3])') + self.assertEqual(repr(y), 'Expression([1, [2], 3])') def test_abc(self): x = Expression(()) - assert_is_instance(x, collections_abc.MutableSequence) - assert_is_instance(iter(x), collections_abc.Iterator) + self.assertIsInstance(x, collections_abc.MutableSequence) + self.assertIsInstance(iter(x), collections_abc.Iterator) def test_pickle(self): for lst in (), (1, 2, 3), (1, (2, 3)): x = Expression(lst) - assert_pickle_equal(x) + self.assert_pickle_equal(x) -class test_expression_parser(): +class test_expression_parser(TestBase): def test_badstring(self): - with assert_raises(ExpressionSyntaxError): + with self.assertRaises(ExpressionSyntaxError): Expression.from_string('(1') def test_attr_from_file(self): - assert_is(getattr(Expression, 'from_file', None), None) + self.assertIs(getattr(Expression, 'from_file', None), None) def test_bad_io(self): - with assert_raises_str(AttributeError, "'int' object has no attribute 'read'"): + with self.assertRaisesRegex(AttributeError, "'int' object has no attribute 'read'"): Expression.from_stream(42) def test_bad_file_io(self): if os.name == 'nt': - raise SkipTest('not implemented on Windows') + raise unittest.SkipTest('not implemented on Windows') path = '/proc/self/mem' try: os.stat(path) except OSError as exc: - raise SkipTest('{exc.filename}: {exc.strerror}'.format(exc=exc)) + raise unittest.SkipTest('{exc.filename}: {exc.strerror}'.format(exc=exc)) with open('/proc/self/mem') as fp: - with assert_raises(IOError) as ecm: + with self.assertRaises(IOError) as ecm: Expression.from_stream(fp) - assert_in( + self.assertIn( ecm.exception.errno, (errno.EIO, errno.EFAULT) ) @@ -563,10 +556,10 @@ class test_expression_parser(): if py3k: def test_bad_unicode_io(self): fp = StringIO(chr(0xD800)) - with assert_raises(UnicodeEncodeError): + with self.assertRaises(UnicodeEncodeError): Expression.from_stream(fp) -class test_expression_parser_ascii(): +class test_expression_parser_ascii(TestBase): expr = '(eggs) (ham)' repr = ["Expression([Symbol('eggs')])", "Expression([Symbol('ham')])"] @@ -575,10 +568,10 @@ class test_expression_parser_ascii(): def read(): return Expression.from_stream(fp) x = read() - assert_repr(x, self.repr[0]) + self.assertEqual(repr(x), self.repr[0]) x = read() - assert_repr(x, self.repr[1]) - with assert_raises(ExpressionSyntaxError): + self.assertEqual(repr(x), self.repr[1]) + with self.assertRaises(ExpressionSyntaxError): x = read() def test_stringio(self): @@ -625,11 +618,11 @@ class test_expression_parser_nonascii(test_expression_parser_ascii): if not py3k: repr = [s.decode('ISO-8859-1').encode('ASCII', 'backslashreplace') for s in repr] -class test_expression_writer(): +class test_expression_writer(TestBase): def test_bad_io(self): expr = Expression(23) - with assert_raises_str(AttributeError, "'int' object has no attribute 'write'"): + with self.assertRaisesRegex(AttributeError, "'int' object has no attribute 'write'"): expr.print_into(42) def test_bad_file_io(self): @@ -638,11 +631,11 @@ class test_expression_writer(): try: os.stat(path) except OSError as exc: - raise SkipTest('{exc.filename}: {exc.strerror}'.format(exc=exc)) + raise unittest.SkipTest('{exc.filename}: {exc.strerror}'.format(exc=exc)) fp = open(path, 'w', buffering=2) expr = Expression(23) try: - with assert_raises(IOError) as ecm: + with self.assertRaises(IOError) as ecm: for i in range(10000): expr.print_into(fp) finally: @@ -651,11 +644,11 @@ class test_expression_writer(): except IOError: if ecm is None: raise - assert_equal(ecm.exception.errno, errno.ENOSPC) + self.assertEqual(ecm.exception.errno, errno.ENOSPC) def test_reentrant(self): if not _ExpressionIO._reentrant: - raise SkipTest('this test requires DjVuLibre >= 3.5.26') + raise unittest.SkipTest('this test requires DjVuLibre >= 3.5.26') class File(object): def write(self, s): expr.as_string() @@ -670,7 +663,7 @@ class test_expression_writer(): expr.print_into(fp, escape_unicode=v) expr.as_string(escape_unicode=v) -class test_expression_writer_ascii(): +class test_expression_writer_ascii(TestBase): expr = Expression([Symbol('eggs'), Symbol('ham')]) repr = urepr = '(eggs ham)' @@ -678,28 +671,28 @@ class test_expression_writer_ascii(): def test_stringio_7(self): fp = StringIO() self.expr.print_into(fp) - assert_equal(fp.getvalue(), self.repr) + self.assertEqual(fp.getvalue(), self.repr) def test_stringio_8(self): fp = StringIO() self.expr.print_into(fp, escape_unicode=False) - assert_equal(fp.getvalue(), self.urepr) + self.assertEqual(fp.getvalue(), self.urepr) def test_bytesio_7(self): fp = io.BytesIO() self.expr.print_into(fp) - assert_equal(fp.getvalue(), b(self.repr)) + self.assertEqual(fp.getvalue(), b(self.repr)) def test_bytesio_8(self): fp = io.BytesIO() self.expr.print_into(fp, escape_unicode=False) - assert_equal(fp.getvalue(), b(self.urepr)) + self.assertEqual(fp.getvalue(), b(self.urepr)) def test_file_io_text_7(self): with tempfile.TemporaryFile(mode='w+t') as fp: self.expr.print_into(fp) fp.seek(0) - assert_equal(fp.read(), self.repr) + self.assertEqual(fp.read(), self.repr) def test_file_io_text_8(self): if py3k: @@ -709,7 +702,7 @@ class test_expression_writer_ascii(): with fp: self.expr.print_into(fp, escape_unicode=False) fp.seek(0) - assert_equal(fp.read(), self.urepr) + self.assertEqual(fp.read(), self.urepr) def test_codecs_io_text_7(self): tmpdir = tempfile.mkdtemp() @@ -718,7 +711,7 @@ class test_expression_writer_ascii(): with codecs.open(path, mode='w+', encoding='UTF-16-LE') as fp: self.expr.print_into(fp) fp.seek(0) - assert_equal(fp.read(), self.repr) + self.assertEqual(fp.read(), self.repr) finally: shutil.rmtree(tmpdir) @@ -729,7 +722,7 @@ class test_expression_writer_ascii(): with codecs.open(path, mode='w+', encoding='UTF-16-LE') as fp: self.expr.print_into(fp, escape_unicode=False) fp.seek(0) - assert_equal(fp.read(), u(self.urepr)) + self.assertEqual(fp.read(), u(self.urepr)) finally: shutil.rmtree(tmpdir) @@ -737,45 +730,48 @@ class test_expression_writer_ascii(): with tempfile.TemporaryFile(mode='w+b') as fp: self.expr.print_into(fp) fp.seek(0) - assert_equal(fp.read(), b(self.repr)) + self.assertEqual(fp.read(), b(self.repr)) def test_file_io_binary_8(self): with tempfile.TemporaryFile(mode='w+b') as fp: self.expr.print_into(fp, escape_unicode=False) fp.seek(0) - assert_equal(fp.read(), b(self.urepr)) + self.assertEqual(fp.read(), b(self.urepr)) def test_as_string_7(self): s = self.expr.as_string() - assert_equal(s, self.repr) + self.assertEqual(s, self.repr) def test_as_string_8(self): s = self.expr.as_string(escape_unicode=False) - assert_equal(s, self.urepr) + self.assertEqual(s, self.urepr) class test_expression_writer_nonascii(test_expression_writer_ascii): + def test_expression_nonascii(self): + expr = Expression(u('żółw')) + repr = r'"\305\274\303\263\305\202w"' + urepr = r'"żółw"' - expr = Expression(u('żółw')) - repr = r'"\305\274\303\263\305\202w"' - urepr = r'"żółw"' +class TestGeneralSettings(TestBase): -def test_version(): - assert_is_instance(__version__, str) - assert_equal(__version__, get_changelog_version()) + def test_version(self): + self.assertIsInstance(__version__, str) + self.assertEqual(__version__, get_changelog_version()) -def test_wildcard_import(): - ns = wildcard_import('djvu.sexpr') - assert_list_equal( - sorted(ns.keys()), [ - 'Expression', - 'ExpressionSyntaxError', - 'IntExpression', - 'InvalidExpression', - 'ListExpression', - 'StringExpression', - 'Symbol', - 'SymbolExpression' - ] - ) + def test_wildcard_import(self): + ns = {} + exec('from djvu.sexpr import *', {}, ns) + self.assertEqual( + sorted(ns.keys()), [ + 'Expression', + 'ExpressionSyntaxError', + 'IntExpression', + 'InvalidExpression', + 'ListExpression', + 'StringExpression', + 'Symbol', + 'SymbolExpression' + ] + ) # vim:ts=4 sts=4 sw=4 et diff --git a/tests/tools.py b/tests/tools.py index f7591ad..d71675b 100644 --- a/tests/tools.py +++ b/tests/tools.py @@ -22,16 +22,7 @@ import os import re import sys -from nose import SkipTest - -import nose.tools - -from nose.tools import ( - assert_true, - assert_false, - assert_equal, - assert_not_equal, -) +from unittest import SkipTest def get_changelog_version(): here = os.path.dirname(__file__) @@ -40,108 +31,6 @@ def get_changelog_version(): line = file.readline() return line.split()[1].strip('()') -def noseimport(vmaj, vmin, name=None): - def wrapper(f): - if f.__module__ == 'unittest.case': - return f - if sys.version_info >= (vmaj, vmin): - return getattr(nose.tools, name or f.__name__) - return f - return wrapper - -@noseimport(2, 7) -def assert_in(x, y): - assert_true( - x in y, - msg='{0!r} not found in {1!r}'.format(x, y) - ) - -@noseimport(2, 7) -def assert_is(x, y): - assert_true( - x is y, - msg='{0!r} is not {1!r}'.format(x, y) - ) - -@noseimport(2, 7) -def assert_is_instance(obj, cls): - assert_true( - isinstance(obj, cls), - msg='{0!r} is not an instance of {1!r}'.format(obj, cls) - ) - -@noseimport(2, 7) -def assert_less(x, y): - assert_true( - x < y, - msg='{0!r} not less than {1!r}'.format(x, y) - ) - -@noseimport(2, 7) -def assert_list_equal(x, y): - assert_is_instance(x, list) - assert_is_instance(y, list) - return assert_equal(x, y) - -@noseimport(2, 7) -def assert_multi_line_equal(x, y): - return assert_equal(x, y) -if sys.version_info >= (2, 7): - type(assert_multi_line_equal.__self__).maxDiff = None - -@noseimport(2, 7) -def assert_not_in(x, y): - assert_true( - x not in y, - msg='{0!r} unexpectedly found in {1!r}'.format(x, y) - ) - -@noseimport(2, 7) -class assert_raises(object): - def __init__(self, exc_type): - self._exc_type = exc_type - self.exception = None - def __enter__(self): - return self - def __exit__(self, exc_type, exc_value, tb): - if exc_type is None: - assert_true(False, '{0} not raised'.format(self._exc_type.__name__)) - if not issubclass(exc_type, self._exc_type): - return False - if isinstance(exc_value, exc_type): - pass - # This branch is not always taken in Python 2.6: - # https://bugs.python.org/issue7853 - elif isinstance(exc_value, tuple): - exc_value = exc_type(*exc_value) - else: - exc_value = exc_type(exc_value) - self.exception = exc_value - return True - -@noseimport(2, 7, 'assert_raises_regexp') -@noseimport(3, 2) -@contextlib.contextmanager -def assert_raises_regex(exc_type, regex): - with assert_raises(exc_type) as ecm: - yield - assert_regex(str(ecm.exception), regex) - -@noseimport(2, 7, 'assert_regexp_matches') -@noseimport(3, 2) -def assert_regex(text, regex): - if isinstance(regex, (bytes, str, unicode)): - regex = re.compile(regex) - if not regex.search(text): - message = "Regex didn't match: {0!r} not found in {1!r}".format(regex.pattern, text) - assert_true(False, msg=message) - -@contextlib.contextmanager -def assert_raises_str(exc_type, s): - with assert_raises(exc_type) as ecm: - yield - assert_equal(str(ecm.exception), s) - try: locale.LC_MESSAGES except AttributeError: @@ -247,32 +136,13 @@ def wildcard_import(mod): __all__ = [ # Python 2/3 compat: - 'StringIO', 'b', 'cmp', 'long', 'py3k', 'u', 'unicode', - # nose - 'SkipTest', - 'assert_equal', - 'assert_false', - 'assert_in', - 'assert_is', - 'assert_is_instance', - 'assert_less', - 'assert_list_equal', - 'assert_multi_line_equal', - 'assert_not_equal', - 'assert_not_in', - 'assert_raises', - 'assert_raises_regex', - 'assert_regex', - 'assert_true', # misc - 'assert_raises_str', - 'assert_repr', 'get_changelog_version', 'interim', 'interim_locale', @@ -280,7 +150,6 @@ __all__ = [ 'skip_unless_c_messages', 'skip_unless_command_exists', 'skip_unless_translation_exists', - 'wildcard_import', ] # vim:ts=4 sts=4 sw=4 et -- 2.32.0
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
