forked from pool/python-djvulibre
Matej Cepl
ea2dec2805
OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-djvulibre?expand=0&rev=46
2548 lines
103 KiB
Diff
2548 lines
103 KiB
Diff
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
|
|
|
|
|