def test_nonexistent_ja(self):
skip_unless_c_messages()
skip_unless_translation_exists('ja_JP.UTF-8')
path = '__nonexistent__'
context = Context()
try:
with interim_locale(LC_ALL='ja_JP.UTF-8'):
os.stat(path)
except OSError as ex:
c_message = ex.args[1]
else:
raise OSError(errno.EEXIST, os.strerror(errno.EEXIST), path)
try:
c_message.encode('ASCII')
except UnicodeError:
pass
else:
raise AssertionError(
'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):
context.new_document(FileUri(path))
message = context.get_message()
assert_equal(type(message), ErrorMessage)
assert_equal(type(message.message), unicode)
assert_equal(
message.message,
u("[1-11711] Failed to open '{path}': {msg}.".format(path=path, msg=c_message))
)
assert_equal(
str(message),
"[1-11711] Failed to open '{path}': {msg}.".format(path=path, msg=c_message)
)
assert_equal(unicode(message), message.message)
def test_nonexistent_ja(self):
skip_unless_c_messages()
skip_unless_translation_exists('ja_JP.UTF-8')
path = '__nonexistent__'
context = Context()
try:
with interim_locale(LC_ALL='ja_JP.UTF-8'):
os.stat(path)
except OSError as ex:
c_message = ex.args[1]
else:
raise OSError(errno.EEXIST, os.strerror(errno.EEXIST), path)
try:
c_message.encode('ASCII')
except UnicodeError:
pass
else:
raise AssertionError(
'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):
context.new_document(FileUri(path))
message = context.get_message()
assert_equal(type(message), ErrorMessage)
assert_equal(type(message.message), unicode)
assert_equal(
message.message,
u("[1-11711] Failed to open '{path}': {msg}.".format(
path=path, msg=c_message)))
assert_equal(
str(message),
"[1-11711] Failed to open '{path}': {msg}.".format(
path=path, msg=c_message))
assert_equal(unicode(message), message.message)
def t(self, fp):
def read():
return Expression.from_stream(fp)
x = read()
assert_repr(x, self.repr[0])
x = read()
assert_repr(x, self.repr[1])
with assert_raises(ExpressionSyntaxError):
x = read()
def t(self, fp):
def read():
return Expression.from_stream(fp)
x = read()
assert_repr(x, self.repr[0])
x = read()
assert_repr(x, self.repr[1])
with assert_raises(ExpressionSyntaxError):
x = read()
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):
document.outline.sexpr
with assert_raises(NotAvailable):
document.annotations.sexpr
with assert_raises(NotAvailable):
document.pages[0].text.sexpr
with assert_raises(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'):
message.stream.write(b'eggs')
message = document.get_message()
assert_equal(type(message), DocInfoMessage)
outline = document.outline
outline.wait()
x = outline.sexpr
assert_equal(x, Expression([]))
anno = document.annotations
anno.wait()
x = anno.sexpr
assert_equal(x, Expression([]))
text = document.pages[0].text
text.wait()
x = text.sexpr
assert_equal(x, Expression([]))
anno = document.pages[0].annotations
anno.wait()
x = anno.sexpr
assert_equal(x, Expression([]))
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):
document.outline.sexpr
with assert_raises(NotAvailable):
document.annotations.sexpr
with assert_raises(NotAvailable):
document.pages[0].text.sexpr
with assert_raises(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'):
message.stream.write(b'eggs')
message = document.get_message()
assert_equal(type(message), DocInfoMessage)
outline = document.outline
outline.wait()
x = outline.sexpr
assert_equal(x, Expression([]))
anno = document.annotations
anno.wait()
x = anno.sexpr
assert_equal(x, Expression([]))
text = document.pages[0].text
text.wait()
x = text.sexpr
assert_equal(x, Expression([]))
anno = document.pages[0].annotations
anno.wait()
x = anno.sexpr
assert_equal(x, Expression([]))
def test_bad_file_io(self):
if os.name == 'nt':
raise 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))
with open('/proc/self/mem') as fp:
with assert_raises(IOError) as ecm:
Expression.from_stream(fp)
assert_in(ecm.exception.errno, (errno.EIO, errno.EFAULT))
def test_palette(self):
with assert_raises(KeyError) as ecm:
pf = PixelFormatPalette({})
assert_equal(ecm.exception.args, ((0, 0, 0), ))
data = dict(((i, j, k), i + 7 * j + 37 + k) for i in range(6)
for j in range(6) for k in range(6))
pf = PixelFormatPalette(data)
data_repr = ', '.join('{k!r}: 0x{v:02x}'.format(k=k, v=v)
for k, v in sorted(data.items()))
assert_equal(
repr(pf),
'djvu.decode.PixelFormatPalette({{{data}}}, bpp = 8)'.format(
data=data_repr))
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()
def test_bad_file_io(self):
if os.name == 'nt':
raise 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))
with open('/proc/self/mem') as fp:
with assert_raises(IOError) as ecm:
Expression.from_stream(fp)
assert_in(
ecm.exception.errno,
(errno.EIO, errno.EFAULT)
)
def test_palette(self):
with assert_raises(KeyError) as ecm:
pf = PixelFormatPalette({})
assert_equal(
ecm.exception.args,
((0, 0, 0),)
)
data = dict(((i, j, k), i + 7 * j + 37 + k) for i in range(6) for j in range(6) for k in range(6))
pf = PixelFormatPalette(data)
data_repr = ', '.join(
'{k!r}: 0x{v:02x}'.format(k=k, v=v) for k, v in sorted(data.items())
)
assert_equal(
repr(pf),
'djvu.decode.PixelFormatPalette({{{data}}}, bpp = 8)'.format(data=data_repr)
)
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()
def test_bad_file_io(self):
ecm = None
path = '/dev/full'
try:
os.stat(path)
except OSError as exc:
raise SkipTest('{exc.filename}: {exc.strerror}'.format(exc=exc))
fp = open(path, 'w', buffering=2)
expr = Expression(23)
try:
with assert_raises(IOError) as ecm:
for i in range(10000):
expr.print_into(fp)
finally:
try:
fp.close()
except IOError:
if ecm is None:
raise
assert_equal(ecm.exception.errno, errno.ENOSPC)
def test_bad_file_io(self):
ecm = None
path = '/dev/full'
try:
os.stat(path)
except OSError as exc:
raise SkipTest('{exc.filename}: {exc.strerror}'.format(exc=exc))
fp = open(path, 'w', buffering=2)
expr = Expression(23)
try:
with assert_raises(IOError) as ecm:
for i in range(10000):
expr.print_into(fp)
finally:
try:
fp.close()
except IOError:
if ecm is None:
raise
assert_equal(ecm.exception.errno, errno.ENOSPC)
def test_nonexistent(self):
path = '__nonexistent__'
try:
os.stat(path)
except OSError as ex:
c_message = ex.args[1]
else:
raise OSError(errno.EEXIST, os.strerror(errno.EEXIST), path)
c_message.encode('ASCII')
skip_unless_c_messages()
context = Context()
with assert_raises(JobFailed):
context.new_document(FileUri(path))
message = context.get_message()
assert_equal(type(message), ErrorMessage)
assert_equal(type(message.message), unicode)
assert_equal(
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)
def test_nonexistent(self):
path = '__nonexistent__'
try:
os.stat(path)
except OSError as ex:
c_message = ex.args[1]
else:
raise OSError(errno.EEXIST, os.strerror(errno.EEXIST), path)
c_message.encode('ASCII')
skip_unless_c_messages()
context = Context()
with assert_raises(JobFailed):
context.new_document(FileUri(path))
message = context.get_message()
assert_equal(type(message), ErrorMessage)
assert_equal(type(message.message), unicode)
assert_equal(
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)
def test_badstring(self):
with assert_raises(ExpressionSyntaxError):
Expression.from_string('(1')
def test_parse(self):
with assert_raises(ExpressionSyntaxError):
x = Expression.from_string('3.14')
if isinstance(x.value, Symbol):
raise ExpressionSyntaxError
def test_bad_unicode_io(self):
fp = StringIO(chr(0xD800))
with assert_raises(UnicodeEncodeError):
Expression.from_stream(fp)
def test_bad_unicode_io(self):
fp = StringIO(chr(0xD800))
with assert_raises(UnicodeEncodeError):
Expression.from_stream(fp)
def test_badstring(self):
with assert_raises(ExpressionSyntaxError):
Expression.from_string('(1')
def test_parse(self):
with assert_raises(ExpressionSyntaxError):
x = Expression.from_string('3.14')
if isinstance(x.value, Symbol):
raise ExpressionSyntaxError
