File python-kitchen-remove-nose.patch of Package python-kitchen
Index: kitchen-1.2.6/kitchen2/tests/test__all__.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test__all__.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test__all__.py 2020-09-09 14:50:23.910571749 +0200
@@ -1,5 +1,6 @@
# -*- coding: utf-8 -*-
-from nose import tools
+
+import unittest
import os
import types
@@ -18,7 +19,7 @@ class NoAll(RuntimeError):
class FailedImport(RuntimeError):
pass
-class Test__all__(object):
+class Test__all__(unittest.TestCase):
'''Test that every function in __all__ exists and that no public methods
are missing from __all__
'''
@@ -100,9 +101,9 @@ class Test__all__(object):
try:
try:
f = open(modpath, 'rb')
- tools.ok_('__all__' in f.read(), '%s does not contain __all__' % modpath)
+ self.assertTrue('__all__' in f.read(), '%s does not contain __all__' % modpath)
except IOError, e:
- tools.ok_(False, '%s' % e)
+ self.assertTrue(False, '%s' % e)
finally:
if f:
f.close()
@@ -131,13 +132,13 @@ class Test__all__(object):
exec 'from %s.%s import *' % (modpath, modname) in interior_names
except Exception, e:
# Include the module name in the exception string
- tools.ok_(False, '__all__ failure in %s: %s: %s' % (
+ self.assertTrue(False, '__all__ failure in %s: %s: %s' % (
modname, e.__class__.__name__, e))
if '__builtins__' in interior_names:
del interior_names['__builtins__']
keys = set(interior_names)
all = set(names[modname].__all__)
- tools.ok_(keys == all)
+ self.assertTrue(keys == all)
def test_everything_in__all__exists(self):
'''
@@ -174,7 +175,7 @@ class Test__all__(object):
all = set(mod.__all__)
public = set(expected_public)
- tools.ok_(all.issuperset(public), 'These public names are not in %s.__all__: %s'
+ self.assertTrue(all.issuperset(public), 'These public names are not in %s.__all__: %s'
% (modname, ', '.join(public.difference(all))))
def test__all__is_complete(self):
Index: kitchen-1.2.6/kitchen2/tests/test_collections.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test_collections.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test_collections.py 2020-09-09 14:50:23.910571749 +0200
@@ -1,28 +1,28 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
from kitchen.pycompat24.sets import add_builtin_set
add_builtin_set()
from kitchen import collections
-def test_strict_dict_get_set():
- '''Test getting and setting items in StrictDict'''
- d = collections.StrictDict()
- d[u'a'] = 1
- d['a'] = 2
- tools.assert_not_equal(d[u'a'], d['a'])
- tools.eq_(len(d), 2)
-
- d[u'\xf1'] = 1
- d['\xf1'] = 2
- d[u'\xf1'.encode('utf-8')] = 3
- tools.eq_(d[u'\xf1'], 1)
- tools.eq_(d['\xf1'], 2)
- tools.eq_(d[u'\xf1'.encode('utf-8')], 3)
- tools.eq_(len(d), 5)
+class TestStrictDictGetSet(unittest.TestCase):
+ def test_strict_dict_get_set(self):
+ '''Test getting and setting items in StrictDict'''
+ d = collections.StrictDict()
+ d[u'a'] = 1
+ d['a'] = 2
+ self.assertNotEqual(d[u'a'], d['a'])
+ self.assertEqual(len(d), 2)
+
+ d[u'\xf1'] = 1
+ d['\xf1'] = 2
+ d[u'\xf1'.encode('utf-8')] = 3
+ self.assertEqual(d[u'\xf1'], 1)
+ self.assertEqual(d['\xf1'], 2)
+ self.assertEqual(d[u'\xf1'.encode('utf-8')], 3)
+ self.assertEqual(len(d), 5)
class TestStrictDict(unittest.TestCase):
def setUp(self):
@@ -94,66 +94,66 @@ class TestStrictDict(unittest.TestCase):
def test__compare_list(self):
'''*sigh* this test support function is so complex we need to test it'''
- tools.ok_(self._compare_lists(['a', 'b', 'c'], ['c', 'a', 'b']))
- tools.ok_(not self._compare_lists(['b', 'c'], ['c', 'a', 'b']))
- tools.ok_(not self._compare_lists([u'a', 'b'], ['a', 'b']))
- tools.ok_(not self._compare_lists(['a', u'b'], [u'a', 'b']))
- tools.ok_(self._compare_lists(['a', 'b', 1], ['a', 1, 'b']))
- tools.ok_(self._compare_lists([u'a', u'b'], [u'a', u'b']))
- tools.ok_(self._compare_lists([u'a', 'b'], [u'a', 'b']))
- tools.ok_(not self._compare_lists([u'a', 'b'], [u'a', u'b']))
- tools.ok_(self._compare_lists([u'a', 'b', 'b', 'c', u'a'], [u'a', u'a', 'b', 'c', 'b']))
- tools.ok_(not self._compare_lists([u'a', 'b', 'b', 'c', 'a'], [u'a', u'a', 'b', 'c', 'b']))
- tools.ok_(not self._compare_lists([u'a', 'b', 'b', 'c', u'a'], [u'a', 'b', 'b', 'c', 'b']))
+ self.assertTrue(self._compare_lists(['a', 'b', 'c'], ['c', 'a', 'b']))
+ self.assertTrue(not self._compare_lists(['b', 'c'], ['c', 'a', 'b']))
+ self.assertTrue(not self._compare_lists([u'a', 'b'], ['a', 'b']))
+ self.assertTrue(not self._compare_lists(['a', u'b'], [u'a', 'b']))
+ self.assertTrue(self._compare_lists(['a', 'b', 1], ['a', 1, 'b']))
+ self.assertTrue(self._compare_lists([u'a', u'b'], [u'a', u'b']))
+ self.assertTrue(self._compare_lists([u'a', 'b'], [u'a', 'b']))
+ self.assertTrue(not self._compare_lists([u'a', 'b'], [u'a', u'b']))
+ self.assertTrue(self._compare_lists([u'a', 'b', 'b', 'c', u'a'], [u'a', u'a', 'b', 'c', 'b']))
+ self.assertTrue(not self._compare_lists([u'a', 'b', 'b', 'c', 'a'], [u'a', u'a', 'b', 'c', 'b']))
+ self.assertTrue(not self._compare_lists([u'a', 'b', 'b', 'c', u'a'], [u'a', 'b', 'b', 'c', 'b']))
def test_strict_dict_len(self):
'''StrictDict len'''
- tools.eq_(len(self.d), 5)
+ self.assertEqual(len(self.d), 5)
def test_strict_dict_del(self):
'''StrictDict del'''
- tools.eq_(len(self.d), 5)
+ self.assertEqual(len(self.d), 5)
del(self.d[u'\xf1'])
- tools.assert_raises(KeyError, self.d.__getitem__, u'\xf1')
- tools.eq_(len(self.d), 4)
+ self.assertRaises(KeyError, self.d.__getitem__, u'\xf1')
+ self.assertEqual(len(self.d), 4)
def test_strict_dict_iter(self):
'''StrictDict iteration'''
keys = []
for k in self.d:
keys.append(k)
- tools.ok_(self._compare_lists(keys, self.keys),
+ self.assertTrue(self._compare_lists(keys, self.keys),
msg='keys != self.key: %s != %s' % (keys, self.keys))
keys = []
for k in self.d.iterkeys():
keys.append(k)
- tools.ok_(self._compare_lists(keys, self.keys),
+ self.assertTrue(self._compare_lists(keys, self.keys),
msg='keys != self.key: %s != %s' % (keys, self.keys))
keys = [k for k in self.d]
- tools.ok_(self._compare_lists(keys, self.keys),
+ self.assertTrue(self._compare_lists(keys, self.keys),
msg='keys != self.key: %s != %s' % (keys, self.keys))
keys = []
for k in self.d.keys():
keys.append(k)
- tools.ok_(self._compare_lists(keys, self.keys),
+ self.assertTrue(self._compare_lists(keys, self.keys),
msg='keys != self.key: %s != %s' % (keys, self.keys))
def test_strict_dict_contains(self):
'''StrictDict contains function'''
- tools.ok_('b' not in self.d)
- tools.ok_(u'b' not in self.d)
- tools.ok_('\xf1' in self.d)
- tools.ok_(u'\xf1' in self.d)
- tools.ok_('a' in self.d)
- tools.ok_(u'a' in self.d)
+ self.assertTrue('b' not in self.d)
+ self.assertTrue(u'b' not in self.d)
+ self.assertTrue('\xf1' in self.d)
+ self.assertTrue(u'\xf1' in self.d)
+ self.assertTrue('a' in self.d)
+ self.assertTrue(u'a' in self.d)
del(self.d[u'\xf1'])
- tools.ok_(u'\xf1' not in self.d)
- tools.ok_('\xf1' in self.d)
+ self.assertTrue(u'\xf1' not in self.d)
+ self.assertTrue('\xf1' in self.d)
del(self.d['a'])
- tools.ok_(u'a' in self.d)
- tools.ok_('a' not in self.d)
+ self.assertTrue(u'a' in self.d)
+ self.assertTrue('a' not in self.d)
Index: kitchen-1.2.6/kitchen2/tests/test_converters.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test_converters.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test_converters.py 2020-09-09 14:50:38.666660897 +0200
@@ -2,8 +2,6 @@
#
import unittest
-from nose import tools
-from nose.plugins.skip import SkipTest
import sys
import StringIO
@@ -49,98 +47,98 @@ class ReprUnicode(object):
class TestConverters(unittest.TestCase, base_classes.UnicodeTestData):
def test_to_unicode(self):
'''Test to_unicode when the user gives good values'''
- tools.eq_(converters.to_unicode(self.u_japanese, encoding='latin1'), self.u_japanese)
+ self.assertEqual(converters.to_unicode(self.u_japanese, encoding='latin1'), self.u_japanese)
- tools.eq_(converters.to_unicode(self.utf8_spanish), self.u_spanish)
- tools.eq_(converters.to_unicode(self.utf8_japanese), self.u_japanese)
+ self.assertEqual(converters.to_unicode(self.utf8_spanish), self.u_spanish)
+ self.assertEqual(converters.to_unicode(self.utf8_japanese), self.u_japanese)
- tools.eq_(converters.to_unicode(self.latin1_spanish, encoding='latin1'), self.u_spanish)
- tools.eq_(converters.to_unicode(self.euc_jp_japanese, encoding='euc_jp'), self.u_japanese)
+ self.assertEqual(converters.to_unicode(self.latin1_spanish, encoding='latin1'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(self.euc_jp_japanese, encoding='euc_jp'), self.u_japanese)
- tools.assert_raises(TypeError, converters.to_unicode, *[5], **{'nonstring': 'foo'})
+ self.assertRaises(TypeError, converters.to_unicode, *[5], **{'nonstring': 'foo'})
def test_to_unicode_errors(self):
- tools.eq_(converters.to_unicode(self.latin1_spanish), self.u_mangled_spanish_latin1_as_utf8)
- tools.eq_(converters.to_unicode(self.latin1_spanish, errors='ignore'), self.u_spanish_ignore)
- tools.assert_raises(UnicodeDecodeError, converters.to_unicode,
+ self.assertEqual(converters.to_unicode(self.latin1_spanish), self.u_mangled_spanish_latin1_as_utf8)
+ self.assertEqual(converters.to_unicode(self.latin1_spanish, errors='ignore'), self.u_spanish_ignore)
+ self.assertRaises(UnicodeDecodeError, converters.to_unicode,
*[self.latin1_spanish], **{'errors': 'strict'})
def test_to_unicode_nonstring(self):
- tools.eq_(converters.to_unicode(5), u'5')
- tools.eq_(converters.to_unicode(5, nonstring='empty'), u'')
- tools.eq_(converters.to_unicode(5, nonstring='passthru'), 5)
- tools.eq_(converters.to_unicode(5, nonstring='simplerepr'), u'5')
- tools.eq_(converters.to_unicode(5, nonstring='repr'), u'5')
- tools.assert_raises(TypeError, converters.to_unicode, *[5], **{'nonstring': 'strict'})
+ self.assertEqual(converters.to_unicode(5), u'5')
+ self.assertEqual(converters.to_unicode(5, nonstring='empty'), u'')
+ self.assertEqual(converters.to_unicode(5, nonstring='passthru'), 5)
+ self.assertEqual(converters.to_unicode(5, nonstring='simplerepr'), u'5')
+ self.assertEqual(converters.to_unicode(5, nonstring='repr'), u'5')
+ self.assertRaises(TypeError, converters.to_unicode, *[5], **{'nonstring': 'strict'})
obj_repr = converters.to_unicode(object, nonstring='simplerepr')
- tools.eq_(obj_repr, u"<type 'object'>")
- tools.assert_true(isinstance(obj_repr, unicode))
+ self.assertEqual(obj_repr, u"<type 'object'>")
+ self.assertTrue(isinstance(obj_repr, unicode))
def test_to_unicode_nonstring_with_objects_that_have__unicode__and__str__(self):
'''Test that to_unicode handles objects that have __unicode__ and __str__ methods'''
if sys.version_info < (3, 0):
# None of these apply on python3 because python3 does not use __unicode__
# and it enforces __str__ returning str
- tools.eq_(converters.to_unicode(UnicodeNoStr(), nonstring='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(StrNoUnicode(), nonstring='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(UnicodeReturnsStr(), nonstring='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(UnicodeNoStr(), nonstring='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(StrNoUnicode(), nonstring='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(UnicodeReturnsStr(), nonstring='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(StrReturnsUnicode(), nonstring='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(UnicodeStrCrossed(), nonstring='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(StrReturnsUnicode(), nonstring='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(UnicodeStrCrossed(), nonstring='simplerepr'), self.u_spanish)
def test_to_bytes(self):
'''Test to_bytes when the user gives good values'''
- tools.eq_(converters.to_bytes(self.utf8_japanese, encoding='latin1'), self.utf8_japanese)
+ self.assertEqual(converters.to_bytes(self.utf8_japanese, encoding='latin1'), self.utf8_japanese)
- tools.eq_(converters.to_bytes(self.u_spanish), self.utf8_spanish)
- tools.eq_(converters.to_bytes(self.u_japanese), self.utf8_japanese)
+ self.assertEqual(converters.to_bytes(self.u_spanish), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(self.u_japanese), self.utf8_japanese)
- tools.eq_(converters.to_bytes(self.u_spanish, encoding='latin1'), self.latin1_spanish)
- tools.eq_(converters.to_bytes(self.u_japanese, encoding='euc_jp'), self.euc_jp_japanese)
+ self.assertEqual(converters.to_bytes(self.u_spanish, encoding='latin1'), self.latin1_spanish)
+ self.assertEqual(converters.to_bytes(self.u_japanese, encoding='euc_jp'), self.euc_jp_japanese)
def test_to_bytes_errors(self):
- tools.eq_(converters.to_bytes(self.u_mixed, encoding='latin1'),
+ self.assertEqual(converters.to_bytes(self.u_mixed, encoding='latin1'),
self.latin1_mixed_replace)
- tools.eq_(converters.to_bytes(self.u_mixed, encoding='latin',
+ self.assertEqual(converters.to_bytes(self.u_mixed, encoding='latin',
errors='ignore'), self.latin1_mixed_ignore)
- tools.assert_raises(UnicodeEncodeError, converters.to_bytes,
+ self.assertRaises(UnicodeEncodeError, converters.to_bytes,
*[self.u_mixed], **{'errors': 'strict', 'encoding': 'latin1'})
def _check_repr_bytes(self, repr_string, obj_name):
- tools.assert_true(isinstance(repr_string, str))
+ self.assertTrue(isinstance(repr_string, str))
match = self.repr_re.match(repr_string)
- tools.assert_not_equal(match, None)
- tools.eq_(match.groups()[0], obj_name)
+ self.assertNotEqual(match, None)
+ self.assertEqual(match.groups()[0], obj_name)
def test_to_bytes_nonstring(self):
- tools.eq_(converters.to_bytes(5), '5')
- tools.eq_(converters.to_bytes(5, nonstring='empty'), '')
- tools.eq_(converters.to_bytes(5, nonstring='passthru'), 5)
- tools.eq_(converters.to_bytes(5, nonstring='simplerepr'), '5')
- tools.eq_(converters.to_bytes(5, nonstring='repr'), '5')
+ self.assertEqual(converters.to_bytes(5), '5')
+ self.assertEqual(converters.to_bytes(5, nonstring='empty'), '')
+ self.assertEqual(converters.to_bytes(5, nonstring='passthru'), 5)
+ self.assertEqual(converters.to_bytes(5, nonstring='simplerepr'), '5')
+ self.assertEqual(converters.to_bytes(5, nonstring='repr'), '5')
# Raise a TypeError if the msg is nonstring and we're set to strict
- tools.assert_raises(TypeError, converters.to_bytes, *[5], **{'nonstring': 'strict'})
+ self.assertRaises(TypeError, converters.to_bytes, *[5], **{'nonstring': 'strict'})
# Raise a TypeError if given an invalid nonstring arg
- tools.assert_raises(TypeError, converters.to_bytes, *[5], **{'nonstring': 'INVALID'})
+ self.assertRaises(TypeError, converters.to_bytes, *[5], **{'nonstring': 'INVALID'})
obj_repr = converters.to_bytes(object, nonstring='simplerepr')
- tools.eq_(obj_repr, "<type 'object'>")
- tools.assert_true(isinstance(obj_repr, str))
+ self.assertEqual(obj_repr, "<type 'object'>")
+ self.assertTrue(isinstance(obj_repr, str))
def test_to_bytes_nonstring_with_objects_that_have__unicode__and__str__(self):
if sys.version_info < (3, 0):
# This object's _str__ returns a utf8 encoded object
- tools.eq_(converters.to_bytes(StrNoUnicode(), nonstring='simplerepr'), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(StrNoUnicode(), nonstring='simplerepr'), self.utf8_spanish)
# No __str__ method so this returns repr
string = converters.to_bytes(UnicodeNoStr(), nonstring='simplerepr')
self._check_repr_bytes(string, 'UnicodeNoStr')
# This object's __str__ returns unicode which to_bytes converts to utf8
- tools.eq_(converters.to_bytes(StrReturnsUnicode(), nonstring='simplerepr'), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(StrReturnsUnicode(), nonstring='simplerepr'), self.utf8_spanish)
# Unless we explicitly ask for something different
- tools.eq_(converters.to_bytes(StrReturnsUnicode(),
+ self.assertEqual(converters.to_bytes(StrReturnsUnicode(),
nonstring='simplerepr', encoding='latin1'), self.latin1_spanish)
# This object has no __str__ so it returns repr
@@ -148,79 +146,79 @@ class TestConverters(unittest.TestCase,
self._check_repr_bytes(string, 'UnicodeReturnsStr')
# This object's __str__ returns unicode which to_bytes converts to utf8
- tools.eq_(converters.to_bytes(UnicodeStrCrossed(), nonstring='simplerepr'), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(UnicodeStrCrossed(), nonstring='simplerepr'), self.utf8_spanish)
# This object's __repr__ returns unicode which to_bytes converts to utf8
- tools.eq_(converters.to_bytes(ReprUnicode(), nonstring='simplerepr'),
+ self.assertEqual(converters.to_bytes(ReprUnicode(), nonstring='simplerepr'),
u'ReprUnicode(El veloz murciélago saltó sobre el perro perezoso.)'.encode('utf8'))
- tools.eq_(converters.to_bytes(ReprUnicode(), nonstring='repr'),
+ self.assertEqual(converters.to_bytes(ReprUnicode(), nonstring='repr'),
u'ReprUnicode(El veloz murciélago saltó sobre el perro perezoso.)'.encode('utf8'))
def test_unicode_to_xml(self):
- tools.eq_(converters.unicode_to_xml(None), '')
- tools.assert_raises(XmlEncodeError, converters.unicode_to_xml, *['byte string'])
- tools.assert_raises(ValueError, converters.unicode_to_xml, *[u'string'], **{'control_chars': 'foo'})
- tools.assert_raises(XmlEncodeError, converters.unicode_to_xml,
+ self.assertEqual(converters.unicode_to_xml(None), '')
+ self.assertRaises(XmlEncodeError, converters.unicode_to_xml, *['byte string'])
+ self.assertRaises(ValueError, converters.unicode_to_xml, *[u'string'], **{'control_chars': 'foo'})
+ self.assertRaises(XmlEncodeError, converters.unicode_to_xml,
*[u'string\u0002'], **{'control_chars': 'strict'})
- tools.eq_(converters.unicode_to_xml(self.u_entity), self.utf8_entity_escape)
- tools.eq_(converters.unicode_to_xml(self.u_entity, attrib=True), self.utf8_attrib_escape)
- tools.eq_(converters.unicode_to_xml(self.u_entity, encoding='ascii'), self.ascii_entity_escape)
- tools.eq_(converters.unicode_to_xml(self.u_entity, encoding='ascii', attrib=True), self.ascii_attrib_escape)
+ self.assertEqual(converters.unicode_to_xml(self.u_entity), self.utf8_entity_escape)
+ self.assertEqual(converters.unicode_to_xml(self.u_entity, attrib=True), self.utf8_attrib_escape)
+ self.assertEqual(converters.unicode_to_xml(self.u_entity, encoding='ascii'), self.ascii_entity_escape)
+ self.assertEqual(converters.unicode_to_xml(self.u_entity, encoding='ascii', attrib=True), self.ascii_attrib_escape)
def test_xml_to_unicode(self):
- tools.eq_(converters.xml_to_unicode(self.utf8_entity_escape, 'utf8', 'replace'), self.u_entity)
- tools.eq_(converters.xml_to_unicode(self.utf8_attrib_escape, 'utf8', 'replace'), self.u_entity)
- tools.eq_(converters.xml_to_unicode(self.ascii_entity_escape, 'ascii', 'replace'), self.u_entity)
- tools.eq_(converters.xml_to_unicode(self.ascii_attrib_escape, 'ascii', 'replace'), self.u_entity)
+ self.assertEqual(converters.xml_to_unicode(self.utf8_entity_escape, 'utf8', 'replace'), self.u_entity)
+ self.assertEqual(converters.xml_to_unicode(self.utf8_attrib_escape, 'utf8', 'replace'), self.u_entity)
+ self.assertEqual(converters.xml_to_unicode(self.ascii_entity_escape, 'ascii', 'replace'), self.u_entity)
+ self.assertEqual(converters.xml_to_unicode(self.ascii_attrib_escape, 'ascii', 'replace'), self.u_entity)
def test_xml_to_byte_string(self):
- tools.eq_(converters.xml_to_byte_string(self.utf8_entity_escape, 'utf8', 'replace'), self.u_entity.encode('utf8'))
- tools.eq_(converters.xml_to_byte_string(self.utf8_attrib_escape, 'utf8', 'replace'), self.u_entity.encode('utf8'))
- tools.eq_(converters.xml_to_byte_string(self.ascii_entity_escape, 'ascii', 'replace'), self.u_entity.encode('utf8'))
- tools.eq_(converters.xml_to_byte_string(self.ascii_attrib_escape, 'ascii', 'replace'), self.u_entity.encode('utf8'))
+ self.assertEqual(converters.xml_to_byte_string(self.utf8_entity_escape, 'utf8', 'replace'), self.u_entity.encode('utf8'))
+ self.assertEqual(converters.xml_to_byte_string(self.utf8_attrib_escape, 'utf8', 'replace'), self.u_entity.encode('utf8'))
+ self.assertEqual(converters.xml_to_byte_string(self.ascii_entity_escape, 'ascii', 'replace'), self.u_entity.encode('utf8'))
+ self.assertEqual(converters.xml_to_byte_string(self.ascii_attrib_escape, 'ascii', 'replace'), self.u_entity.encode('utf8'))
- tools.eq_(converters.xml_to_byte_string(self.utf8_attrib_escape,
+ self.assertEqual(converters.xml_to_byte_string(self.utf8_attrib_escape,
output_encoding='euc_jp', errors='replace'),
self.u_entity.encode('euc_jp', 'replace'))
- tools.eq_(converters.xml_to_byte_string(self.utf8_attrib_escape,
+ self.assertEqual(converters.xml_to_byte_string(self.utf8_attrib_escape,
output_encoding='latin1', errors='replace'),
self.u_entity.encode('latin1', 'replace'))
- tools.eq_(converters.xml_to_byte_string(self.ascii_attrib_escape,
+ self.assertEqual(converters.xml_to_byte_string(self.ascii_attrib_escape,
output_encoding='euc_jp', errors='replace'),
self.u_entity.encode('euc_jp', 'replace'))
- tools.eq_(converters.xml_to_byte_string(self.ascii_attrib_escape,
+ self.assertEqual(converters.xml_to_byte_string(self.ascii_attrib_escape,
output_encoding='latin1', errors='replace'),
self.u_entity.encode('latin1', 'replace'))
def test_byte_string_to_xml(self):
- tools.assert_raises(XmlEncodeError, converters.byte_string_to_xml, *[u'test'])
- tools.eq_(converters.byte_string_to_xml(self.utf8_entity), self.utf8_entity_escape)
- tools.eq_(converters.byte_string_to_xml(self.utf8_entity, attrib=True), self.utf8_attrib_escape)
+ self.assertRaises(XmlEncodeError, converters.byte_string_to_xml, *[u'test'])
+ self.assertEqual(converters.byte_string_to_xml(self.utf8_entity), self.utf8_entity_escape)
+ self.assertEqual(converters.byte_string_to_xml(self.utf8_entity, attrib=True), self.utf8_attrib_escape)
def test_bytes_to_xml(self):
- tools.eq_(converters.bytes_to_xml(self.b_byte_chars), self.b_byte_encoded)
+ self.assertEqual(converters.bytes_to_xml(self.b_byte_chars), self.b_byte_encoded)
def test_xml_to_bytes(self):
- tools.eq_(converters.xml_to_bytes(self.b_byte_encoded), self.b_byte_chars)
+ self.assertEqual(converters.xml_to_bytes(self.b_byte_encoded), self.b_byte_chars)
def test_guess_encoding_to_xml(self):
- tools.eq_(converters.guess_encoding_to_xml(self.u_entity), self.utf8_entity_escape)
- tools.eq_(converters.guess_encoding_to_xml(self.utf8_spanish), self.utf8_spanish)
- tools.eq_(converters.guess_encoding_to_xml(self.latin1_spanish), self.utf8_spanish)
- tools.eq_(converters.guess_encoding_to_xml(self.utf8_japanese), self.utf8_japanese)
+ self.assertEqual(converters.guess_encoding_to_xml(self.u_entity), self.utf8_entity_escape)
+ self.assertEqual(converters.guess_encoding_to_xml(self.utf8_spanish), self.utf8_spanish)
+ self.assertEqual(converters.guess_encoding_to_xml(self.latin1_spanish), self.utf8_spanish)
+ self.assertEqual(converters.guess_encoding_to_xml(self.utf8_japanese), self.utf8_japanese)
def test_guess_encoding_to_xml_euc_japanese(self):
if chardet:
- tools.eq_(converters.guess_encoding_to_xml(self.euc_jp_japanese),
+ self.assertEqual(converters.guess_encoding_to_xml(self.euc_jp_japanese),
self.utf8_japanese)
else:
- raise SkipTest('chardet not installed, euc_japanese won\'t be detected')
+ self.skipTest('chardet not installed, euc_japanese won\'t be detected')
def test_guess_encoding_to_xml_euc_japanese_mangled(self):
if chardet:
- raise SkipTest('chardet installed, euc_japanese won\'t be mangled')
+ self.skipTest('chardet installed, euc_japanese won\'t be mangled')
else:
- tools.eq_(converters.guess_encoding_to_xml(self.euc_jp_japanese),
+ self.assertEqual(converters.guess_encoding_to_xml(self.euc_jp_japanese),
self.utf8_mangled_euc_jp_as_latin1)
class TestGetWriter(unittest.TestCase, base_classes.UnicodeTestData):
@@ -233,27 +231,27 @@ class TestGetWriter(unittest.TestCase, b
io.write(self.u_japanese + u'\n')
io.seek(0)
result = io.read().strip()
- tools.eq_(result, self.utf8_japanese)
+ self.assertEqual(result, self.utf8_japanese)
io.seek(0)
io.truncate(0)
io.write(self.euc_jp_japanese + '\n')
io.seek(0)
result = io.read().strip()
- tools.eq_(result, self.euc_jp_japanese)
+ self.assertEqual(result, self.euc_jp_japanese)
io.seek(0)
io.truncate(0)
io.write(self.utf8_japanese + '\n')
io.seek(0)
result = io.read().strip()
- tools.eq_(result, self.utf8_japanese)
+ self.assertEqual(result, self.utf8_japanese)
def test_error_handlers(self):
'''Test setting alternate error handlers'''
writer = converters.getwriter('latin1')
io = writer(self.io, errors='strict')
- tools.assert_raises(UnicodeEncodeError, io.write, self.u_japanese)
+ self.assertRaises(UnicodeEncodeError, io.write, self.u_japanese)
class TestExceptionConverters(unittest.TestCase, base_classes.UnicodeTestData):
@@ -272,61 +270,61 @@ class TestExceptionConverters(unittest.T
pass
def test_exception_to_unicode_with_unicode(self):
- tools.eq_(converters.exception_to_unicode(self.exceptions['u_jpn']), self.u_japanese)
- tools.eq_(converters.exception_to_unicode(self.exceptions['u_spanish']), self.u_spanish)
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['u_jpn']), self.u_japanese)
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['u_spanish']), self.u_spanish)
def test_exception_to_unicode_with_bytes(self):
- tools.eq_(converters.exception_to_unicode(self.exceptions['utf8_jpn']), self.u_japanese)
- tools.eq_(converters.exception_to_unicode(self.exceptions['utf8_spanish']), self.u_spanish)
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['utf8_jpn']), self.u_japanese)
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['utf8_spanish']), self.u_spanish)
# Mangled latin1/utf8 conversion but no tracebacks
- tools.eq_(converters.exception_to_unicode(self.exceptions['latin1_spanish']), self.u_mangled_spanish_latin1_as_utf8)
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['latin1_spanish']), self.u_mangled_spanish_latin1_as_utf8)
# Mangled euc_jp/utf8 conversion but no tracebacks
- tools.eq_(converters.exception_to_unicode(self.exceptions['euc_jpn']), self.u_mangled_euc_jp_as_utf8)
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['euc_jpn']), self.u_mangled_euc_jp_as_utf8)
def test_exception_to_unicode_custom(self):
# If given custom functions, then we should not mangle
c = [lambda e: converters.to_unicode(e.args[0], encoding='euc_jp'),
lambda e: converters.to_unicode(e, encoding='euc_jp')]
- tools.eq_(converters.exception_to_unicode(self.exceptions['euc_jpn'],
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['euc_jpn'],
converters=c), self.u_japanese)
c.extend(converters.EXCEPTION_CONVERTERS)
- tools.eq_(converters.exception_to_unicode(self.exceptions['euc_jpn'],
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['euc_jpn'],
converters=c), self.u_japanese)
c = [lambda e: converters.to_unicode(e.args[0], encoding='latin1'),
lambda e: converters.to_unicode(e, encoding='latin1')]
- tools.eq_(converters.exception_to_unicode(self.exceptions['latin1_spanish'],
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['latin1_spanish'],
converters=c), self.u_spanish)
c.extend(converters.EXCEPTION_CONVERTERS)
- tools.eq_(converters.exception_to_unicode(self.exceptions['latin1_spanish'],
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['latin1_spanish'],
converters=c), self.u_spanish)
def test_exception_to_bytes_with_unicode(self):
- tools.eq_(converters.exception_to_bytes(self.exceptions['u_jpn']), self.utf8_japanese)
- tools.eq_(converters.exception_to_bytes(self.exceptions['u_spanish']), self.utf8_spanish)
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['u_jpn']), self.utf8_japanese)
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['u_spanish']), self.utf8_spanish)
def test_exception_to_bytes_with_bytes(self):
- tools.eq_(converters.exception_to_bytes(self.exceptions['utf8_jpn']), self.utf8_japanese)
- tools.eq_(converters.exception_to_bytes(self.exceptions['utf8_spanish']), self.utf8_spanish)
- tools.eq_(converters.exception_to_bytes(self.exceptions['latin1_spanish']), self.latin1_spanish)
- tools.eq_(converters.exception_to_bytes(self.exceptions['euc_jpn']), self.euc_jp_japanese)
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['utf8_jpn']), self.utf8_japanese)
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['utf8_spanish']), self.utf8_spanish)
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['latin1_spanish']), self.latin1_spanish)
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['euc_jpn']), self.euc_jp_japanese)
def test_exception_to_bytes_custom(self):
# If given custom functions, then we should not mangle
c = [lambda e: converters.to_bytes(e.args[0], encoding='euc_jp'),
lambda e: converters.to_bytes(e, encoding='euc_jp')]
- tools.eq_(converters.exception_to_bytes(self.exceptions['euc_jpn'],
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['euc_jpn'],
converters=c), self.euc_jp_japanese)
c.extend(converters.EXCEPTION_CONVERTERS)
- tools.eq_(converters.exception_to_bytes(self.exceptions['euc_jpn'],
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['euc_jpn'],
converters=c), self.euc_jp_japanese)
c = [lambda e: converters.to_bytes(e.args[0], encoding='latin1'),
lambda e: converters.to_bytes(e, encoding='latin1')]
- tools.eq_(converters.exception_to_bytes(self.exceptions['latin1_spanish'],
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['latin1_spanish'],
converters=c), self.latin1_spanish)
c.extend(converters.EXCEPTION_CONVERTERS)
- tools.eq_(converters.exception_to_bytes(self.exceptions['latin1_spanish'],
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['latin1_spanish'],
converters=c), self.latin1_spanish)
@@ -338,63 +336,63 @@ class TestDeprecatedConverters(TestConve
warnings.simplefilter('default', DeprecationWarning)
def test_to_xml(self):
- tools.eq_(converters.to_xml(self.u_entity), self.utf8_entity_escape)
- tools.eq_(converters.to_xml(self.utf8_spanish), self.utf8_spanish)
- tools.eq_(converters.to_xml(self.latin1_spanish), self.utf8_spanish)
- tools.eq_(converters.to_xml(self.utf8_japanese), self.utf8_japanese)
+ self.assertEqual(converters.to_xml(self.u_entity), self.utf8_entity_escape)
+ self.assertEqual(converters.to_xml(self.utf8_spanish), self.utf8_spanish)
+ self.assertEqual(converters.to_xml(self.latin1_spanish), self.utf8_spanish)
+ self.assertEqual(converters.to_xml(self.utf8_japanese), self.utf8_japanese)
def test_to_utf8(self):
- tools.eq_(converters.to_utf8(self.u_japanese), self.utf8_japanese)
- tools.eq_(converters.to_utf8(self.utf8_spanish), self.utf8_spanish)
+ self.assertEqual(converters.to_utf8(self.u_japanese), self.utf8_japanese)
+ self.assertEqual(converters.to_utf8(self.utf8_spanish), self.utf8_spanish)
def test_to_str(self):
- tools.eq_(converters.to_str(self.u_japanese), self.utf8_japanese)
- tools.eq_(converters.to_str(self.utf8_spanish), self.utf8_spanish)
- tools.eq_(converters.to_str(object), "<type 'object'>")
+ self.assertEqual(converters.to_str(self.u_japanese), self.utf8_japanese)
+ self.assertEqual(converters.to_str(self.utf8_spanish), self.utf8_spanish)
+ self.assertEqual(converters.to_str(object), "<type 'object'>")
def test_non_string(self):
'''Test deprecated non_string parameter'''
# unicode
- tools.assert_raises(TypeError, converters.to_unicode, *[5], **{'non_string': 'foo'})
- tools.eq_(converters.to_unicode(5, non_string='empty'), u'')
- tools.eq_(converters.to_unicode(5, non_string='passthru'), 5)
- tools.eq_(converters.to_unicode(5, non_string='simplerepr'), u'5')
- tools.eq_(converters.to_unicode(5, non_string='repr'), u'5')
- tools.assert_raises(TypeError, converters.to_unicode, *[5], **{'non_string': 'strict'})
-
- tools.eq_(converters.to_unicode(UnicodeNoStr(), non_string='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(StrNoUnicode(), non_string='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(StrReturnsUnicode(), non_string='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(UnicodeReturnsStr(), non_string='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(UnicodeStrCrossed(), non_string='simplerepr'), self.u_spanish)
+ self.assertRaises(TypeError, converters.to_unicode, *[5], **{'non_string': 'foo'})
+ self.assertEqual(converters.to_unicode(5, non_string='empty'), u'')
+ self.assertEqual(converters.to_unicode(5, non_string='passthru'), 5)
+ self.assertEqual(converters.to_unicode(5, non_string='simplerepr'), u'5')
+ self.assertEqual(converters.to_unicode(5, non_string='repr'), u'5')
+ self.assertRaises(TypeError, converters.to_unicode, *[5], **{'non_string': 'strict'})
+
+ self.assertEqual(converters.to_unicode(UnicodeNoStr(), non_string='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(StrNoUnicode(), non_string='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(StrReturnsUnicode(), non_string='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(UnicodeReturnsStr(), non_string='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(UnicodeStrCrossed(), non_string='simplerepr'), self.u_spanish)
obj_repr = converters.to_unicode(object, non_string='simplerepr')
- tools.eq_(obj_repr, u"<type 'object'>")
- tools.assert_true(isinstance(obj_repr, unicode))
+ self.assertEqual(obj_repr, u"<type 'object'>")
+ self.assertTrue(isinstance(obj_repr, unicode))
# Bytes
- tools.eq_(converters.to_bytes(5), '5')
- tools.eq_(converters.to_bytes(5, non_string='empty'), '')
- tools.eq_(converters.to_bytes(5, non_string='passthru'), 5)
- tools.eq_(converters.to_bytes(5, non_string='simplerepr'), '5')
- tools.eq_(converters.to_bytes(5, non_string='repr'), '5')
+ self.assertEqual(converters.to_bytes(5), '5')
+ self.assertEqual(converters.to_bytes(5, non_string='empty'), '')
+ self.assertEqual(converters.to_bytes(5, non_string='passthru'), 5)
+ self.assertEqual(converters.to_bytes(5, non_string='simplerepr'), '5')
+ self.assertEqual(converters.to_bytes(5, non_string='repr'), '5')
# Raise a TypeError if the msg is non_string and we're set to strict
- tools.assert_raises(TypeError, converters.to_bytes, *[5], **{'non_string': 'strict'})
+ self.assertRaises(TypeError, converters.to_bytes, *[5], **{'non_string': 'strict'})
# Raise a TypeError if given an invalid non_string arg
- tools.assert_raises(TypeError, converters.to_bytes, *[5], **{'non_string': 'INVALID'})
+ self.assertRaises(TypeError, converters.to_bytes, *[5], **{'non_string': 'INVALID'})
# No __str__ method so this returns repr
string = converters.to_bytes(UnicodeNoStr(), non_string='simplerepr')
self._check_repr_bytes(string, 'UnicodeNoStr')
# This object's _str__ returns a utf8 encoded object
- tools.eq_(converters.to_bytes(StrNoUnicode(), non_string='simplerepr'), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(StrNoUnicode(), non_string='simplerepr'), self.utf8_spanish)
# This object's __str__ returns unicode which to_bytes converts to utf8
- tools.eq_(converters.to_bytes(StrReturnsUnicode(), non_string='simplerepr'), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(StrReturnsUnicode(), non_string='simplerepr'), self.utf8_spanish)
# Unless we explicitly ask for something different
- tools.eq_(converters.to_bytes(StrReturnsUnicode(),
+ self.assertEqual(converters.to_bytes(StrReturnsUnicode(),
non_string='simplerepr', encoding='latin1'), self.latin1_spanish)
# This object has no __str__ so it returns repr
@@ -402,14 +400,14 @@ class TestDeprecatedConverters(TestConve
self._check_repr_bytes(string, 'UnicodeReturnsStr')
# This object's __str__ returns unicode which to_bytes converts to utf8
- tools.eq_(converters.to_bytes(UnicodeStrCrossed(), non_string='simplerepr'), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(UnicodeStrCrossed(), non_string='simplerepr'), self.utf8_spanish)
# This object's __repr__ returns unicode which to_bytes converts to utf8
- tools.eq_(converters.to_bytes(ReprUnicode(), non_string='simplerepr'),
+ self.assertEqual(converters.to_bytes(ReprUnicode(), non_string='simplerepr'),
u'ReprUnicode(El veloz murciélago saltó sobre el perro perezoso.)'.encode('utf8'))
- tools.eq_(converters.to_bytes(ReprUnicode(), non_string='repr'),
+ self.assertEqual(converters.to_bytes(ReprUnicode(), non_string='repr'),
u'ReprUnicode(El veloz murciélago saltó sobre el perro perezoso.)'.encode('utf8'))
obj_repr = converters.to_bytes(object, non_string='simplerepr')
- tools.eq_(obj_repr, "<type 'object'>")
- tools.assert_true(isinstance(obj_repr, str))
+ self.assertEqual(obj_repr, "<type 'object'>")
+ self.assertTrue(isinstance(obj_repr, str))
Index: kitchen-1.2.6/kitchen2/tests/test_deprecation.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test_deprecation.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test_deprecation.py 2020-09-09 14:50:23.910571749 +0200
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
import sys
import warnings
@@ -21,27 +20,27 @@ class TestDeprecated(unittest.TestCase):
def test_deprecated_functions(self):
'''Test that all deprecated functions raise DeprecationWarning'''
- tools.assert_raises(DeprecationWarning, converters.to_utf8, u'café')
- tools.assert_raises(DeprecationWarning, converters.to_str, 5)
- tools.assert_raises(DeprecationWarning, converters.to_xml, 'test')
-
- tools.assert_raises(DeprecationWarning, utf8.utf8_valid, 'test')
- tools.assert_raises(DeprecationWarning, utf8.utf8_width, 'test')
- tools.assert_raises(DeprecationWarning, utf8.utf8_width_chop, 'test')
- tools.assert_raises(DeprecationWarning, utf8.utf8_width_fill, 'test', 'asd')
- tools.assert_raises(DeprecationWarning, utf8.utf8_text_wrap, 'test')
- tools.assert_raises(DeprecationWarning, utf8.utf8_text_fill, 'test')
- tools.assert_raises(DeprecationWarning, utf8._utf8_width_le, 'test')
+ self.assertRaises(DeprecationWarning, converters.to_utf8, u'café')
+ self.assertRaises(DeprecationWarning, converters.to_str, 5)
+ self.assertRaises(DeprecationWarning, converters.to_xml, 'test')
+
+ self.assertRaises(DeprecationWarning, utf8.utf8_valid, 'test')
+ self.assertRaises(DeprecationWarning, utf8.utf8_width, 'test')
+ self.assertRaises(DeprecationWarning, utf8.utf8_width_chop, 'test')
+ self.assertRaises(DeprecationWarning, utf8.utf8_width_fill, 'test', 'asd')
+ self.assertRaises(DeprecationWarning, utf8.utf8_text_wrap, 'test')
+ self.assertRaises(DeprecationWarning, utf8.utf8_text_fill, 'test')
+ self.assertRaises(DeprecationWarning, utf8._utf8_width_le, 'test')
def test_deprecated_parameters(self):
- tools.assert_raises(DeprecationWarning, converters.to_unicode, *[5],
+ self.assertRaises(DeprecationWarning, converters.to_unicode, *[5],
**{'non_string': 'simplerepr'})
- tools.assert_raises(DeprecationWarning, converters.to_unicode, *[5],
+ self.assertRaises(DeprecationWarning, converters.to_unicode, *[5],
**{'nonstring': 'simplerepr', 'non_string': 'simplerepr'})
- tools.assert_raises(DeprecationWarning, converters.to_bytes, *[5],
+ self.assertRaises(DeprecationWarning, converters.to_bytes, *[5],
**{'non_string': 'simplerepr'})
- tools.assert_raises(DeprecationWarning, converters.to_bytes, *[5],
+ self.assertRaises(DeprecationWarning, converters.to_bytes, *[5],
**{'nonstring': 'simplerepr', 'non_string': 'simplerepr'})
@@ -57,7 +56,7 @@ class TestPendingDeprecationParameters(u
def test_parameters(self):
# test that we warn when using the python2_api parameters
- tools.assert_raises(PendingDeprecationWarning,
+ self.assertRaises(PendingDeprecationWarning,
i18n.get_translation_object, 'test', **{'python2_api': True})
- tools.assert_raises(PendingDeprecationWarning,
+ self.assertRaises(PendingDeprecationWarning,
i18n.DummyTranslations, **{'python2_api': True})
Index: kitchen-1.2.6/kitchen2/tests/test_i18n.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test_i18n.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test_i18n.py 2020-09-09 14:50:23.910571749 +0200
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
import os
import types
@@ -31,17 +30,17 @@ class TestI18N_UTF8(unittest.TestCase, b
'''
_, N_ = i18n.easy_gettext_setup('foo', localedirs=
['%s/data/locale/' % os.path.dirname(__file__)])
- tools.assert_true(isinstance(_, types.MethodType))
- tools.assert_true(isinstance(N_, types.MethodType))
- tools.eq_(_.__name__, '_ugettext')
- tools.eq_(N_.__name__, '_ungettext')
-
- tools.eq_(_(self.utf8_spanish), self.u_spanish)
- tools.eq_(_(self.u_spanish), self.u_spanish)
- tools.eq_(N_(self.utf8_limao, self.utf8_limoes, 1), self.u_limao)
- tools.eq_(N_(self.utf8_limao, self.utf8_limoes, 2), self.u_limoes)
- tools.eq_(N_(self.u_limao, self.u_limoes, 1), self.u_limao)
- tools.eq_(N_(self.u_limao, self.u_limoes, 2), self.u_limoes)
+ self.assertTrue(isinstance(_, types.MethodType))
+ self.assertTrue(isinstance(N_, types.MethodType))
+ self.assertEqual(_.__name__, '_ugettext')
+ self.assertEqual(N_.__name__, '_ungettext')
+
+ self.assertEqual(_(self.utf8_spanish), self.u_spanish)
+ self.assertEqual(_(self.u_spanish), self.u_spanish)
+ self.assertEqual(N_(self.utf8_limao, self.utf8_limoes, 1), self.u_limao)
+ self.assertEqual(N_(self.utf8_limao, self.utf8_limoes, 2), self.u_limoes)
+ self.assertEqual(N_(self.u_limao, self.u_limoes, 1), self.u_limao)
+ self.assertEqual(N_(self.u_limao, self.u_limoes, 2), self.u_limoes)
def test_easy_gettext_setup_non_unicode(self):
'''Test that the easy_gettext_setup function works
@@ -49,35 +48,35 @@ class TestI18N_UTF8(unittest.TestCase, b
b_, bN_ = i18n.easy_gettext_setup('foo', localedirs=
['%s/data/locale/' % os.path.dirname(__file__)],
use_unicode=False)
- tools.assert_true(isinstance(b_, types.MethodType))
- tools.assert_true(isinstance(bN_, types.MethodType))
- tools.eq_(b_.__name__, '_lgettext')
- tools.eq_(bN_.__name__, '_lngettext')
-
- tools.eq_(b_(self.utf8_spanish), self.utf8_spanish)
- tools.eq_(b_(self.u_spanish), self.utf8_spanish)
- tools.eq_(bN_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_limao)
- tools.eq_(bN_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_limoes)
- tools.eq_(bN_(self.u_limao, self.u_limoes, 1), self.utf8_limao)
- tools.eq_(bN_(self.u_limao, self.u_limoes, 2), self.utf8_limoes)
+ self.assertTrue(isinstance(b_, types.MethodType))
+ self.assertTrue(isinstance(bN_, types.MethodType))
+ self.assertEqual(b_.__name__, '_lgettext')
+ self.assertEqual(bN_.__name__, '_lngettext')
+
+ self.assertEqual(b_(self.utf8_spanish), self.utf8_spanish)
+ self.assertEqual(b_(self.u_spanish), self.utf8_spanish)
+ self.assertEqual(bN_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_limao)
+ self.assertEqual(bN_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_limoes)
+ self.assertEqual(bN_(self.u_limao, self.u_limoes, 1), self.utf8_limao)
+ self.assertEqual(bN_(self.u_limao, self.u_limoes, 2), self.utf8_limoes)
def test_get_translation_object(self):
'''Test that the get_translation_object function works
'''
translations = i18n.get_translation_object('foo', ['%s/data/locale/' % os.path.dirname(__file__)])
- tools.eq_(translations.__class__, i18n.DummyTranslations)
- tools.assert_raises(IOError, i18n.get_translation_object, 'foo', ['%s/data/locale/' % os.path.dirname(__file__)], fallback=False)
+ self.assertEqual(translations.__class__, i18n.DummyTranslations)
+ self.assertRaises(IOError, i18n.get_translation_object, 'foo', ['%s/data/locale/' % os.path.dirname(__file__)], fallback=False)
translations = i18n.get_translation_object('test', ['%s/data/locale/' % os.path.dirname(__file__)])
- tools.eq_(translations.__class__, i18n.NewGNUTranslations)
+ self.assertEqual(translations.__class__, i18n.NewGNUTranslations)
def test_get_translation_object_create_fallback(self):
'''Test get_translation_object creates fallbacks for additional catalogs'''
translations = i18n.get_translation_object('test',
['%s/data/locale' % os.path.dirname(__file__),
'%s/data/locale-old' % os.path.dirname(__file__)])
- tools.eq_(translations.__class__, i18n.NewGNUTranslations)
- tools.eq_(translations._fallback.__class__, i18n.NewGNUTranslations)
+ self.assertEqual(translations.__class__, i18n.NewGNUTranslations)
+ self.assertEqual(translations._fallback.__class__, i18n.NewGNUTranslations)
def test_get_translation_object_copy(self):
'''Test get_translation_object shallow copies the message catalog'''
@@ -93,16 +92,16 @@ class TestI18N_UTF8(unittest.TestCase, b
# Test that portions of the translation objects are the same and other
# portions are different (which is a space optimization so that the
# translation data isn't in memory multiple times)
- tools.assert_not_equal(id(translations._fallback), id(translations2._fallback))
- tools.assert_not_equal(id(translations.output_charset()), id(translations2.output_charset()))
- tools.assert_not_equal(id(translations.input_charset), id(translations2.input_charset))
- tools.assert_not_equal(id(translations.input_charset), id(translations2.input_charset))
- tools.eq_(id(translations._catalog), id(translations2._catalog))
+ self.assertNotEqual(id(translations._fallback), id(translations2._fallback))
+ self.assertNotEqual(id(translations.output_charset()), id(translations2.output_charset()))
+ self.assertNotEqual(id(translations.input_charset), id(translations2.input_charset))
+ self.assertNotEqual(id(translations.input_charset), id(translations2.input_charset))
+ self.assertEqual(id(translations._catalog), id(translations2._catalog))
def test_get_translation_object_optional_params(self):
'''Smoketest leaving out optional parameters'''
translations = i18n.get_translation_object('test')
- tools.assert_true(translations.__class__ in (i18n.NewGNUTranslations, i18n.DummyTranslations))
+ self.assertTrue(translations.__class__ in (i18n.NewGNUTranslations, i18n.DummyTranslations))
def test_get_translation_object_python2_api_default(self):
'''Smoketest that python2_api default value yields the python2 functions'''
@@ -111,12 +110,12 @@ class TestI18N_UTF8(unittest.TestCase, b
['%s/data/locale' % os.path.dirname(__file__),
'%s/data/locale-old' % os.path.dirname(__file__)], codeset='utf-8')
translations.input_charset = 'utf-8'
- tools.eq_(translations.gettext.__name__, '_gettext')
- tools.eq_(translations.lgettext.__name__, '_lgettext')
- tools.eq_(translations.ugettext.__name__, '_ugettext')
- tools.eq_(translations.ngettext.__name__, '_ngettext')
- tools.eq_(translations.lngettext.__name__, '_lngettext')
- tools.eq_(translations.ungettext.__name__, '_ungettext')
+ self.assertEqual(translations.gettext.__name__, '_gettext')
+ self.assertEqual(translations.lgettext.__name__, '_lgettext')
+ self.assertEqual(translations.ugettext.__name__, '_ugettext')
+ self.assertEqual(translations.ngettext.__name__, '_ngettext')
+ self.assertEqual(translations.lngettext.__name__, '_lngettext')
+ self.assertEqual(translations.ungettext.__name__, '_ungettext')
def test_get_translation_object_python2_api_true(self):
'''Smoketest that setting python2_api true yields the python2 functions'''
@@ -126,12 +125,12 @@ class TestI18N_UTF8(unittest.TestCase, b
'%s/data/locale-old' % os.path.dirname(__file__)], codeset='utf-8',
python2_api=True)
translations.input_charset = 'utf-8'
- tools.eq_(translations.gettext.__name__, '_gettext')
- tools.eq_(translations.lgettext.__name__, '_lgettext')
- tools.eq_(translations.ugettext.__name__, '_ugettext')
- tools.eq_(translations.ngettext.__name__, '_ngettext')
- tools.eq_(translations.lngettext.__name__, '_lngettext')
- tools.eq_(translations.ungettext.__name__, '_ungettext')
+ self.assertEqual(translations.gettext.__name__, '_gettext')
+ self.assertEqual(translations.lgettext.__name__, '_lgettext')
+ self.assertEqual(translations.ugettext.__name__, '_ugettext')
+ self.assertEqual(translations.ngettext.__name__, '_ngettext')
+ self.assertEqual(translations.lngettext.__name__, '_lngettext')
+ self.assertEqual(translations.ungettext.__name__, '_ungettext')
def test_get_translation_object_python2_api_false(self):
'''Smoketest that setting python2_api false yields the python3 functions'''
@@ -141,23 +140,23 @@ class TestI18N_UTF8(unittest.TestCase, b
'%s/data/locale-old' % os.path.dirname(__file__)], codeset='utf-8',
python2_api=False)
translations.input_charset = 'utf-8'
- tools.eq_(translations.gettext.__name__, '_ugettext')
- tools.eq_(translations.lgettext.__name__, '_lgettext')
- tools.eq_(translations.ngettext.__name__, '_ungettext')
- tools.eq_(translations.lngettext.__name__, '_lngettext')
+ self.assertEqual(translations.gettext.__name__, '_ugettext')
+ self.assertEqual(translations.lgettext.__name__, '_lgettext')
+ self.assertEqual(translations.ngettext.__name__, '_ungettext')
+ self.assertEqual(translations.lngettext.__name__, '_lngettext')
- tools.assert_raises(AttributeError, translations.ugettext, 'message')
- tools.assert_raises(AttributeError, translations.ungettext, 'message1', 'message2')
+ self.assertRaises(AttributeError, translations.ugettext, 'message')
+ self.assertRaises(AttributeError, translations.ungettext, 'message1', 'message2')
def test_dummy_translation(self):
'''Test that we can create a DummyTranslation object
'''
- tools.assert_true(isinstance(i18n.DummyTranslations(), i18n.DummyTranslations))
+ self.assertTrue(isinstance(i18n.DummyTranslations(), i18n.DummyTranslations))
# Note: Using nose's generator tests for this so we can't subclass
# unittest.TestCase
-class TestDummyTranslations(base_classes.UnicodeTestData):
- def __init__(self):
+class TestDummyTranslations(unittest.TestCase, base_classes.UnicodeTestData):
+ def setUp(self):
self.test_data = {'bytes': (( # First set is with default charset (utf8)
(self.u_ascii, self.b_ascii),
(self.u_spanish, self.utf8_spanish),
@@ -214,14 +213,12 @@ class TestDummyTranslations(base_classes
(self.utf8_japanese, self.u_mangled_japanese_utf8_as_ascii), # String mangled but no exception
),
)
- }
-
- def setUp(self):
+ }
self.translations = i18n.DummyTranslations()
def check_gettext(self, message, value, charset=None):
self.translations.set_output_charset(charset)
- tools.eq_(self.translations.gettext(message), value,
+ self.assertEqual(self.translations.gettext(message), value,
msg='gettext(%s): trans: %s != val: %s (charset=%s)'
% (repr(message), repr(self.translations.gettext(message)),
repr(value), charset))
@@ -230,7 +227,7 @@ class TestDummyTranslations(base_classes
locale='en_US.UTF-8'):
os.environ['LC_ALL'] = locale
self.translations.set_output_charset(charset)
- tools.eq_(self.translations.lgettext(message), value,
+ self.assertEqual(self.translations.lgettext(message), value,
msg='lgettext(%s): trans: %s != val: %s (charset=%s, locale=%s)'
% (repr(message), repr(self.translations.lgettext(message)),
repr(value), charset, locale))
@@ -240,34 +237,34 @@ class TestDummyTranslations(base_classes
def check_ugettext(self, message, value, charset='utf-8'):
'''ugettext method with default values'''
self.translations.input_charset = charset
- tools.eq_(self.translations.ugettext(message), value,
+ self.assertEqual(self.translations.ugettext(message), value,
msg='ugettext(%s): trans: %s != val: %s (charset=%s)'
% (repr(message), repr(self.translations.ugettext(message)),
repr(value), charset))
def check_ngettext(self, message, value, charset=None):
self.translations.set_output_charset(charset)
- tools.eq_(self.translations.ngettext(message, 'blank', 1), value)
- tools.eq_(self.translations.ngettext('blank', message, 2), value)
- tools.assert_not_equal(self.translations.ngettext(message, 'blank', 2), value)
- tools.assert_not_equal(self.translations.ngettext('blank', message, 1), value)
+ self.assertEqual(self.translations.ngettext(message, 'blank', 1), value)
+ self.assertEqual(self.translations.ngettext('blank', message, 2), value)
+ self.assertNotEqual(self.translations.ngettext(message, 'blank', 2), value)
+ self.assertNotEqual(self.translations.ngettext('blank', message, 1), value)
def check_lngettext(self, message, value, charset=None, locale='en_US.UTF-8'):
os.environ['LC_ALL'] = locale
self.translations.set_output_charset(charset)
- tools.eq_(self.translations.lngettext(message, 'blank', 1), value,
+ self.assertEqual(self.translations.lngettext(message, 'blank', 1), value,
msg='lngettext(%s, "blank", 1): trans: %s != val: %s (charset=%s, locale=%s)'
% (repr(message), repr(self.translations.lngettext(message,
'blank', 1)), repr(value), charset, locale))
- tools.eq_(self.translations.lngettext('blank', message, 2), value,
+ self.assertEqual(self.translations.lngettext('blank', message, 2), value,
msg='lngettext("blank", %s, 2): trans: %s != val: %s (charset=%s, locale=%s)'
% (repr(message), repr(self.translations.lngettext('blank',
message, 2)), repr(value), charset, locale))
- tools.assert_not_equal(self.translations.lngettext(message, 'blank', 2), value,
+ self.assertNotEqual(self.translations.lngettext(message, 'blank', 2), value,
msg='lngettext(%s, "blank", 2): trans: %s, val: %s (charset=%s, locale=%s)'
% (repr(message), repr(self.translations.lngettext(message,
'blank', 2)), repr(value), charset, locale))
- tools.assert_not_equal(self.translations.lngettext('blank', message, 1), value,
+ self.assertNotEqual(self.translations.lngettext('blank', message, 1), value,
msg='lngettext("blank", %s, 1): trans: %s != val: %s (charset=%s, locale=%s)'
% (repr(message), repr(self.translations.lngettext('blank',
message, 1)), repr(value), charset, locale))
@@ -276,10 +273,10 @@ class TestDummyTranslations(base_classes
# tearDown each time check_* is run.
def check_ungettext(self, message, value, charset='utf-8'):
self.translations.input_charset = charset
- tools.eq_(self.translations.ungettext(message, 'blank', 1), value)
- tools.eq_(self.translations.ungettext('blank', message, 2), value)
- tools.assert_not_equal(self.translations.ungettext(message, 'blank', 2), value)
- tools.assert_not_equal(self.translations.ungettext('blank', message, 1), value)
+ self.assertEqual(self.translations.ungettext(message, 'blank', 1), value)
+ self.assertEqual(self.translations.ungettext('blank', message, 2), value)
+ self.assertNotEqual(self.translations.ungettext(message, 'blank', 2), value)
+ self.assertNotEqual(self.translations.ungettext('blank', message, 1), value)
def test_gettext(self):
'''gettext method with default values'''
@@ -370,12 +367,12 @@ class TestDummyTranslations(base_classes
yield self.check_ungettext, message, value, 'ascii'
def test_nonbasestring(self):
- tools.eq_(self.translations.gettext(dict(hi='there')), self.b_empty_string)
- tools.eq_(self.translations.ngettext(dict(hi='there'), dict(hi='two'), 1), self.b_empty_string)
- tools.eq_(self.translations.lgettext(dict(hi='there')), self.b_empty_string)
- tools.eq_(self.translations.lngettext(dict(hi='there'), dict(hi='two'), 1), self.b_empty_string)
- tools.eq_(self.translations.ugettext(dict(hi='there')), self.u_empty_string)
- tools.eq_(self.translations.ungettext(dict(hi='there'), dict(hi='two'), 1), self.u_empty_string)
+ self.assertEqual(self.translations.gettext(dict(hi='there')), self.b_empty_string)
+ self.assertEqual(self.translations.ngettext(dict(hi='there'), dict(hi='two'), 1), self.b_empty_string)
+ self.assertEqual(self.translations.lgettext(dict(hi='there')), self.b_empty_string)
+ self.assertEqual(self.translations.lngettext(dict(hi='there'), dict(hi='two'), 1), self.b_empty_string)
+ self.assertEqual(self.translations.ugettext(dict(hi='there')), self.u_empty_string)
+ self.assertEqual(self.translations.ungettext(dict(hi='there'), dict(hi='two'), 1), self.u_empty_string)
class TestI18N_Latin1(unittest.TestCase, base_classes.UnicodeTestData):
@@ -401,12 +398,12 @@ class TestI18N_Latin1(unittest.TestCase,
['%s/data/locale/' % os.path.dirname(__file__)],
use_unicode=False)
- tools.eq_(b_(self.utf8_spanish), self.utf8_spanish)
- tools.eq_(b_(self.u_spanish), self.latin1_spanish)
- tools.eq_(bN_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_limao)
- tools.eq_(bN_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_limoes)
- tools.eq_(bN_(self.u_limao, self.u_limoes, 1), self.latin1_limao)
- tools.eq_(bN_(self.u_limao, self.u_limoes, 2), self.latin1_limoes)
+ self.assertEqual(b_(self.utf8_spanish), self.utf8_spanish)
+ self.assertEqual(b_(self.u_spanish), self.latin1_spanish)
+ self.assertEqual(bN_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_limao)
+ self.assertEqual(bN_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_limoes)
+ self.assertEqual(bN_(self.u_limao, self.u_limoes, 1), self.latin1_limao)
+ self.assertEqual(bN_(self.u_limao, self.u_limoes, 2), self.latin1_limoes)
class TestNewGNUTranslationsNoMatch(TestDummyTranslations):
@@ -448,104 +445,104 @@ class TestNewGNURealTranslations_UTF8(un
def test_gettext(self):
_ = self.translations.gettext
- tools.eq_(_(self.utf8_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.utf8_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
# This is not translated to utf8_yes_in_fallback because this test is
# without the fallback message catalog
- tools.eq_(_(self.utf8_in_fallback), self.utf8_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.u_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.utf8_ja_kuratomi)
# This is not translated to utf8_yes_in_fallback because this test is
# without the fallback message catalog
- tools.eq_(_(self.u_in_fallback), self.utf8_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
def test_ngettext(self):
_ = self.translations.ngettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
def test_lgettext(self):
_ = self.translations.lgettext
- tools.eq_(_(self.utf8_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.utf8_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
# This is not translated to utf8_yes_in_fallback because this test is
# without the fallback message catalog
- tools.eq_(_(self.utf8_in_fallback), self.utf8_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.u_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.utf8_ja_kuratomi)
# This is not translated to utf8_yes_in_fallback because this test is
# without the fallback message catalog
- tools.eq_(_(self.u_in_fallback), self.utf8_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
def test_lngettext(self):
_ = self.translations.lngettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
def test_ugettext(self):
_ = self.translations.ugettext
- tools.eq_(_(self.utf8_kitchen), self.u_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.u_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.u_ja_kuratomi)
+ self.assertEqual(_(self.utf8_kitchen), self.u_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.u_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.u_ja_kuratomi)
# This is not translated to utf8_yes_in_fallback because this test is
# without the fallback message catalog
- tools.eq_(_(self.utf8_in_fallback), self.u_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.u_not_in_catalog)
+ self.assertEqual(_(self.utf8_in_fallback), self.u_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.u_not_in_catalog)
- tools.eq_(_(self.u_kitchen), self.u_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.u_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.u_ja_kuratomi)
+ self.assertEqual(_(self.u_kitchen), self.u_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.u_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.u_ja_kuratomi)
# This is not translated to utf8_yes_in_fallback because this test is
# without the fallback message catalog
- tools.eq_(_(self.u_in_fallback), self.u_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.u_not_in_catalog)
+ self.assertEqual(_(self.u_in_fallback), self.u_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.u_not_in_catalog)
def test_ungettext(self):
_ = self.translations.ungettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.u_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.u_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.u_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.u_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.u_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.u_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.u_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.u_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.u_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.u_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.u_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.u_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.u_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.u_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.u_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.u_lemons)
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
class TestNewGNURealTranslations_Latin1(TestNewGNURealTranslations_UTF8):
@@ -568,43 +565,43 @@ class TestNewGNURealTranslations_Latin1(
def test_lgettext(self):
_ = self.translations.lgettext
- tools.eq_(_(self.utf8_kitchen), self.latin1_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.latin1_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.latin1_ja_kuratomi)
+ self.assertEqual(_(self.utf8_kitchen), self.latin1_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.latin1_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.latin1_ja_kuratomi)
# Neither of the following two tests encode to proper latin-1 because:
# any byte is valid in latin-1 so there's no way to know that what
# we're given in the string is really utf-8
#
# This is not translated to latin1_yes_in_fallback because this test
# is without the fallback message catalog
- tools.eq_(_(self.utf8_in_fallback), self.utf8_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_kitchen), self.latin1_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.latin1_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.latin1_ja_kuratomi)
+ self.assertEqual(_(self.u_kitchen), self.latin1_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.latin1_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.latin1_ja_kuratomi)
# This is not translated to latin1_yes_in_fallback because this test
# is without the fallback message catalog
- tools.eq_(_(self.u_in_fallback), self.latin1_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.latin1_not_in_catalog)
+ self.assertEqual(_(self.u_in_fallback), self.latin1_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.latin1_not_in_catalog)
def test_lngettext(self):
_ = self.translations.lngettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.latin1_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.latin1_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.latin1_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.latin1_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.latin1_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.latin1_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.latin1_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.latin1_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.latin1_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.latin1_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.latin1_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.latin1_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.latin1_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.latin1_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.latin1_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.latin1_lemons)
# This unfortunately does not encode to proper latin-1 because:
# any byte is valid in latin-1 so there's no way to know that what
# we're given in the string is really utf-8
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.latin1_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.latin1_not_in_catalog)
class TestFallbackNewGNUTranslationsNoMatch(TestDummyTranslations):
@@ -650,90 +647,90 @@ class TestFallbackNewGNURealTranslations
def test_gettext(self):
_ = self.translations.gettext
- tools.eq_(_(self.utf8_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
- tools.eq_(_(self.utf8_in_fallback), self.utf8_yes_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
-
- tools.eq_(_(self.u_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.utf8_ja_kuratomi)
- tools.eq_(_(self.u_in_fallback), self.utf8_yes_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.utf8_in_fallback), self.utf8_yes_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
+
+ self.assertEqual(_(self.u_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.u_in_fallback), self.utf8_yes_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
def test_ngettext(self):
_ = self.translations.ngettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
def test_lgettext(self):
_ = self.translations.lgettext
- tools.eq_(_(self.utf8_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
- tools.eq_(_(self.utf8_in_fallback), self.utf8_yes_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
-
- tools.eq_(_(self.u_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.utf8_ja_kuratomi)
- tools.eq_(_(self.u_in_fallback), self.utf8_yes_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.utf8_in_fallback), self.utf8_yes_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
+
+ self.assertEqual(_(self.u_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.u_in_fallback), self.utf8_yes_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
def test_lngettext(self):
_ = self.translations.lngettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
def test_ugettext(self):
_ = self.translations.ugettext
- tools.eq_(_(self.utf8_kitchen), self.u_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.u_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.u_ja_kuratomi)
- tools.eq_(_(self.utf8_in_fallback), self.u_yes_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.u_not_in_catalog)
-
- tools.eq_(_(self.u_kitchen), self.u_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.u_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.u_ja_kuratomi)
- tools.eq_(_(self.u_in_fallback), self.u_yes_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.u_not_in_catalog)
+ self.assertEqual(_(self.utf8_kitchen), self.u_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.u_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.u_ja_kuratomi)
+ self.assertEqual(_(self.utf8_in_fallback), self.u_yes_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.u_not_in_catalog)
+
+ self.assertEqual(_(self.u_kitchen), self.u_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.u_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.u_ja_kuratomi)
+ self.assertEqual(_(self.u_in_fallback), self.u_yes_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.u_not_in_catalog)
def test_ungettext(self):
_ = self.translations.ungettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.u_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.u_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.u_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.u_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.u_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.u_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.u_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.u_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.u_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.u_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.u_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.u_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.u_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.u_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.u_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.u_lemons)
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
class TestFallbackNewGNURealTranslations_Latin1(TestFallbackNewGNURealTranslations_UTF8):
@@ -758,38 +755,38 @@ class TestFallbackNewGNURealTranslations
def test_lgettext(self):
_ = self.translations.lgettext
- tools.eq_(_(self.utf8_kitchen), self.latin1_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.latin1_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.latin1_ja_kuratomi)
- tools.eq_(_(self.utf8_in_fallback), self.latin1_yes_in_fallback)
+ self.assertEqual(_(self.utf8_kitchen), self.latin1_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.latin1_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.latin1_ja_kuratomi)
+ self.assertEqual(_(self.utf8_in_fallback), self.latin1_yes_in_fallback)
# This unfortunately does not encode to proper latin-1 because:
# any byte is valid in latin-1 so there's no way to know that what
# we're given in the string is really utf-8
- tools.eq_(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_kitchen), self.latin1_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.latin1_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.latin1_ja_kuratomi)
- tools.eq_(_(self.u_in_fallback), self.latin1_yes_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.latin1_not_in_catalog)
+ self.assertEqual(_(self.u_kitchen), self.latin1_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.latin1_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.latin1_ja_kuratomi)
+ self.assertEqual(_(self.u_in_fallback), self.latin1_yes_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.latin1_not_in_catalog)
def test_lngettext(self):
_ = self.translations.lngettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.latin1_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.latin1_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.latin1_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.latin1_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.latin1_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.latin1_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.latin1_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.latin1_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.latin1_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.latin1_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.latin1_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.latin1_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.latin1_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.latin1_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.latin1_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.latin1_lemons)
# This unfortunately does not encode to proper latin-1 because:
# any byte is valid in latin-1 so there's no way to know that what
# we're given in the string is really utf-8
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.latin1_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.latin1_not_in_catalog)
class TestFallback(unittest.TestCase, base_classes.UnicodeTestData):
@@ -820,21 +817,21 @@ class TestFallback(unittest.TestCase, ba
def test_invalid_fallback_no_raise(self):
'''Test when we have an invalid fallback that it does not raise.'''
- tools.eq_(self.gtranslations.gettext(self.u_spanish), self.utf8_spanish)
- tools.eq_(self.gtranslations.ugettext(self.u_spanish), self.u_spanish)
- tools.eq_(self.gtranslations.lgettext(self.u_spanish), self.latin1_spanish)
-
- tools.eq_(self.gtranslations.ngettext(self.u_spanish, 'cde', 1), self.utf8_spanish)
- tools.eq_(self.gtranslations.ungettext(self.u_spanish, 'cde', 1), self.u_spanish)
- tools.eq_(self.gtranslations.lngettext(self.u_spanish, 'cde', 1), self.latin1_spanish)
-
- tools.eq_(self.dtranslations.gettext(self.u_spanish), self.utf8_spanish)
- tools.eq_(self.dtranslations.ugettext(self.u_spanish), self.u_spanish)
- tools.eq_(self.dtranslations.lgettext(self.u_spanish), self.latin1_spanish)
-
- tools.eq_(self.dtranslations.ngettext(self.u_spanish, 'cde', 1), self.utf8_spanish)
- tools.eq_(self.dtranslations.ungettext(self.u_spanish, 'cde', 1), self.u_spanish)
- tools.eq_(self.dtranslations.lngettext(self.u_spanish, 'cde', 1), self.latin1_spanish)
+ self.assertEqual(self.gtranslations.gettext(self.u_spanish), self.utf8_spanish)
+ self.assertEqual(self.gtranslations.ugettext(self.u_spanish), self.u_spanish)
+ self.assertEqual(self.gtranslations.lgettext(self.u_spanish), self.latin1_spanish)
+
+ self.assertEqual(self.gtranslations.ngettext(self.u_spanish, 'cde', 1), self.utf8_spanish)
+ self.assertEqual(self.gtranslations.ungettext(self.u_spanish, 'cde', 1), self.u_spanish)
+ self.assertEqual(self.gtranslations.lngettext(self.u_spanish, 'cde', 1), self.latin1_spanish)
+
+ self.assertEqual(self.dtranslations.gettext(self.u_spanish), self.utf8_spanish)
+ self.assertEqual(self.dtranslations.ugettext(self.u_spanish), self.u_spanish)
+ self.assertEqual(self.dtranslations.lgettext(self.u_spanish), self.latin1_spanish)
+
+ self.assertEqual(self.dtranslations.ngettext(self.u_spanish, 'cde', 1), self.utf8_spanish)
+ self.assertEqual(self.dtranslations.ungettext(self.u_spanish, 'cde', 1), self.u_spanish)
+ self.assertEqual(self.dtranslations.lngettext(self.u_spanish, 'cde', 1), self.latin1_spanish)
class TestDefaultLocaleDir(unittest.TestCase, base_classes.UnicodeTestData):
@@ -863,16 +860,16 @@ class TestDefaultLocaleDir(unittest.Test
def test_gettext(self):
_ = self.translations.gettext
- tools.eq_(_(self.utf8_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
- tools.eq_(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.utf8_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
# Returns msgid because the string is in a fallback catalog which we
# haven't setup
- tools.eq_(_(self.utf8_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.utf8_in_fallback), self.utf8_in_fallback)
- tools.eq_(_(self.u_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.u_kuratomi), self.utf8_ja_kuratomi)
- tools.eq_(_(self.u_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.u_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.u_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.u_ja_kuratomi), self.utf8_kuratomi)
# Returns msgid because the string is in a fallback catalog which we
# haven't setup
- tools.eq_(_(self.u_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.u_in_fallback), self.utf8_in_fallback)
Index: kitchen-1.2.6/kitchen2/tests/test_iterutils.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test_iterutils.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test_iterutils.py 2020-09-09 14:50:23.910571749 +0200
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
from kitchen import iterutils
@@ -31,32 +30,32 @@ class TestIterutils(unittest.TestCase):
def test_isiterable(self):
for item in self.iterable_data:
- tools.ok_(iterutils.isiterable(item) == True)
+ self.assertTrue(iterutils.isiterable(item) == True)
for item in self.non_iterable_data:
- tools.ok_(iterutils.isiterable(item) == False)
+ self.assertTrue(iterutils.isiterable(item) == False)
# strings
- tools.ok_(iterutils.isiterable('a', include_string=True) == True)
- tools.ok_(iterutils.isiterable('a', include_string=False) == False)
- tools.ok_(iterutils.isiterable('a') == False)
- tools.ok_(iterutils.isiterable(u'a', include_string=True) == True)
- tools.ok_(iterutils.isiterable(u'a', include_string=False) == False)
- tools.ok_(iterutils.isiterable(u'a') == False)
+ self.assertTrue(iterutils.isiterable('a', include_string=True) == True)
+ self.assertTrue(iterutils.isiterable('a', include_string=False) == False)
+ self.assertTrue(iterutils.isiterable('a') == False)
+ self.assertTrue(iterutils.isiterable(u'a', include_string=True) == True)
+ self.assertTrue(iterutils.isiterable(u'a', include_string=False) == False)
+ self.assertTrue(iterutils.isiterable(u'a') == False)
def test_iterate(self):
iterutils.iterate(None)
for item in self.non_iterable_data:
- tools.ok_(list(iterutils.iterate(item)) == [item])
+ self.assertTrue(list(iterutils.iterate(item)) == [item])
for item in self.iterable_data[:-1]:
- tools.ok_(list(iterutils.iterate(item)) == list(item))
+ self.assertTrue(list(iterutils.iterate(item)) == list(item))
# iter() is exhausted after use so we have to test separately
- tools.ok_(list(iterutils.iterate(iter([1, 2, 3]))) == [1, 2, 3])
+ self.assertTrue(list(iterutils.iterate(iter([1, 2, 3]))) == [1, 2, 3])
# strings
- tools.ok_(list(iterutils.iterate('abc')) == ['abc'])
- tools.ok_(list(iterutils.iterate('abc', include_string=True)) == ['a', 'b', 'c'])
- tools.ok_(list(iterutils.iterate(u'abc')) == [u'abc'])
- tools.ok_(list(iterutils.iterate(u'abc', include_string=True)) == [u'a', u'b', u'c'])
+ self.assertTrue(list(iterutils.iterate('abc')) == ['abc'])
+ self.assertTrue(list(iterutils.iterate('abc', include_string=True)) == ['a', 'b', 'c'])
+ self.assertTrue(list(iterutils.iterate(u'abc')) == [u'abc'])
+ self.assertTrue(list(iterutils.iterate(u'abc', include_string=True)) == [u'a', u'b', u'c'])
Index: kitchen-1.2.6/kitchen2/tests/test_pycompat24.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test_pycompat24.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test_pycompat24.py 2020-09-09 14:50:38.666660897 +0200
@@ -1,8 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
-from nose.plugins.skip import SkipTest
import __builtin__
import base64 as py_b64
@@ -34,8 +32,8 @@ class TestSetsNoOverwrite(unittest.TestC
'''Test that importing sets when there's already a set and frozenset defined does not overwrite
'''
sets.add_builtin_set()
- tools.ok_(__builtin__.set == self.set_val)
- tools.ok_(__builtin__.frozenset == self.frozenset_val)
+ self.assertTrue(__builtin__.set == self.set_val)
+ self.assertTrue(__builtin__.frozenset == self.frozenset_val)
class TestDefineSets(unittest.TestCase):
def setUp(self):
@@ -66,11 +64,11 @@ class TestDefineSets(unittest.TestCase):
import sets as py_sets
sets.add_builtin_set()
if self.set_val:
- tools.ok_(__builtin__.set == self.set_val)
- tools.ok_(__builtin__.frozenset == self.frozenset_val)
+ self.assertTrue(__builtin__.set == self.set_val)
+ self.assertTrue(__builtin__.frozenset == self.frozenset_val)
else:
- tools.ok_(__builtin__.set == py_sets.Set)
- tools.ok_(__builtin__.frozenset == py_sets.ImmutableSet)
+ self.assertTrue(__builtin__.set == py_sets.Set)
+ self.assertTrue(__builtin__.frozenset == py_sets.ImmutableSet)
class TestSubprocess(unittest.TestCase):
pass
@@ -81,29 +79,29 @@ class TestBase64(unittest.TestCase):
b_byte_encoded_urlsafe = 'ACABIAIgAyAEIAUgBiAHIAggCSAKIAsgDCANIA4gDyAQIBEgEiATIBQgFSAWIBcgGCAZIBogGyAcIB0gHiAfICAgISAiICMgJCAlICYgJyAoICkgKiArICwgLSAuIC8gMCAxIDIgMyA0IDUgNiA3IDggOSA6IDsgPCA9ID4gPyBAIEEgQiBDIEQgRSBGIEcgSCBJIEogSyBMIE0gTiBPIFAgUSBSIFMgVCBVIFYgVyBYIFkgWiBbIFwgXSBeIF8gYCBhIGIgYyBkIGUgZiBnIGggaSBqIGsgbCBtIG4gbyBwIHEgciBzIHQgdSB2IHcgeCB5IHogeyB8IH0gfiB_IIAggSCCIIMghCCFIIYghyCIIIkgiiCLIIwgjSCOII8gkCCRIJIgkyCUIJUgliCXIJggmSCaIJsgnCCdIJ4gnyCgIKEgoiCjIKQgpSCmIKcgqCCpIKogqyCsIK0griCvILAgsSCyILMgtCC1ILYgtyC4ILkguiC7ILwgvSC-IL8gwCDBIMIgwyDEIMUgxiDHIMggySDKIMsgzCDNIM4gzyDQINEg0iDTINQg1SDWINcg2CDZINog2yDcIN0g3iDfIOAg4SDiIOMg5CDlIOYg5yDoIOkg6iDrIOwg7SDuIO8g8CDxIPIg8yD0IPUg9iD3IPgg-SD6IPsg_CD9IP4g_w=='
def test_base64_encode(self):
- tools.ok_(base64.b64encode(self.b_byte_chars) == self.b_byte_encoded)
- tools.ok_(base64.b64encode(self.b_byte_chars, altchars='-_') == self.b_byte_encoded_urlsafe)
- tools.ok_(base64.standard_b64encode(self.b_byte_chars) == self.b_byte_encoded)
- tools.ok_(base64.urlsafe_b64encode(self.b_byte_chars) == self.b_byte_encoded_urlsafe)
-
- tools.ok_(base64.b64encode(self.b_byte_chars) == self.b_byte_encoded)
- tools.ok_(base64.b64encode(self.b_byte_chars, altchars='-_') == self.b_byte_encoded_urlsafe)
- tools.ok_(base64.standard_b64encode(self.b_byte_chars) == self.b_byte_encoded)
- tools.ok_(base64.urlsafe_b64encode(self.b_byte_chars) == self.b_byte_encoded_urlsafe)
+ self.assertTrue(base64.b64encode(self.b_byte_chars) == self.b_byte_encoded)
+ self.assertTrue(base64.b64encode(self.b_byte_chars, altchars='-_') == self.b_byte_encoded_urlsafe)
+ self.assertTrue(base64.standard_b64encode(self.b_byte_chars) == self.b_byte_encoded)
+ self.assertTrue(base64.urlsafe_b64encode(self.b_byte_chars) == self.b_byte_encoded_urlsafe)
+
+ self.assertTrue(base64.b64encode(self.b_byte_chars) == self.b_byte_encoded)
+ self.assertTrue(base64.b64encode(self.b_byte_chars, altchars='-_') == self.b_byte_encoded_urlsafe)
+ self.assertTrue(base64.standard_b64encode(self.b_byte_chars) == self.b_byte_encoded)
+ self.assertTrue(base64.urlsafe_b64encode(self.b_byte_chars) == self.b_byte_encoded_urlsafe)
def test_base64_decode(self):
- tools.ok_(base64.b64decode(self.b_byte_encoded) == self.b_byte_chars)
- tools.ok_(base64.b64decode(self.b_byte_encoded_urlsafe, altchars='-_') == self.b_byte_chars)
- tools.ok_(base64.standard_b64decode(self.b_byte_encoded) == self.b_byte_chars)
- tools.ok_(base64.urlsafe_b64decode(self.b_byte_encoded_urlsafe) == self.b_byte_chars)
-
- tools.ok_(base64.b64decode(self.b_byte_encoded) == self.b_byte_chars)
- tools.ok_(base64.b64decode(self.b_byte_encoded_urlsafe, altchars='-_') == self.b_byte_chars)
- tools.ok_(base64.standard_b64decode(self.b_byte_encoded) == self.b_byte_chars)
- tools.ok_(base64.urlsafe_b64decode(self.b_byte_encoded_urlsafe) == self.b_byte_chars)
+ self.assertTrue(base64.b64decode(self.b_byte_encoded) == self.b_byte_chars)
+ self.assertTrue(base64.b64decode(self.b_byte_encoded_urlsafe, altchars='-_') == self.b_byte_chars)
+ self.assertTrue(base64.standard_b64decode(self.b_byte_encoded) == self.b_byte_chars)
+ self.assertTrue(base64.urlsafe_b64decode(self.b_byte_encoded_urlsafe) == self.b_byte_chars)
+
+ self.assertTrue(base64.b64decode(self.b_byte_encoded) == self.b_byte_chars)
+ self.assertTrue(base64.b64decode(self.b_byte_encoded_urlsafe, altchars='-_') == self.b_byte_chars)
+ self.assertTrue(base64.standard_b64decode(self.b_byte_encoded) == self.b_byte_chars)
+ self.assertTrue(base64.urlsafe_b64decode(self.b_byte_encoded_urlsafe) == self.b_byte_chars)
def test_base64_stdlib_compat(self):
if not hasattr(py_b64, 'b64encode'):
- raise SkipTest('Python-2.3 doesn\'t have b64encode to compare against')
- tools.ok_(base64.b64encode(self.b_byte_chars) == py_b64.b64encode(self.b_byte_chars))
- tools.ok_(base64.b64decode(self.b_byte_chars) == py_b64.b64decode(self.b_byte_chars))
+ self.skipTest('Python-2.3 doesn\'t have b64encode to compare against')
+ self.assertTrue(base64.b64encode(self.b_byte_chars) == py_b64.b64encode(self.b_byte_chars))
+ self.assertTrue(base64.b64decode(self.b_byte_chars) == py_b64.b64decode(self.b_byte_chars))
Index: kitchen-1.2.6/kitchen2/tests/test_pycompat.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test_pycompat.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test_pycompat.py 2020-09-09 14:50:23.910571749 +0200
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
class TestUsableModules(unittest.TestCase):
def test_subprocess(self):
@@ -10,11 +9,11 @@ class TestUsableModules(unittest.TestCas
try:
from kitchen.pycompat24.subprocess import Popen
except ImportError:
- tools.ok_(False, 'Unable to import pycompat24.subprocess as a module')
+ self.assertTrue(False, 'Unable to import pycompat24.subprocess as a module')
try:
from kitchen.pycompat27.subprocess import Popen
except ImportError:
- tools.ok_(False, 'Unable to import pycompat27.subprocess as a module')
+ self.assertTrue(False, 'Unable to import pycompat27.subprocess as a module')
def test_base64(self):
'''Test that importing base64 as a module works
@@ -22,4 +21,4 @@ class TestUsableModules(unittest.TestCas
try:
from kitchen.pycompat24.base64 import b64encode
except ImportError:
- tools.ok_(False, 'Unable to import pycompat24.base64 as a module')
+ self.assertTrue(False, 'Unable to import pycompat24.base64 as a module')
Index: kitchen-1.2.6/kitchen2/tests/test_text_display.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test_text_display.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test_text_display.py 2020-09-09 14:50:23.910571749 +0200
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
from kitchen.text.exceptions import ControlCharError
@@ -14,19 +13,19 @@ class TestDisplay(base_classes.UnicodeTe
def test_internal_interval_bisearch(self):
'''Test that we can find things in an interval table'''
table = ((0, 3), (5, 7), (9, 10))
- tools.assert_true(display._interval_bisearch(0, table))
- tools.assert_true(display._interval_bisearch(1, table))
- tools.assert_true(display._interval_bisearch(2, table))
- tools.assert_true(display._interval_bisearch(3, table))
- tools.assert_true(display._interval_bisearch(5, table))
- tools.assert_true(display._interval_bisearch(6, table))
- tools.assert_true(display._interval_bisearch(7, table))
- tools.assert_true(display._interval_bisearch(9, table))
- tools.assert_true(display._interval_bisearch(10, table))
- tools.assert_false(display._interval_bisearch(-1, table))
- tools.assert_false(display._interval_bisearch(4, table))
- tools.assert_false(display._interval_bisearch(8, table))
- tools.assert_false(display._interval_bisearch(11, table))
+ self.assertTrue(display._interval_bisearch(0, table))
+ self.assertTrue(display._interval_bisearch(1, table))
+ self.assertTrue(display._interval_bisearch(2, table))
+ self.assertTrue(display._interval_bisearch(3, table))
+ self.assertTrue(display._interval_bisearch(5, table))
+ self.assertTrue(display._interval_bisearch(6, table))
+ self.assertTrue(display._interval_bisearch(7, table))
+ self.assertTrue(display._interval_bisearch(9, table))
+ self.assertTrue(display._interval_bisearch(10, table))
+ self.assertFalse(display._interval_bisearch(-1, table))
+ self.assertFalse(display._interval_bisearch(4, table))
+ self.assertFalse(display._interval_bisearch(8, table))
+ self.assertFalse(display._interval_bisearch(11, table))
def test_internal_generate_combining_table(self):
'''Test that the combining table we generate is equal to or a subseet of what's in the current table
@@ -40,27 +39,27 @@ class TestDisplay(base_classes.UnicodeTe
new_table = display._generate_combining_table()
for interval in new_table:
if interval[0] == interval[1]:
- tools.assert_true(display._interval_bisearch(interval[0], old_table))
+ self.assertTrue(display._interval_bisearch(interval[0], old_table))
else:
for codepoint in xrange(interval[0], interval[1] + 1):
- tools.assert_true(display._interval_bisearch(interval[0], old_table))
+ self.assertTrue(display._interval_bisearch(interval[0], old_table))
def test_internal_ucp_width(self):
'''Test that ucp_width returns proper width for characters'''
for codepoint in xrange(0, 0xFFFFF + 1):
if codepoint < 32 or (codepoint < 0xa0 and codepoint >= 0x7f):
# With strict on, we should raise an error
- tools.assert_raises(ControlCharError, display._ucp_width, codepoint, 'strict')
+ self.assertRaises(ControlCharError, display._ucp_width, codepoint, 'strict')
if codepoint in (0x08, 0x1b, 0x7f, 0x94):
# Backspace, delete, clear delete remove one char
- tools.eq_(display._ucp_width(codepoint), -1)
+ self.assertEqual(display._ucp_width(codepoint), -1)
else:
# Everything else returns 0
- tools.eq_(display._ucp_width(codepoint), 0)
+ self.assertEqual(display._ucp_width(codepoint), 0)
elif display._interval_bisearch(codepoint, display._COMBINING):
# Combining character
- tools.eq_(display._ucp_width(codepoint), 0)
+ self.assertEqual(display._ucp_width(codepoint), 0)
elif (codepoint >= 0x1100 and
(codepoint <= 0x115f or # Hangul Jamo init. consonants
codepoint == 0x2329 or codepoint == 0x232a or
@@ -74,87 +73,87 @@ class TestDisplay(base_classes.UnicodeTe
(codepoint >= 0xffe0 and codepoint <= 0xffe6) or
(codepoint >= 0x20000 and codepoint <= 0x2fffd) or
(codepoint >= 0x30000 and codepoint <= 0x3fffd))):
- tools.eq_(display._ucp_width(codepoint), 2)
+ self.assertEqual(display._ucp_width(codepoint), 2)
else:
- tools.eq_(display._ucp_width(codepoint), 1)
+ self.assertEqual(display._ucp_width(codepoint), 1)
def test_textual_width(self):
'''Test that we find the proper number of spaces that a utf8 string will consume'''
- tools.eq_(display.textual_width(self.u_japanese), 31)
- tools.eq_(display.textual_width(self.u_spanish), 50)
- tools.eq_(display.textual_width(self.u_mixed), 23)
+ self.assertEqual(display.textual_width(self.u_japanese), 31)
+ self.assertEqual(display.textual_width(self.u_spanish), 50)
+ self.assertEqual(display.textual_width(self.u_mixed), 23)
def test_textual_width_chop(self):
'''utf8_width_chop with byte strings'''
- tools.eq_(display.textual_width_chop(self.u_mixed, 1000), self.u_mixed)
- tools.eq_(display.textual_width_chop(self.u_mixed, 23), self.u_mixed)
- tools.eq_(display.textual_width_chop(self.u_mixed, 22), self.u_mixed[:-1])
- tools.eq_(display.textual_width_chop(self.u_mixed, 19), self.u_mixed[:-4])
- tools.eq_(display.textual_width_chop(self.u_mixed, 1), u'')
- tools.eq_(display.textual_width_chop(self.u_mixed, 2), self.u_mixed[0])
- tools.eq_(display.textual_width_chop(self.u_mixed, 3), self.u_mixed[:2])
- tools.eq_(display.textual_width_chop(self.u_mixed, 4), self.u_mixed[:3])
- tools.eq_(display.textual_width_chop(self.u_mixed, 5), self.u_mixed[:4])
- tools.eq_(display.textual_width_chop(self.u_mixed, 6), self.u_mixed[:5])
- tools.eq_(display.textual_width_chop(self.u_mixed, 7), self.u_mixed[:5])
- tools.eq_(display.textual_width_chop(self.u_mixed, 8), self.u_mixed[:6])
- tools.eq_(display.textual_width_chop(self.u_mixed, 9), self.u_mixed[:7])
- tools.eq_(display.textual_width_chop(self.u_mixed, 10), self.u_mixed[:8])
- tools.eq_(display.textual_width_chop(self.u_mixed, 11), self.u_mixed[:9])
- tools.eq_(display.textual_width_chop(self.u_mixed, 12), self.u_mixed[:10])
- tools.eq_(display.textual_width_chop(self.u_mixed, 13), self.u_mixed[:10])
- tools.eq_(display.textual_width_chop(self.u_mixed, 14), self.u_mixed[:11])
- tools.eq_(display.textual_width_chop(self.u_mixed, 15), self.u_mixed[:12])
- tools.eq_(display.textual_width_chop(self.u_mixed, 16), self.u_mixed[:13])
- tools.eq_(display.textual_width_chop(self.u_mixed, 17), self.u_mixed[:14])
- tools.eq_(display.textual_width_chop(self.u_mixed, 18), self.u_mixed[:15])
- tools.eq_(display.textual_width_chop(self.u_mixed, 19), self.u_mixed[:15])
- tools.eq_(display.textual_width_chop(self.u_mixed, 20), self.u_mixed[:16])
- tools.eq_(display.textual_width_chop(self.u_mixed, 21), self.u_mixed[:17])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 1000), self.u_mixed)
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 23), self.u_mixed)
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 22), self.u_mixed[:-1])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 19), self.u_mixed[:-4])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 1), u'')
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 2), self.u_mixed[0])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 3), self.u_mixed[:2])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 4), self.u_mixed[:3])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 5), self.u_mixed[:4])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 6), self.u_mixed[:5])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 7), self.u_mixed[:5])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 8), self.u_mixed[:6])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 9), self.u_mixed[:7])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 10), self.u_mixed[:8])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 11), self.u_mixed[:9])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 12), self.u_mixed[:10])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 13), self.u_mixed[:10])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 14), self.u_mixed[:11])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 15), self.u_mixed[:12])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 16), self.u_mixed[:13])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 17), self.u_mixed[:14])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 18), self.u_mixed[:15])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 19), self.u_mixed[:15])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 20), self.u_mixed[:16])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 21), self.u_mixed[:17])
def test_textual_width_fill(self):
'''Pad a utf8 string'''
- tools.eq_(display.textual_width_fill(self.u_mixed, 1), self.u_mixed)
- tools.eq_(display.textual_width_fill(self.u_mixed, 25), self.u_mixed + u' ')
- tools.eq_(display.textual_width_fill(self.u_mixed, 25, left=False), u' ' + self.u_mixed)
- tools.eq_(display.textual_width_fill(self.u_mixed, 25, chop=18), self.u_mixed[:-4] + u' ')
- tools.eq_(display.textual_width_fill(self.u_mixed, 25, chop=18, prefix=self.u_spanish, suffix=self.u_spanish), self.u_spanish + self.u_mixed[:-4] + self.u_spanish + u' ')
- tools.eq_(display.textual_width_fill(self.u_mixed, 25, chop=18), self.u_mixed[:-4] + u' ')
- tools.eq_(display.textual_width_fill(self.u_mixed, 25, chop=18, prefix=self.u_spanish, suffix=self.u_spanish), self.u_spanish + self.u_mixed[:-4] + self.u_spanish + u' ')
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 1), self.u_mixed)
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 25), self.u_mixed + u' ')
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 25, left=False), u' ' + self.u_mixed)
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 25, chop=18), self.u_mixed[:-4] + u' ')
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 25, chop=18, prefix=self.u_spanish, suffix=self.u_spanish), self.u_spanish + self.u_mixed[:-4] + self.u_spanish + u' ')
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 25, chop=18), self.u_mixed[:-4] + u' ')
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 25, chop=18, prefix=self.u_spanish, suffix=self.u_spanish), self.u_spanish + self.u_mixed[:-4] + self.u_spanish + u' ')
def test_internal_textual_width_le(self):
test_data = ''.join([self.u_mixed, self.u_spanish])
tw = display.textual_width(test_data)
- tools.eq_(display._textual_width_le(68, self.u_mixed, self.u_spanish), (tw <= 68))
- tools.eq_(display._textual_width_le(69, self.u_mixed, self.u_spanish), (tw <= 69))
- tools.eq_(display._textual_width_le(137, self.u_mixed, self.u_spanish), (tw <= 137))
- tools.eq_(display._textual_width_le(138, self.u_mixed, self.u_spanish), (tw <= 138))
- tools.eq_(display._textual_width_le(78, self.u_mixed, self.u_spanish), (tw <= 78))
- tools.eq_(display._textual_width_le(79, self.u_mixed, self.u_spanish), (tw <= 79))
+ self.assertEqual(display._textual_width_le(68, self.u_mixed, self.u_spanish), (tw <= 68))
+ self.assertEqual(display._textual_width_le(69, self.u_mixed, self.u_spanish), (tw <= 69))
+ self.assertEqual(display._textual_width_le(137, self.u_mixed, self.u_spanish), (tw <= 137))
+ self.assertEqual(display._textual_width_le(138, self.u_mixed, self.u_spanish), (tw <= 138))
+ self.assertEqual(display._textual_width_le(78, self.u_mixed, self.u_spanish), (tw <= 78))
+ self.assertEqual(display._textual_width_le(79, self.u_mixed, self.u_spanish), (tw <= 79))
def test_wrap(self):
'''Test that text wrapping works'''
- tools.eq_(display.wrap(self.u_mixed), [self.u_mixed])
- tools.eq_(display.wrap(self.u_paragraph), self.u_paragraph_out)
- tools.eq_(display.wrap(self.utf8_paragraph), self.u_paragraph_out)
- tools.eq_(display.wrap(self.u_mixed_para), self.u_mixed_para_out)
- tools.eq_(display.wrap(self.u_mixed_para, width=57,
+ self.assertEqual(display.wrap(self.u_mixed), [self.u_mixed])
+ self.assertEqual(display.wrap(self.u_paragraph), self.u_paragraph_out)
+ self.assertEqual(display.wrap(self.utf8_paragraph), self.u_paragraph_out)
+ self.assertEqual(display.wrap(self.u_mixed_para), self.u_mixed_para_out)
+ self.assertEqual(display.wrap(self.u_mixed_para, width=57,
initial_indent=' ', subsequent_indent='----'),
self.u_mixed_para_57_initial_subsequent_out)
def test_fill(self):
- tools.eq_(display.fill(self.u_paragraph), u'\n'.join(self.u_paragraph_out))
- tools.eq_(display.fill(self.utf8_paragraph), u'\n'.join(self.u_paragraph_out))
- tools.eq_(display.fill(self.u_mixed_para), u'\n'.join(self.u_mixed_para_out))
- tools.eq_(display.fill(self.u_mixed_para, width=57,
+ self.assertEqual(display.fill(self.u_paragraph), u'\n'.join(self.u_paragraph_out))
+ self.assertEqual(display.fill(self.utf8_paragraph), u'\n'.join(self.u_paragraph_out))
+ self.assertEqual(display.fill(self.u_mixed_para), u'\n'.join(self.u_mixed_para_out))
+ self.assertEqual(display.fill(self.u_mixed_para, width=57,
initial_indent=' ', subsequent_indent='----'),
u'\n'.join(self.u_mixed_para_57_initial_subsequent_out))
def test_byte_string_textual_width_fill(self):
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 1), self.utf8_mixed)
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 25), self.utf8_mixed + ' ')
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 25, left=False), ' ' + self.utf8_mixed)
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18), self.u_mixed[:-4].encode('utf8') + ' ')
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18, prefix=self.utf8_spanish, suffix=self.utf8_spanish), self.utf8_spanish + self.u_mixed[:-4].encode('utf8') + self.utf8_spanish + ' ')
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18), self.u_mixed[:-4].encode('utf8') + ' ')
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18, prefix=self.utf8_spanish, suffix=self.utf8_spanish), self.utf8_spanish + self.u_mixed[:-4].encode('utf8') + self.utf8_spanish + ' ')
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 1), self.utf8_mixed)
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 25), self.utf8_mixed + ' ')
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 25, left=False), ' ' + self.utf8_mixed)
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18), self.u_mixed[:-4].encode('utf8') + ' ')
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18, prefix=self.utf8_spanish, suffix=self.utf8_spanish), self.utf8_spanish + self.u_mixed[:-4].encode('utf8') + self.utf8_spanish + ' ')
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18), self.u_mixed[:-4].encode('utf8') + ' ')
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18, prefix=self.utf8_spanish, suffix=self.utf8_spanish), self.utf8_spanish + self.u_mixed[:-4].encode('utf8') + self.utf8_spanish + ' ')
Index: kitchen-1.2.6/kitchen2/tests/test_text_misc.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test_text_misc.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test_text_misc.py 2020-09-09 14:50:23.910571749 +0200
@@ -1,8 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
-from nose.plugins.skip import SkipTest
try:
import chardet
@@ -18,136 +16,136 @@ import base_classes
class TestTextMisc(unittest.TestCase, base_classes.UnicodeTestData):
def test_guess_encoding_no_chardet(self):
# Test that unicode strings are not allowed
- tools.assert_raises(TypeError, misc.guess_encoding, self.u_spanish)
+ self.assertRaises(TypeError, misc.guess_encoding, self.u_spanish)
- tools.ok_(misc.guess_encoding(self.utf8_spanish, disable_chardet=True) == 'utf-8')
- tools.ok_(misc.guess_encoding(self.latin1_spanish, disable_chardet=True) == 'latin-1')
- tools.ok_(misc.guess_encoding(self.utf8_japanese, disable_chardet=True) == 'utf-8')
- tools.ok_(misc.guess_encoding(self.euc_jp_japanese, disable_chardet=True) == 'latin-1')
+ self.assertTrue(misc.guess_encoding(self.utf8_spanish, disable_chardet=True) == 'utf-8')
+ self.assertTrue(misc.guess_encoding(self.latin1_spanish, disable_chardet=True) == 'latin-1')
+ self.assertTrue(misc.guess_encoding(self.utf8_japanese, disable_chardet=True) == 'utf-8')
+ self.assertTrue(misc.guess_encoding(self.euc_jp_japanese, disable_chardet=True) == 'latin-1')
def test_guess_encoding_with_chardet(self):
# We go this slightly roundabout way because multiple encodings can
# output the same byte sequence. What we're really interested in is
# if we can get the original unicode string without knowing the
# converters beforehand
- tools.ok_(to_unicode(self.utf8_spanish,
+ self.assertTrue(to_unicode(self.utf8_spanish,
misc.guess_encoding(self.utf8_spanish)) == self.u_spanish)
- tools.ok_(to_unicode(self.latin1_spanish,
+ self.assertTrue(to_unicode(self.latin1_spanish,
misc.guess_encoding(self.latin1_spanish)) == self.u_spanish)
- tools.ok_(to_unicode(self.utf8_japanese,
+ self.assertTrue(to_unicode(self.utf8_japanese,
misc.guess_encoding(self.utf8_japanese)) == self.u_japanese)
def test_guess_encoding_with_chardet_installed(self):
if chardet:
- tools.ok_(to_unicode(self.euc_jp_japanese,
+ self.assertTrue(to_unicode(self.euc_jp_japanese,
misc.guess_encoding(self.euc_jp_japanese)) == self.u_japanese)
else:
- raise SkipTest('chardet not installed, euc_jp will not be guessed correctly')
+ self.skipTest('chardet not installed, euc_jp will not be guessed correctly')
def test_guess_encoding_with_chardet_uninstalled(self):
if chardet:
- raise SkipTest('chardet installed, euc_jp will not be mangled')
+ self.skipTest('chardet installed, euc_jp will not be mangled')
else:
- tools.ok_(to_unicode(self.euc_jp_japanese,
+ self.assertTrue(to_unicode(self.euc_jp_japanese,
misc.guess_encoding(self.euc_jp_japanese)) ==
self.u_mangled_euc_jp_as_latin1)
def test_str_eq(self):
# str vs str:
- tools.ok_(misc.str_eq(self.euc_jp_japanese, self.euc_jp_japanese) == True)
- tools.ok_(misc.str_eq(self.utf8_japanese, self.utf8_japanese) == True)
- tools.ok_(misc.str_eq(self.b_ascii, self.b_ascii) == True)
- tools.ok_(misc.str_eq(self.euc_jp_japanese, self.latin1_spanish) == False)
- tools.ok_(misc.str_eq(self.utf8_japanese, self.euc_jp_japanese) == False)
- tools.ok_(misc.str_eq(self.b_ascii, self.b_ascii[:-2]) == False)
+ self.assertTrue(misc.str_eq(self.euc_jp_japanese, self.euc_jp_japanese) == True)
+ self.assertTrue(misc.str_eq(self.utf8_japanese, self.utf8_japanese) == True)
+ self.assertTrue(misc.str_eq(self.b_ascii, self.b_ascii) == True)
+ self.assertTrue(misc.str_eq(self.euc_jp_japanese, self.latin1_spanish) == False)
+ self.assertTrue(misc.str_eq(self.utf8_japanese, self.euc_jp_japanese) == False)
+ self.assertTrue(misc.str_eq(self.b_ascii, self.b_ascii[:-2]) == False)
# unicode vs unicode:
- tools.ok_(misc.str_eq(self.u_japanese, self.u_japanese) == True)
- tools.ok_(misc.str_eq(self.u_ascii, self.u_ascii) == True)
- tools.ok_(misc.str_eq(self.u_japanese, self.u_spanish) == False)
- tools.ok_(misc.str_eq(self.u_ascii, self.u_ascii[:-2]) == False)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.u_japanese) == True)
+ self.assertTrue(misc.str_eq(self.u_ascii, self.u_ascii) == True)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.u_spanish) == False)
+ self.assertTrue(misc.str_eq(self.u_ascii, self.u_ascii[:-2]) == False)
# unicode vs str with default utf-8 conversion:
- tools.ok_(misc.str_eq(self.u_japanese, self.utf8_japanese) == True)
- tools.ok_(misc.str_eq(self.u_ascii, self.b_ascii) == True)
- tools.ok_(misc.str_eq(self.u_japanese, self.euc_jp_japanese) == False)
- tools.ok_(misc.str_eq(self.u_ascii, self.b_ascii[:-2]) == False)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.utf8_japanese) == True)
+ self.assertTrue(misc.str_eq(self.u_ascii, self.b_ascii) == True)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.euc_jp_japanese) == False)
+ self.assertTrue(misc.str_eq(self.u_ascii, self.b_ascii[:-2]) == False)
# unicode vs str with explicit encodings:
- tools.ok_(misc.str_eq(self.u_japanese, self.euc_jp_japanese, encoding='euc_jp') == True)
- tools.ok_(misc.str_eq(self.u_japanese, self.utf8_japanese, encoding='utf8') == True)
- tools.ok_(misc.str_eq(self.u_ascii, self.b_ascii, encoding='latin1') == True)
- tools.ok_(misc.str_eq(self.u_japanese, self.euc_jp_japanese, encoding='latin1') == False)
- tools.ok_(misc.str_eq(self.u_japanese, self.utf8_japanese, encoding='euc_jp') == False)
- tools.ok_(misc.str_eq(self.u_japanese, self.utf8_japanese, encoding='euc_jp') == False)
- tools.ok_(misc.str_eq(self.u_ascii, self.b_ascii[:-2], encoding='latin1') == False)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.euc_jp_japanese, encoding='euc_jp') == True)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.utf8_japanese, encoding='utf8') == True)
+ self.assertTrue(misc.str_eq(self.u_ascii, self.b_ascii, encoding='latin1') == True)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.euc_jp_japanese, encoding='latin1') == False)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.utf8_japanese, encoding='euc_jp') == False)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.utf8_japanese, encoding='euc_jp') == False)
+ self.assertTrue(misc.str_eq(self.u_ascii, self.b_ascii[:-2], encoding='latin1') == False)
# str vs unicode (reverse parameter order of unicode vs str)
- tools.ok_(misc.str_eq(self.utf8_japanese, self.u_japanese) == True)
- tools.ok_(misc.str_eq(self.b_ascii, self.u_ascii) == True)
- tools.ok_(misc.str_eq(self.euc_jp_japanese, self.u_japanese) == False)
- tools.ok_(misc.str_eq(self.b_ascii, self.u_ascii[:-2]) == False)
-
- tools.ok_(misc.str_eq(self.euc_jp_japanese, self.u_japanese, encoding='euc_jp') == True)
- tools.ok_(misc.str_eq(self.utf8_japanese, self.u_japanese, encoding='utf8') == True)
- tools.ok_(misc.str_eq(self.b_ascii, self.u_ascii, encoding='latin1') == True)
- tools.ok_(misc.str_eq(self.euc_jp_japanese, self.u_japanese, encoding='latin1') == False)
- tools.ok_(misc.str_eq(self.utf8_japanese, self.u_japanese, encoding='euc_jp') == False)
- tools.ok_(misc.str_eq(self.utf8_japanese, self.u_japanese, encoding='euc_jp') == False)
- tools.ok_(misc.str_eq(self.b_ascii, self.u_ascii[:-2], encoding='latin1') == False)
+ self.assertTrue(misc.str_eq(self.utf8_japanese, self.u_japanese) == True)
+ self.assertTrue(misc.str_eq(self.b_ascii, self.u_ascii) == True)
+ self.assertTrue(misc.str_eq(self.euc_jp_japanese, self.u_japanese) == False)
+ self.assertTrue(misc.str_eq(self.b_ascii, self.u_ascii[:-2]) == False)
+
+ self.assertTrue(misc.str_eq(self.euc_jp_japanese, self.u_japanese, encoding='euc_jp') == True)
+ self.assertTrue(misc.str_eq(self.utf8_japanese, self.u_japanese, encoding='utf8') == True)
+ self.assertTrue(misc.str_eq(self.b_ascii, self.u_ascii, encoding='latin1') == True)
+ self.assertTrue(misc.str_eq(self.euc_jp_japanese, self.u_japanese, encoding='latin1') == False)
+ self.assertTrue(misc.str_eq(self.utf8_japanese, self.u_japanese, encoding='euc_jp') == False)
+ self.assertTrue(misc.str_eq(self.utf8_japanese, self.u_japanese, encoding='euc_jp') == False)
+ self.assertTrue(misc.str_eq(self.b_ascii, self.u_ascii[:-2], encoding='latin1') == False)
def test_process_control_chars(self):
- tools.assert_raises(TypeError, misc.process_control_chars, 'byte string')
- tools.assert_raises(ControlCharError, misc.process_control_chars,
+ self.assertRaises(TypeError, misc.process_control_chars, 'byte string')
+ self.assertRaises(ControlCharError, misc.process_control_chars,
*[self.u_ascii_chars], **{'strategy': 'strict'})
- tools.ok_(misc.process_control_chars(self.u_ascii_chars,
+ self.assertTrue(misc.process_control_chars(self.u_ascii_chars,
strategy='ignore') == self.u_ascii_no_ctrl)
- tools.ok_(misc.process_control_chars(self.u_ascii_chars,
+ self.assertTrue(misc.process_control_chars(self.u_ascii_chars,
strategy='replace') == self.u_ascii_ctrl_replace)
def test_html_entities_unescape(self):
- tools.assert_raises(TypeError, misc.html_entities_unescape, 'byte string')
- tools.ok_(misc.html_entities_unescape(self.u_entity_escape) == self.u_entity)
- tools.ok_(misc.html_entities_unescape(u'<tag>%s</tag>'
+ self.assertRaises(TypeError, misc.html_entities_unescape, 'byte string')
+ self.assertTrue(misc.html_entities_unescape(self.u_entity_escape) == self.u_entity)
+ self.assertTrue(misc.html_entities_unescape(u'<tag>%s</tag>'
% self.u_entity_escape) == self.u_entity)
- tools.ok_(misc.html_entities_unescape(u'a�b') == u'a�b')
- tools.ok_(misc.html_entities_unescape(u'a�b') == u'a\ufffdb')
- tools.ok_(misc.html_entities_unescape(u'a�b') == u'a\ufffdb')
+ self.assertTrue(misc.html_entities_unescape(u'a�b') == u'a�b')
+ self.assertTrue(misc.html_entities_unescape(u'a�b') == u'a\ufffdb')
+ self.assertTrue(misc.html_entities_unescape(u'a�b') == u'a\ufffdb')
def test_byte_string_valid_xml(self):
- tools.ok_(misc.byte_string_valid_xml(u'unicode string') == False)
+ self.assertTrue(misc.byte_string_valid_xml(u'unicode string') == False)
- tools.ok_(misc.byte_string_valid_xml(self.utf8_japanese))
- tools.ok_(misc.byte_string_valid_xml(self.euc_jp_japanese, 'euc_jp'))
+ self.assertTrue(misc.byte_string_valid_xml(self.utf8_japanese))
+ self.assertTrue(misc.byte_string_valid_xml(self.euc_jp_japanese, 'euc_jp'))
- tools.ok_(misc.byte_string_valid_xml(self.utf8_japanese, 'euc_jp') == False)
- tools.ok_(misc.byte_string_valid_xml(self.euc_jp_japanese, 'utf8') == False)
+ self.assertTrue(misc.byte_string_valid_xml(self.utf8_japanese, 'euc_jp') == False)
+ self.assertTrue(misc.byte_string_valid_xml(self.euc_jp_japanese, 'utf8') == False)
- tools.ok_(misc.byte_string_valid_xml(self.utf8_ascii_chars) == False)
+ self.assertTrue(misc.byte_string_valid_xml(self.utf8_ascii_chars) == False)
def test_byte_string_valid_encoding(self):
'''Test that a byte sequence is validated'''
- tools.ok_(misc.byte_string_valid_encoding(self.utf8_japanese) == True)
- tools.ok_(misc.byte_string_valid_encoding(self.euc_jp_japanese, encoding='euc_jp') == True)
+ self.assertTrue(misc.byte_string_valid_encoding(self.utf8_japanese) == True)
+ self.assertTrue(misc.byte_string_valid_encoding(self.euc_jp_japanese, encoding='euc_jp') == True)
def test_byte_string_invalid_encoding(self):
'''Test that we return False with non-encoded chars'''
- tools.ok_(misc.byte_string_valid_encoding('\xff') == False)
- tools.ok_(misc.byte_string_valid_encoding(self.euc_jp_japanese) == False)
+ self.assertTrue(misc.byte_string_valid_encoding('\xff') == False)
+ self.assertTrue(misc.byte_string_valid_encoding(self.euc_jp_japanese) == False)
class TestIsStringTypes(unittest.TestCase):
def test_isbasestring(self):
- tools.assert_true(misc.isbasestring('abc'))
- tools.assert_true(misc.isbasestring(u'abc'))
- tools.assert_false(misc.isbasestring(5))
+ self.assertTrue(misc.isbasestring('abc'))
+ self.assertTrue(misc.isbasestring(u'abc'))
+ self.assertFalse(misc.isbasestring(5))
def test_isbytestring(self):
- tools.assert_true(misc.isbytestring('abc'))
- tools.assert_false(misc.isbytestring(u'abc'))
- tools.assert_false(misc.isbytestring(5))
+ self.assertTrue(misc.isbytestring('abc'))
+ self.assertFalse(misc.isbytestring(u'abc'))
+ self.assertFalse(misc.isbytestring(5))
def test_isunicodestring(self):
- tools.assert_false(misc.isunicodestring('abc'))
- tools.assert_true(misc.isunicodestring(u'abc'))
- tools.assert_false(misc.isunicodestring(5))
+ self.assertFalse(misc.isunicodestring('abc'))
+ self.assertTrue(misc.isunicodestring(u'abc'))
+ self.assertFalse(misc.isunicodestring(5))
Index: kitchen-1.2.6/kitchen2/tests/test_text_utf8.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test_text_utf8.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test_text_utf8.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
import warnings
@@ -19,9 +18,9 @@ class TestUTF8(base_classes.UnicodeTestD
def test_utf8_width(self):
'''Test that we find the proper number of spaces that a utf8 string will consume'''
- tools.ok_(utf8.utf8_width(self.utf8_japanese) == 31)
- tools.ok_(utf8.utf8_width(self.utf8_spanish) == 50)
- tools.ok_(utf8.utf8_width(self.utf8_mixed) == 23)
+ self.assertTrue(utf8.utf8_width(self.utf8_japanese) == 31)
+ self.assertTrue(utf8.utf8_width(self.utf8_spanish) == 50)
+ self.assertTrue(utf8.utf8_width(self.utf8_mixed) == 23)
def test_utf8_width_non_utf8(self):
'''Test that we handle non-utf8 bytes in utf8_width without backtracing'''
@@ -35,58 +34,58 @@ class TestUTF8(base_classes.UnicodeTestD
# El veloz murci�go salt�bre el perro perezoso.
if len(unicode(u'\xe9la'.encode('latin1'), 'utf8', 'replace')) == 1:
# Python < 2.7
- tools.ok_(utf8.utf8_width(self.latin1_spanish) == 45)
+ self.assertTrue(utf8.utf8_width(self.latin1_spanish) == 45)
else:
# Python >= 2.7
- tools.ok_(utf8.utf8_width(self.latin1_spanish) == 50)
+ self.assertTrue(utf8.utf8_width(self.latin1_spanish) == 50)
def test_utf8_width_chop(self):
'''utf8_width_chop with byte strings'''
- tools.ok_(utf8.utf8_width_chop(self.utf8_mixed) == (23, self.utf8_mixed))
- tools.ok_(utf8.utf8_width_chop(self.utf8_mixed, 23) == (23, self.utf8_mixed))
- tools.ok_(utf8.utf8_width_chop(self.utf8_mixed, 22) == (22, self.utf8_mixed[:-1]))
- tools.ok_(utf8.utf8_width_chop(self.utf8_mixed, 19) == (18, self.u_mixed[:-4].encode('utf8')))
- tools.ok_(utf8.utf8_width_chop(self.utf8_mixed, 2) == (2, self.u_mixed[0].encode('utf8')))
- tools.ok_(utf8.utf8_width_chop(self.utf8_mixed, 1) == (0, ''))
+ self.assertTrue(utf8.utf8_width_chop(self.utf8_mixed) == (23, self.utf8_mixed))
+ self.assertTrue(utf8.utf8_width_chop(self.utf8_mixed, 23) == (23, self.utf8_mixed))
+ self.assertTrue(utf8.utf8_width_chop(self.utf8_mixed, 22) == (22, self.utf8_mixed[:-1]))
+ self.assertTrue(utf8.utf8_width_chop(self.utf8_mixed, 19) == (18, self.u_mixed[:-4].encode('utf8')))
+ self.assertTrue(utf8.utf8_width_chop(self.utf8_mixed, 2) == (2, self.u_mixed[0].encode('utf8')))
+ self.assertTrue(utf8.utf8_width_chop(self.utf8_mixed, 1) == (0, ''))
def test_utf8_width_chop_unicode(self):
'''utf8_width_chop with unicode input'''
- tools.ok_(utf8.utf8_width_chop(self.u_mixed) == (23, self.u_mixed))
- tools.ok_(utf8.utf8_width_chop(self.u_mixed, 23) == (23, self.u_mixed))
- tools.ok_(utf8.utf8_width_chop(self.u_mixed, 22) == (22, self.u_mixed[:-1]))
- tools.ok_(utf8.utf8_width_chop(self.u_mixed, 19) == (18, self.u_mixed[:-4]))
- tools.ok_(utf8.utf8_width_chop(self.u_mixed, 2) == (2, self.u_mixed[0]))
- tools.ok_(utf8.utf8_width_chop(self.u_mixed, 1) == (0, u''))
+ self.assertTrue(utf8.utf8_width_chop(self.u_mixed) == (23, self.u_mixed))
+ self.assertTrue(utf8.utf8_width_chop(self.u_mixed, 23) == (23, self.u_mixed))
+ self.assertTrue(utf8.utf8_width_chop(self.u_mixed, 22) == (22, self.u_mixed[:-1]))
+ self.assertTrue(utf8.utf8_width_chop(self.u_mixed, 19) == (18, self.u_mixed[:-4]))
+ self.assertTrue(utf8.utf8_width_chop(self.u_mixed, 2) == (2, self.u_mixed[0]))
+ self.assertTrue(utf8.utf8_width_chop(self.u_mixed, 1) == (0, u''))
def test_utf8_width_fill(self):
'''Pad a utf8 string'''
- tools.ok_(utf8.utf8_width_fill(self.utf8_mixed, 1) == self.utf8_mixed)
- tools.ok_(utf8.utf8_width_fill(self.utf8_mixed, 25) == self.utf8_mixed + ' ')
- tools.ok_(utf8.utf8_width_fill(self.utf8_mixed, 25, left=False) == ' ' + self.utf8_mixed)
- tools.ok_(utf8.utf8_width_fill(self.utf8_mixed, 25, chop=18) == self.u_mixed[:-4].encode('utf8') + ' ')
- tools.ok_(utf8.utf8_width_fill(self.utf8_mixed, 25, chop=18, prefix=self.utf8_spanish, suffix=self.utf8_spanish) == self.utf8_spanish + self.u_mixed[:-4].encode('utf8') + self.utf8_spanish + ' ')
- tools.ok_(utf8.utf8_width_fill(self.utf8_mixed, 25, chop=18) == self.u_mixed[:-4].encode('utf8') + ' ')
- tools.ok_(utf8.utf8_width_fill(self.u_mixed, 25, chop=18, prefix=self.u_spanish, suffix=self.utf8_spanish) == self.u_spanish.encode('utf8') + self.u_mixed[:-4].encode('utf8') + self.u_spanish.encode('utf8') + ' ')
+ self.assertTrue(utf8.utf8_width_fill(self.utf8_mixed, 1) == self.utf8_mixed)
+ self.assertTrue(utf8.utf8_width_fill(self.utf8_mixed, 25) == self.utf8_mixed + ' ')
+ self.assertTrue(utf8.utf8_width_fill(self.utf8_mixed, 25, left=False) == ' ' + self.utf8_mixed)
+ self.assertTrue(utf8.utf8_width_fill(self.utf8_mixed, 25, chop=18) == self.u_mixed[:-4].encode('utf8') + ' ')
+ self.assertTrue(utf8.utf8_width_fill(self.utf8_mixed, 25, chop=18, prefix=self.utf8_spanish, suffix=self.utf8_spanish) == self.utf8_spanish + self.u_mixed[:-4].encode('utf8') + self.utf8_spanish + ' ')
+ self.assertTrue(utf8.utf8_width_fill(self.utf8_mixed, 25, chop=18) == self.u_mixed[:-4].encode('utf8') + ' ')
+ self.assertTrue(utf8.utf8_width_fill(self.u_mixed, 25, chop=18, prefix=self.u_spanish, suffix=self.utf8_spanish) == self.u_spanish.encode('utf8') + self.u_mixed[:-4].encode('utf8') + self.u_spanish.encode('utf8') + ' ')
pass
def test_utf8_valid(self):
'''Test that a utf8 byte sequence is validated'''
warnings.simplefilter('ignore', DeprecationWarning)
- tools.ok_(utf8.utf8_valid(self.utf8_japanese) == True)
- tools.ok_(utf8.utf8_valid(self.utf8_spanish) == True)
+ self.assertTrue(utf8.utf8_valid(self.utf8_japanese) == True)
+ self.assertTrue(utf8.utf8_valid(self.utf8_spanish) == True)
warnings.simplefilter('default', DeprecationWarning)
def test_utf8_invalid(self):
'''Test that we return False with non-utf8 chars'''
warnings.simplefilter('ignore', DeprecationWarning)
- tools.ok_(utf8.utf8_valid('\xff') == False)
- tools.ok_(utf8.utf8_valid(self.latin1_spanish) == False)
+ self.assertTrue(utf8.utf8_valid('\xff') == False)
+ self.assertTrue(utf8.utf8_valid(self.latin1_spanish) == False)
warnings.simplefilter('default', DeprecationWarning)
def test_utf8_text_wrap(self):
- tools.ok_(utf8.utf8_text_wrap(self.utf8_mixed) == [self.utf8_mixed])
- tools.ok_(utf8.utf8_text_wrap(self.utf8_paragraph) == self.utf8_paragraph_out)
- tools.ok_(utf8.utf8_text_wrap(self.utf8_mixed_para) == self.utf8_mixed_para_out)
- tools.ok_(utf8.utf8_text_wrap(self.utf8_mixed_para, width=57,
+ self.assertTrue(utf8.utf8_text_wrap(self.utf8_mixed) == [self.utf8_mixed])
+ self.assertTrue(utf8.utf8_text_wrap(self.utf8_paragraph) == self.utf8_paragraph_out)
+ self.assertTrue(utf8.utf8_text_wrap(self.utf8_mixed_para) == self.utf8_mixed_para_out)
+ self.assertTrue(utf8.utf8_text_wrap(self.utf8_mixed_para, width=57,
initial_indent=' ', subsequent_indent='----') ==
self.utf8_mixed_para_57_initial_subsequent_out)
Index: kitchen-1.2.6/kitchen2/tests/test_versioning.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test_versioning.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test_versioning.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,12 +1,13 @@
# -*- coding: utf-8 -*-
#
-from nose import tools
+
+import unittest
from kitchen.versioning import version_tuple_to_string
# Note: Using nose's generator tests for this so we can't subclass
# unittest.TestCase
-class TestVersionTuple(object):
+class TestVersionTuple(unittest.TestCase):
ver_to_tuple = {u'1': ((1,),),
u'1.0': ((1, 0),),
u'1.0.0': ((1, 0, 0),),
@@ -25,7 +26,7 @@ class TestVersionTuple(object):
}
def check_ver_tuple_to_str(self, v_tuple, v_str):
- tools.eq_(version_tuple_to_string(v_tuple), v_str)
+ self.assertEqual(version_tuple_to_string(v_tuple), v_str)
def test_version_tuple_to_string(self):
'''Test that version_tuple_to_string outputs PEP-386 compliant strings
Index: kitchen-1.2.6/kitchen3/tests/test__all__.py
===================================================================
--- kitchen-1.2.6.orig/kitchen3/tests/test__all__.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen3/tests/test__all__.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,5 +1,6 @@
# -*- coding: utf-8 -*-
-from nose import tools
+
+import unittest
import os
import types
@@ -18,7 +19,7 @@ class NoAll(RuntimeError):
class FailedImport(RuntimeError):
pass
-class Test__all__(object):
+class Test__all__(unittest.TestCase):
'''Test that every function in __all__ exists and that no public methods
are missing from __all__
'''
@@ -100,9 +101,9 @@ class Test__all__(object):
try:
try:
f = open(modpath, 'r', encoding='utf-8')
- tools.ok_('__all__' in f.read(), '%s does not contain __all__' % modpath)
+ self.assertTrue('__all__' in f.read(), '%s does not contain __all__' % modpath)
except IOError as e:
- tools.ok_(False, '%s' % e)
+ self.assertTrue(False, '%s' % e)
finally:
if f:
f.close()
@@ -131,13 +132,13 @@ class Test__all__(object):
exec('from %s.%s import *' % (modpath, modname), interior_names)
except Exception as e:
# Include the module name in the exception string
- tools.ok_(False, '__all__ failure in %s: %s: %s' % (
+ self.assertTrue(False, '__all__ failure in %s: %s: %s' % (
modname, e.__class__.__name__, e))
if '__builtins__' in interior_names:
del interior_names['__builtins__']
keys = set(interior_names)
all = set(names[modname].__all__)
- tools.ok_(keys == all)
+ self.assertTrue(keys == all)
def test_everything_in__all__exists(self):
'''
@@ -172,7 +173,7 @@ class Test__all__(object):
all = set(mod.__all__)
public = set(expected_public)
- tools.ok_(all.issuperset(public), 'These public names are not in %s.__all__: %s'
+ self.assertTrue(all.issuperset(public), 'These public names are not in %s.__all__: %s'
% (modname, ', '.join(public.difference(all))))
def test__all__is_complete(self):
Index: kitchen-1.2.6/kitchen3/tests/test_collections.py
===================================================================
--- kitchen-1.2.6.orig/kitchen3/tests/test_collections.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen3/tests/test_collections.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,28 +1,28 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
from kitchen.pycompat24.sets import add_builtin_set
add_builtin_set()
from kitchen import collections
-def test_strict_dict_get_set():
- '''Test getting and setting items in StrictDict'''
- d = collections.StrictDict()
- d['a'] = 1
- d[b'a'] = 2
- tools.assert_not_equal(d['a'], d[b'a'])
- tools.eq_(len(d), 2)
-
- d['\xf1'] = 1
- d[b'\xf1'] = 2
- d['\xf1'.encode('utf-8')] = 3
- tools.eq_(d['\xf1'], 1)
- tools.eq_(d[b'\xf1'], 2)
- tools.eq_(d['\xf1'.encode('utf-8')], 3)
- tools.eq_(len(d), 5)
+class TestStrictDictGetSet(unittest.TestCase):
+ def test_strict_dict_get_set(self):
+ '''Test getting and setting items in StrictDict'''
+ d = collections.StrictDict()
+ d['a'] = 1
+ d[b'a'] = 2
+ self.assertNotEqual(d['a'], d[b'a'])
+ self.assertEqual(len(d), 2)
+
+ d['\xf1'] = 1
+ d[b'\xf1'] = 2
+ d['\xf1'.encode('utf-8')] = 3
+ self.assertEqual(d['\xf1'], 1)
+ self.assertEqual(d[b'\xf1'], 2)
+ self.assertEqual(d['\xf1'.encode('utf-8')], 3)
+ self.assertEqual(len(d), 5)
class TestStrictDict(unittest.TestCase):
def setUp(self):
@@ -94,66 +94,66 @@ class TestStrictDict(unittest.TestCase):
def test__compare_list(self):
'''*sigh* this test support function is so complex we need to test it'''
- tools.ok_(self._compare_lists(['a', 'b', 'c'], ['c', 'a', 'b']))
- tools.ok_(not self._compare_lists(['b', 'c'], ['c', 'a', 'b']))
- tools.ok_(not self._compare_lists([b'a', 'b'], ['a', 'b']))
- tools.ok_(not self._compare_lists(['a', b'b'], [b'a', 'b']))
- tools.ok_(self._compare_lists(['a', 'b', 1], ['a', 1, 'b']))
- tools.ok_(self._compare_lists([b'a', b'b'], [b'a', b'b']))
- tools.ok_(self._compare_lists([b'a', 'b'], [b'a', 'b']))
- tools.ok_(not self._compare_lists([b'a', 'b'], [b'a', b'b']))
- tools.ok_(self._compare_lists([b'a', 'b', 'b', 'c', b'a'], [b'a', b'a', 'b', 'c', 'b']))
- tools.ok_(not self._compare_lists([b'a', 'b', 'b', 'c', 'a'], [b'a', b'a', 'b', 'c', 'b']))
- tools.ok_(not self._compare_lists([b'a', 'b', 'b', 'c', b'a'], [b'a', 'b', 'b', 'c', 'b']))
+ self.assertTrue(self._compare_lists(['a', 'b', 'c'], ['c', 'a', 'b']))
+ self.assertTrue(not self._compare_lists(['b', 'c'], ['c', 'a', 'b']))
+ self.assertTrue(not self._compare_lists([b'a', 'b'], ['a', 'b']))
+ self.assertTrue(not self._compare_lists(['a', b'b'], [b'a', 'b']))
+ self.assertTrue(self._compare_lists(['a', 'b', 1], ['a', 1, 'b']))
+ self.assertTrue(self._compare_lists([b'a', b'b'], [b'a', b'b']))
+ self.assertTrue(self._compare_lists([b'a', 'b'], [b'a', 'b']))
+ self.assertTrue(not self._compare_lists([b'a', 'b'], [b'a', b'b']))
+ self.assertTrue(self._compare_lists([b'a', 'b', 'b', 'c', b'a'], [b'a', b'a', 'b', 'c', 'b']))
+ self.assertTrue(not self._compare_lists([b'a', 'b', 'b', 'c', 'a'], [b'a', b'a', 'b', 'c', 'b']))
+ self.assertTrue(not self._compare_lists([b'a', 'b', 'b', 'c', b'a'], [b'a', 'b', 'b', 'c', 'b']))
def test_strict_dict_len(self):
'''StrictDict len'''
- tools.eq_(len(self.d), 5)
+ self.assertEqual(len(self.d), 5)
def test_strict_dict_del(self):
'''StrictDict del'''
- tools.eq_(len(self.d), 5)
+ self.assertEqual(len(self.d), 5)
del(self.d['\xf1'])
- tools.assert_raises(KeyError, self.d.__getitem__, '\xf1')
- tools.eq_(len(self.d), 4)
+ self.assertRaises(KeyError, self.d.__getitem__, '\xf1')
+ self.assertEqual(len(self.d), 4)
def test_strict_dict_iter(self):
'''StrictDict iteration'''
keys = []
for k in self.d:
keys.append(k)
- tools.ok_(self._compare_lists(keys, self.keys),
+ self.assertTrue(self._compare_lists(keys, self.keys),
msg='keys != self.key: %s != %s' % (keys, self.keys))
keys = []
for k in self.d.keys():
keys.append(k)
- tools.ok_(self._compare_lists(keys, self.keys),
+ self.assertTrue(self._compare_lists(keys, self.keys),
msg='keys != self.key: %s != %s' % (keys, self.keys))
keys = [k for k in self.d]
- tools.ok_(self._compare_lists(keys, self.keys),
+ self.assertTrue(self._compare_lists(keys, self.keys),
msg='keys != self.key: %s != %s' % (keys, self.keys))
keys = []
for k in list(self.d.keys()):
keys.append(k)
- tools.ok_(self._compare_lists(keys, self.keys),
+ self.assertTrue(self._compare_lists(keys, self.keys),
msg='keys != self.key: %s != %s' % (keys, self.keys))
def test_strict_dict_contains(self):
'''StrictDict contains function'''
- tools.ok_(b'b' not in self.d)
- tools.ok_('b' not in self.d)
- tools.ok_(b'\xf1' in self.d)
- tools.ok_('\xf1' in self.d)
- tools.ok_(b'a' in self.d)
- tools.ok_('a' in self.d)
+ self.assertTrue(b'b' not in self.d)
+ self.assertTrue('b' not in self.d)
+ self.assertTrue(b'\xf1' in self.d)
+ self.assertTrue('\xf1' in self.d)
+ self.assertTrue(b'a' in self.d)
+ self.assertTrue('a' in self.d)
del(self.d['\xf1'])
- tools.ok_('\xf1' not in self.d)
- tools.ok_(b'\xf1' in self.d)
+ self.assertTrue('\xf1' not in self.d)
+ self.assertTrue(b'\xf1' in self.d)
del(self.d[b'a'])
- tools.ok_('a' in self.d)
- tools.ok_(b'a' not in self.d)
+ self.assertTrue('a' in self.d)
+ self.assertTrue(b'a' not in self.d)
Index: kitchen-1.2.6/kitchen3/tests/test_converters.py
===================================================================
--- kitchen-1.2.6.orig/kitchen3/tests/test_converters.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen3/tests/test_converters.py 2020-09-09 14:50:38.670660921 +0200
@@ -2,8 +2,6 @@
#
import unittest
-from nose import tools
-from nose.plugins.skip import SkipTest
import io
import sys
@@ -49,98 +47,98 @@ class ReprUnicode(object):
class TestConverters(unittest.TestCase, base_classes.UnicodeTestData):
def test_to_unicode(self):
'''Test to_unicode when the user gives good values'''
- tools.eq_(converters.to_unicode(self.u_japanese, encoding='latin1'), self.u_japanese)
+ self.assertEqual(converters.to_unicode(self.u_japanese, encoding='latin1'), self.u_japanese)
- tools.eq_(converters.to_unicode(self.utf8_spanish), self.u_spanish)
- tools.eq_(converters.to_unicode(self.utf8_japanese), self.u_japanese)
+ self.assertEqual(converters.to_unicode(self.utf8_spanish), self.u_spanish)
+ self.assertEqual(converters.to_unicode(self.utf8_japanese), self.u_japanese)
- tools.eq_(converters.to_unicode(self.latin1_spanish, encoding='latin1'), self.u_spanish)
- tools.eq_(converters.to_unicode(self.euc_jp_japanese, encoding='euc_jp'), self.u_japanese)
+ self.assertEqual(converters.to_unicode(self.latin1_spanish, encoding='latin1'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(self.euc_jp_japanese, encoding='euc_jp'), self.u_japanese)
- tools.assert_raises(TypeError, converters.to_unicode, *[5], **{'nonstring': 'foo'})
+ self.assertRaises(TypeError, converters.to_unicode, *[5], **{'nonstring': 'foo'})
def test_to_unicode_errors(self):
- tools.eq_(converters.to_unicode(self.latin1_spanish), self.u_mangled_spanish_latin1_as_utf8)
- tools.eq_(converters.to_unicode(self.latin1_spanish, errors='ignore'), self.u_spanish_ignore)
- tools.assert_raises(UnicodeDecodeError, converters.to_unicode,
+ self.assertEqual(converters.to_unicode(self.latin1_spanish), self.u_mangled_spanish_latin1_as_utf8)
+ self.assertEqual(converters.to_unicode(self.latin1_spanish, errors='ignore'), self.u_spanish_ignore)
+ self.assertRaises(UnicodeDecodeError, converters.to_unicode,
*[self.latin1_spanish], **{'errors': 'strict'})
def test_to_unicode_nonstring(self):
- tools.eq_(converters.to_unicode(5), '5')
- tools.eq_(converters.to_unicode(5, nonstring='empty'), '')
- tools.eq_(converters.to_unicode(5, nonstring='passthru'), 5)
- tools.eq_(converters.to_unicode(5, nonstring='simplerepr'), '5')
- tools.eq_(converters.to_unicode(5, nonstring='repr'), '5')
- tools.assert_raises(TypeError, converters.to_unicode, *[5], **{'nonstring': 'strict'})
+ self.assertEqual(converters.to_unicode(5), '5')
+ self.assertEqual(converters.to_unicode(5, nonstring='empty'), '')
+ self.assertEqual(converters.to_unicode(5, nonstring='passthru'), 5)
+ self.assertEqual(converters.to_unicode(5, nonstring='simplerepr'), '5')
+ self.assertEqual(converters.to_unicode(5, nonstring='repr'), '5')
+ self.assertRaises(TypeError, converters.to_unicode, *[5], **{'nonstring': 'strict'})
obj_repr = converters.to_unicode(object, nonstring='simplerepr')
- tools.eq_(obj_repr, "<class 'object'>")
- tools.assert_true(isinstance(obj_repr, str))
+ self.assertEqual(obj_repr, "<class 'object'>")
+ self.assertTrue(isinstance(obj_repr, str))
def test_to_unicode_nonstring_with_objects_that_have__unicode__and__str__(self):
'''Test that to_unicode handles objects that have __unicode__ and __str__ methods'''
if sys.version_info < (3, 0):
# None of these apply on python3 because python3 does not use __unicode__
# and it enforces __str__ returning str
- tools.eq_(converters.to_unicode(UnicodeNoStr(), nonstring='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(StrNoUnicode(), nonstring='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(UnicodeReturnsStr(), nonstring='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(UnicodeNoStr(), nonstring='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(StrNoUnicode(), nonstring='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(UnicodeReturnsStr(), nonstring='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(StrReturnsUnicode(), nonstring='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(UnicodeStrCrossed(), nonstring='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(StrReturnsUnicode(), nonstring='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(UnicodeStrCrossed(), nonstring='simplerepr'), self.u_spanish)
def test_to_bytes(self):
'''Test to_bytes when the user gives good values'''
- tools.eq_(converters.to_bytes(self.utf8_japanese, encoding='latin1'), self.utf8_japanese)
+ self.assertEqual(converters.to_bytes(self.utf8_japanese, encoding='latin1'), self.utf8_japanese)
- tools.eq_(converters.to_bytes(self.u_spanish), self.utf8_spanish)
- tools.eq_(converters.to_bytes(self.u_japanese), self.utf8_japanese)
+ self.assertEqual(converters.to_bytes(self.u_spanish), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(self.u_japanese), self.utf8_japanese)
- tools.eq_(converters.to_bytes(self.u_spanish, encoding='latin1'), self.latin1_spanish)
- tools.eq_(converters.to_bytes(self.u_japanese, encoding='euc_jp'), self.euc_jp_japanese)
+ self.assertEqual(converters.to_bytes(self.u_spanish, encoding='latin1'), self.latin1_spanish)
+ self.assertEqual(converters.to_bytes(self.u_japanese, encoding='euc_jp'), self.euc_jp_japanese)
def test_to_bytes_errors(self):
- tools.eq_(converters.to_bytes(self.u_mixed, encoding='latin1'),
+ self.assertEqual(converters.to_bytes(self.u_mixed, encoding='latin1'),
self.latin1_mixed_replace)
- tools.eq_(converters.to_bytes(self.u_mixed, encoding='latin',
+ self.assertEqual(converters.to_bytes(self.u_mixed, encoding='latin',
errors='ignore'), self.latin1_mixed_ignore)
- tools.assert_raises(UnicodeEncodeError, converters.to_bytes,
+ self.assertRaises(UnicodeEncodeError, converters.to_bytes,
*[self.u_mixed], **{'errors': 'strict', 'encoding': 'latin1'})
def _check_repr_bytes(self, repr_string, obj_name):
- tools.assert_true(isinstance(repr_string, bytes))
+ self.assertTrue(isinstance(repr_string, bytes))
match = self.repr_re.match(repr_string)
- tools.assert_not_equal(match, None)
- tools.eq_(match.groups()[0], obj_name)
+ self.assertNotEqual(match, None)
+ self.assertEqual(match.groups()[0], obj_name)
def test_to_bytes_nonstring(self):
- tools.eq_(converters.to_bytes(5), b'5')
- tools.eq_(converters.to_bytes(5, nonstring='empty'), b'')
- tools.eq_(converters.to_bytes(5, nonstring='passthru'), 5)
- tools.eq_(converters.to_bytes(5, nonstring='simplerepr'), b'5')
- tools.eq_(converters.to_bytes(5, nonstring='repr'), b'5')
+ self.assertEqual(converters.to_bytes(5), b'5')
+ self.assertEqual(converters.to_bytes(5, nonstring='empty'), b'')
+ self.assertEqual(converters.to_bytes(5, nonstring='passthru'), 5)
+ self.assertEqual(converters.to_bytes(5, nonstring='simplerepr'), b'5')
+ self.assertEqual(converters.to_bytes(5, nonstring='repr'), b'5')
# Raise a TypeError if the msg is nonstring and we're set to strict
- tools.assert_raises(TypeError, converters.to_bytes, *[5], **{'nonstring': 'strict'})
+ self.assertRaises(TypeError, converters.to_bytes, *[5], **{'nonstring': 'strict'})
# Raise a TypeError if given an invalid nonstring arg
- tools.assert_raises(TypeError, converters.to_bytes, *[5], **{'nonstring': 'INVALID'})
+ self.assertRaises(TypeError, converters.to_bytes, *[5], **{'nonstring': 'INVALID'})
obj_repr = converters.to_bytes(object, nonstring='simplerepr')
- tools.eq_(obj_repr, b"<class 'object'>")
- tools.assert_true(isinstance(obj_repr, bytes))
+ self.assertEqual(obj_repr, b"<class 'object'>")
+ self.assertTrue(isinstance(obj_repr, bytes))
def test_to_bytes_nonstring_with_objects_that_have__unicode__and__str__(self):
if sys.version_info < (3, 0):
# This object's _str__ returns a utf8 encoded object
- tools.eq_(converters.to_bytes(StrNoUnicode(), nonstring='simplerepr'), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(StrNoUnicode(), nonstring='simplerepr'), self.utf8_spanish)
# No __str__ method so this returns repr
string = converters.to_bytes(UnicodeNoStr(), nonstring='simplerepr')
self._check_repr_bytes(string, b'UnicodeNoStr')
# This object's __str__ returns unicode which to_bytes converts to utf8
- tools.eq_(converters.to_bytes(StrReturnsUnicode(), nonstring='simplerepr'), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(StrReturnsUnicode(), nonstring='simplerepr'), self.utf8_spanish)
# Unless we explicitly ask for something different
- tools.eq_(converters.to_bytes(StrReturnsUnicode(),
+ self.assertEqual(converters.to_bytes(StrReturnsUnicode(),
nonstring='simplerepr', encoding='latin1'), self.latin1_spanish)
# This object has no __str__ so it returns repr
@@ -148,79 +146,79 @@ class TestConverters(unittest.TestCase,
self._check_repr_bytes(string, b'UnicodeReturnsStr')
# This object's __str__ returns unicode which to_bytes converts to utf8
- tools.eq_(converters.to_bytes(UnicodeStrCrossed(), nonstring='simplerepr'), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(UnicodeStrCrossed(), nonstring='simplerepr'), self.utf8_spanish)
# This object's __repr__ returns unicode which to_bytes converts to utf8
- tools.eq_(converters.to_bytes(ReprUnicode(), nonstring='simplerepr'),
+ self.assertEqual(converters.to_bytes(ReprUnicode(), nonstring='simplerepr'),
'ReprUnicode(El veloz murciélago saltó sobre el perro perezoso.)'.encode('utf8'))
- tools.eq_(converters.to_bytes(ReprUnicode(), nonstring='repr'),
+ self.assertEqual(converters.to_bytes(ReprUnicode(), nonstring='repr'),
'ReprUnicode(El veloz murciélago saltó sobre el perro perezoso.)'.encode('utf8'))
def test_unicode_to_xml(self):
- tools.eq_(converters.unicode_to_xml(None), b'')
- tools.assert_raises(XmlEncodeError, converters.unicode_to_xml, *[b'byte string'])
- tools.assert_raises(ValueError, converters.unicode_to_xml, *['string'], **{'control_chars': 'foo'})
- tools.assert_raises(XmlEncodeError, converters.unicode_to_xml,
+ self.assertEqual(converters.unicode_to_xml(None), b'')
+ self.assertRaises(XmlEncodeError, converters.unicode_to_xml, *[b'byte string'])
+ self.assertRaises(ValueError, converters.unicode_to_xml, *['string'], **{'control_chars': 'foo'})
+ self.assertRaises(XmlEncodeError, converters.unicode_to_xml,
*['string\u0002'], **{'control_chars': 'strict'})
- tools.eq_(converters.unicode_to_xml(self.u_entity), self.utf8_entity_escape)
- tools.eq_(converters.unicode_to_xml(self.u_entity, attrib=True), self.utf8_attrib_escape)
- tools.eq_(converters.unicode_to_xml(self.u_entity, encoding='ascii'), self.ascii_entity_escape)
- tools.eq_(converters.unicode_to_xml(self.u_entity, encoding='ascii', attrib=True), self.ascii_attrib_escape)
+ self.assertEqual(converters.unicode_to_xml(self.u_entity), self.utf8_entity_escape)
+ self.assertEqual(converters.unicode_to_xml(self.u_entity, attrib=True), self.utf8_attrib_escape)
+ self.assertEqual(converters.unicode_to_xml(self.u_entity, encoding='ascii'), self.ascii_entity_escape)
+ self.assertEqual(converters.unicode_to_xml(self.u_entity, encoding='ascii', attrib=True), self.ascii_attrib_escape)
def test_xml_to_unicode(self):
- tools.eq_(converters.xml_to_unicode(self.utf8_entity_escape, 'utf8', 'replace'), self.u_entity)
- tools.eq_(converters.xml_to_unicode(self.utf8_attrib_escape, 'utf8', 'replace'), self.u_entity)
- tools.eq_(converters.xml_to_unicode(self.ascii_entity_escape, 'ascii', 'replace'), self.u_entity)
- tools.eq_(converters.xml_to_unicode(self.ascii_attrib_escape, 'ascii', 'replace'), self.u_entity)
+ self.assertEqual(converters.xml_to_unicode(self.utf8_entity_escape, 'utf8', 'replace'), self.u_entity)
+ self.assertEqual(converters.xml_to_unicode(self.utf8_attrib_escape, 'utf8', 'replace'), self.u_entity)
+ self.assertEqual(converters.xml_to_unicode(self.ascii_entity_escape, 'ascii', 'replace'), self.u_entity)
+ self.assertEqual(converters.xml_to_unicode(self.ascii_attrib_escape, 'ascii', 'replace'), self.u_entity)
def test_xml_to_byte_string(self):
- tools.eq_(converters.xml_to_byte_string(self.utf8_entity_escape, 'utf8', 'replace'), self.u_entity.encode('utf8'))
- tools.eq_(converters.xml_to_byte_string(self.utf8_attrib_escape, 'utf8', 'replace'), self.u_entity.encode('utf8'))
- tools.eq_(converters.xml_to_byte_string(self.ascii_entity_escape, 'ascii', 'replace'), self.u_entity.encode('utf8'))
- tools.eq_(converters.xml_to_byte_string(self.ascii_attrib_escape, 'ascii', 'replace'), self.u_entity.encode('utf8'))
+ self.assertEqual(converters.xml_to_byte_string(self.utf8_entity_escape, 'utf8', 'replace'), self.u_entity.encode('utf8'))
+ self.assertEqual(converters.xml_to_byte_string(self.utf8_attrib_escape, 'utf8', 'replace'), self.u_entity.encode('utf8'))
+ self.assertEqual(converters.xml_to_byte_string(self.ascii_entity_escape, 'ascii', 'replace'), self.u_entity.encode('utf8'))
+ self.assertEqual(converters.xml_to_byte_string(self.ascii_attrib_escape, 'ascii', 'replace'), self.u_entity.encode('utf8'))
- tools.eq_(converters.xml_to_byte_string(self.utf8_attrib_escape,
+ self.assertEqual(converters.xml_to_byte_string(self.utf8_attrib_escape,
output_encoding='euc_jp', errors='replace'),
self.u_entity.encode('euc_jp', 'replace'))
- tools.eq_(converters.xml_to_byte_string(self.utf8_attrib_escape,
+ self.assertEqual(converters.xml_to_byte_string(self.utf8_attrib_escape,
output_encoding='latin1', errors='replace'),
self.u_entity.encode('latin1', 'replace'))
- tools.eq_(converters.xml_to_byte_string(self.ascii_attrib_escape,
+ self.assertEqual(converters.xml_to_byte_string(self.ascii_attrib_escape,
output_encoding='euc_jp', errors='replace'),
self.u_entity.encode('euc_jp', 'replace'))
- tools.eq_(converters.xml_to_byte_string(self.ascii_attrib_escape,
+ self.assertEqual(converters.xml_to_byte_string(self.ascii_attrib_escape,
output_encoding='latin1', errors='replace'),
self.u_entity.encode('latin1', 'replace'))
def test_byte_string_to_xml(self):
- tools.assert_raises(XmlEncodeError, converters.byte_string_to_xml, *['test'])
- tools.eq_(converters.byte_string_to_xml(self.utf8_entity), self.utf8_entity_escape)
- tools.eq_(converters.byte_string_to_xml(self.utf8_entity, attrib=True), self.utf8_attrib_escape)
+ self.assertRaises(XmlEncodeError, converters.byte_string_to_xml, *['test'])
+ self.assertEqual(converters.byte_string_to_xml(self.utf8_entity), self.utf8_entity_escape)
+ self.assertEqual(converters.byte_string_to_xml(self.utf8_entity, attrib=True), self.utf8_attrib_escape)
def test_bytes_to_xml(self):
- tools.eq_(converters.bytes_to_xml(self.b_byte_chars), self.b_byte_encoded)
+ self.assertEqual(converters.bytes_to_xml(self.b_byte_chars), self.b_byte_encoded)
def test_xml_to_bytes(self):
- tools.eq_(converters.xml_to_bytes(self.b_byte_encoded), self.b_byte_chars)
+ self.assertEqual(converters.xml_to_bytes(self.b_byte_encoded), self.b_byte_chars)
def test_guess_encoding_to_xml(self):
- tools.eq_(converters.guess_encoding_to_xml(self.u_entity), self.utf8_entity_escape)
- tools.eq_(converters.guess_encoding_to_xml(self.utf8_spanish), self.utf8_spanish)
- tools.eq_(converters.guess_encoding_to_xml(self.latin1_spanish), self.utf8_spanish)
- tools.eq_(converters.guess_encoding_to_xml(self.utf8_japanese), self.utf8_japanese)
+ self.assertEqual(converters.guess_encoding_to_xml(self.u_entity), self.utf8_entity_escape)
+ self.assertEqual(converters.guess_encoding_to_xml(self.utf8_spanish), self.utf8_spanish)
+ self.assertEqual(converters.guess_encoding_to_xml(self.latin1_spanish), self.utf8_spanish)
+ self.assertEqual(converters.guess_encoding_to_xml(self.utf8_japanese), self.utf8_japanese)
def test_guess_encoding_to_xml_euc_japanese(self):
if chardet:
- tools.eq_(converters.guess_encoding_to_xml(self.euc_jp_japanese),
+ self.assertEqual(converters.guess_encoding_to_xml(self.euc_jp_japanese),
self.utf8_japanese)
else:
- raise SkipTest('chardet not installed, euc_japanese won\'t be detected')
+ self.skipTest('chardet not installed, euc_japanese won\'t be detected')
def test_guess_encoding_to_xml_euc_japanese_mangled(self):
if chardet:
- raise SkipTest('chardet installed, euc_japanese won\'t be mangled')
+ self.skipTest('chardet installed, euc_japanese won\'t be mangled')
else:
- tools.eq_(converters.guess_encoding_to_xml(self.euc_jp_japanese),
+ self.assertEqual(converters.guess_encoding_to_xml(self.euc_jp_japanese),
self.utf8_mangled_euc_jp_as_latin1)
class TestGetWriter(unittest.TestCase, base_classes.UnicodeTestData):
@@ -233,27 +231,27 @@ class TestGetWriter(unittest.TestCase, b
io.write(self.u_japanese + '\n')
io.seek(0)
result = io.read().strip()
- tools.eq_(result, self.utf8_japanese)
+ self.assertEqual(result, self.utf8_japanese)
io.seek(0)
io.truncate(0)
io.write(self.euc_jp_japanese + b'\n')
io.seek(0)
result = io.read().strip()
- tools.eq_(result, self.euc_jp_japanese)
+ self.assertEqual(result, self.euc_jp_japanese)
io.seek(0)
io.truncate(0)
io.write(self.utf8_japanese + b'\n')
io.seek(0)
result = io.read().strip()
- tools.eq_(result, self.utf8_japanese)
+ self.assertEqual(result, self.utf8_japanese)
def test_error_handlers(self):
'''Test setting alternate error handlers'''
writer = converters.getwriter('latin1')
io = writer(self.io, errors='strict')
- tools.assert_raises(UnicodeEncodeError, io.write, self.u_japanese)
+ self.assertRaises(UnicodeEncodeError, io.write, self.u_japanese)
class TestExceptionConverters(unittest.TestCase, base_classes.UnicodeTestData):
@@ -273,61 +271,61 @@ class TestExceptionConverters(unittest.T
pass
def test_exception_to_unicode_with_unicode(self):
- tools.eq_(converters.exception_to_unicode(self.exceptions['u_jpn']), self.u_japanese)
- tools.eq_(converters.exception_to_unicode(self.exceptions['u_spanish']), self.u_spanish)
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['u_jpn']), self.u_japanese)
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['u_spanish']), self.u_spanish)
def test_exception_to_unicode_with_bytes(self):
- tools.eq_(converters.exception_to_unicode(self.exceptions['utf8_jpn']), self.u_japanese)
- tools.eq_(converters.exception_to_unicode(self.exceptions['utf8_spanish']), self.u_spanish)
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['utf8_jpn']), self.u_japanese)
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['utf8_spanish']), self.u_spanish)
# Mangled latin1/utf8 conversion but no tracebacks
- tools.eq_(converters.exception_to_unicode(self.exceptions['latin1_spanish']), self.u_mangled_spanish_latin1_as_utf8)
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['latin1_spanish']), self.u_mangled_spanish_latin1_as_utf8)
# Mangled euc_jp/utf8 conversion but no tracebacks
- tools.eq_(converters.exception_to_unicode(self.exceptions['euc_jpn']), self.u_mangled_euc_jp_as_utf8)
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['euc_jpn']), self.u_mangled_euc_jp_as_utf8)
def test_exception_to_unicode_custom(self):
# If given custom functions, then we should not mangle
c = [lambda e: converters.to_unicode(e.args[0], encoding='euc_jp'),
lambda e: converters.to_unicode(e, encoding='euc_jp')]
- tools.eq_(converters.exception_to_unicode(self.exceptions['euc_jpn'],
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['euc_jpn'],
converters=c), self.u_japanese)
c.extend(converters.EXCEPTION_CONVERTERS)
- tools.eq_(converters.exception_to_unicode(self.exceptions['euc_jpn'],
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['euc_jpn'],
converters=c), self.u_japanese)
c = [lambda e: converters.to_unicode(e.args[0], encoding='latin1'),
lambda e: converters.to_unicode(e, encoding='latin1')]
- tools.eq_(converters.exception_to_unicode(self.exceptions['latin1_spanish'],
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['latin1_spanish'],
converters=c), self.u_spanish)
c.extend(converters.EXCEPTION_CONVERTERS)
- tools.eq_(converters.exception_to_unicode(self.exceptions['latin1_spanish'],
+ self.assertEqual(converters.exception_to_unicode(self.exceptions['latin1_spanish'],
converters=c), self.u_spanish)
def test_exception_to_bytes_with_unicode(self):
- tools.eq_(converters.exception_to_bytes(self.exceptions['u_jpn']), self.utf8_japanese)
- tools.eq_(converters.exception_to_bytes(self.exceptions['u_spanish']), self.utf8_spanish)
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['u_jpn']), self.utf8_japanese)
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['u_spanish']), self.utf8_spanish)
def test_exception_to_bytes_with_bytes(self):
- tools.eq_(converters.exception_to_bytes(self.exceptions['utf8_jpn']), self.utf8_japanese)
- tools.eq_(converters.exception_to_bytes(self.exceptions['utf8_spanish']), self.utf8_spanish)
- tools.eq_(converters.exception_to_bytes(self.exceptions['latin1_spanish']), self.latin1_spanish)
- tools.eq_(converters.exception_to_bytes(self.exceptions['euc_jpn']), self.euc_jp_japanese)
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['utf8_jpn']), self.utf8_japanese)
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['utf8_spanish']), self.utf8_spanish)
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['latin1_spanish']), self.latin1_spanish)
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['euc_jpn']), self.euc_jp_japanese)
def test_exception_to_bytes_custom(self):
# If given custom functions, then we should not mangle
c = [lambda e: converters.to_bytes(e.args[0], encoding='euc_jp'),
lambda e: converters.to_bytes(e, encoding='euc_jp')]
- tools.eq_(converters.exception_to_bytes(self.exceptions['euc_jpn'],
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['euc_jpn'],
converters=c), self.euc_jp_japanese)
c.extend(converters.EXCEPTION_CONVERTERS)
- tools.eq_(converters.exception_to_bytes(self.exceptions['euc_jpn'],
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['euc_jpn'],
converters=c), self.euc_jp_japanese)
c = [lambda e: converters.to_bytes(e.args[0], encoding='latin1'),
lambda e: converters.to_bytes(e, encoding='latin1')]
- tools.eq_(converters.exception_to_bytes(self.exceptions['latin1_spanish'],
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['latin1_spanish'],
converters=c), self.latin1_spanish)
c.extend(converters.EXCEPTION_CONVERTERS)
- tools.eq_(converters.exception_to_bytes(self.exceptions['latin1_spanish'],
+ self.assertEqual(converters.exception_to_bytes(self.exceptions['latin1_spanish'],
converters=c), self.latin1_spanish)
@@ -339,53 +337,53 @@ class TestDeprecatedConverters(TestConve
warnings.simplefilter('default', DeprecationWarning)
def test_to_xml(self):
- tools.eq_(converters.to_xml(self.u_entity), self.utf8_entity_escape)
- tools.eq_(converters.to_xml(self.utf8_spanish), self.utf8_spanish)
- tools.eq_(converters.to_xml(self.latin1_spanish), self.utf8_spanish)
- tools.eq_(converters.to_xml(self.utf8_japanese), self.utf8_japanese)
+ self.assertEqual(converters.to_xml(self.u_entity), self.utf8_entity_escape)
+ self.assertEqual(converters.to_xml(self.utf8_spanish), self.utf8_spanish)
+ self.assertEqual(converters.to_xml(self.latin1_spanish), self.utf8_spanish)
+ self.assertEqual(converters.to_xml(self.utf8_japanese), self.utf8_japanese)
def test_to_utf8(self):
- tools.eq_(converters.to_utf8(self.u_japanese), self.utf8_japanese)
- tools.eq_(converters.to_utf8(self.utf8_spanish), self.utf8_spanish)
+ self.assertEqual(converters.to_utf8(self.u_japanese), self.utf8_japanese)
+ self.assertEqual(converters.to_utf8(self.utf8_spanish), self.utf8_spanish)
def test_to_str(self):
- tools.eq_(converters.to_str(self.u_japanese), self.utf8_japanese)
- tools.eq_(converters.to_str(self.utf8_spanish), self.utf8_spanish)
- tools.eq_(converters.to_str(object), b"<class 'object'>")
+ self.assertEqual(converters.to_str(self.u_japanese), self.utf8_japanese)
+ self.assertEqual(converters.to_str(self.utf8_spanish), self.utf8_spanish)
+ self.assertEqual(converters.to_str(object), b"<class 'object'>")
def test_non_string(self):
'''Test deprecated non_string parameter'''
# unicode
- tools.assert_raises(TypeError, converters.to_unicode, *[5], **{'non_string': 'foo'})
- tools.eq_(converters.to_unicode(5, non_string='empty'), '')
- tools.eq_(converters.to_unicode(5, non_string='passthru'), 5)
- tools.eq_(converters.to_unicode(5, non_string='simplerepr'), '5')
- tools.eq_(converters.to_unicode(5, non_string='repr'), '5')
- tools.assert_raises(TypeError, converters.to_unicode, *[5], **{'non_string': 'strict'})
+ self.assertRaises(TypeError, converters.to_unicode, *[5], **{'non_string': 'foo'})
+ self.assertEqual(converters.to_unicode(5, non_string='empty'), '')
+ self.assertEqual(converters.to_unicode(5, non_string='passthru'), 5)
+ self.assertEqual(converters.to_unicode(5, non_string='simplerepr'), '5')
+ self.assertEqual(converters.to_unicode(5, non_string='repr'), '5')
+ self.assertRaises(TypeError, converters.to_unicode, *[5], **{'non_string': 'strict'})
- tools.eq_(converters.to_unicode(StrReturnsUnicode(), non_string='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(UnicodeStrCrossed(), non_string='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(StrReturnsUnicode(), non_string='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(UnicodeStrCrossed(), non_string='simplerepr'), self.u_spanish)
if sys.version_info < (3, 0):
# Not applicable on python3
- tools.eq_(converters.to_unicode(UnicodeNoStr(), non_string='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(StrNoUnicode(), non_string='simplerepr'), self.u_spanish)
- tools.eq_(converters.to_unicode(UnicodeReturnsStr(), non_string='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(UnicodeNoStr(), non_string='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(StrNoUnicode(), non_string='simplerepr'), self.u_spanish)
+ self.assertEqual(converters.to_unicode(UnicodeReturnsStr(), non_string='simplerepr'), self.u_spanish)
obj_repr = converters.to_unicode(object, non_string='simplerepr')
- tools.eq_(obj_repr, "<class 'object'>")
- tools.assert_true(isinstance(obj_repr, str))
+ self.assertEqual(obj_repr, "<class 'object'>")
+ self.assertTrue(isinstance(obj_repr, str))
# Bytes
- tools.eq_(converters.to_bytes(5), b'5')
- tools.eq_(converters.to_bytes(5, non_string='empty'), b'')
- tools.eq_(converters.to_bytes(5, non_string='passthru'), 5)
- tools.eq_(converters.to_bytes(5, non_string='simplerepr'), b'5')
- tools.eq_(converters.to_bytes(5, non_string='repr'), b'5')
+ self.assertEqual(converters.to_bytes(5), b'5')
+ self.assertEqual(converters.to_bytes(5, non_string='empty'), b'')
+ self.assertEqual(converters.to_bytes(5, non_string='passthru'), 5)
+ self.assertEqual(converters.to_bytes(5, non_string='simplerepr'), b'5')
+ self.assertEqual(converters.to_bytes(5, non_string='repr'), b'5')
# Raise a TypeError if the msg is non_string and we're set to strict
- tools.assert_raises(TypeError, converters.to_bytes, *[5], **{'non_string': 'strict'})
+ self.assertRaises(TypeError, converters.to_bytes, *[5], **{'non_string': 'strict'})
# Raise a TypeError if given an invalid non_string arg
- tools.assert_raises(TypeError, converters.to_bytes, *[5], **{'non_string': 'INVALID'})
+ self.assertRaises(TypeError, converters.to_bytes, *[5], **{'non_string': 'INVALID'})
# No __str__ method so this returns repr
string = converters.to_bytes(UnicodeNoStr(), non_string='simplerepr')
@@ -394,12 +392,12 @@ class TestDeprecatedConverters(TestConve
if sys.version_info < (3, 0):
# Not applicable on python3
# This object's _str__ returns a utf8 encoded object
- tools.eq_(converters.to_bytes(StrNoUnicode(), non_string='simplerepr'), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(StrNoUnicode(), non_string='simplerepr'), self.utf8_spanish)
# This object's __str__ returns unicode which to_bytes converts to utf8
- tools.eq_(converters.to_bytes(StrReturnsUnicode(), non_string='simplerepr'), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(StrReturnsUnicode(), non_string='simplerepr'), self.utf8_spanish)
# Unless we explicitly ask for something different
- tools.eq_(converters.to_bytes(StrReturnsUnicode(),
+ self.assertEqual(converters.to_bytes(StrReturnsUnicode(),
non_string='simplerepr', encoding='latin1'), self.latin1_spanish)
# This object has no __str__ so it returns repr
@@ -407,14 +405,14 @@ class TestDeprecatedConverters(TestConve
self._check_repr_bytes(string, b'UnicodeReturnsStr')
# This object's __str__ returns unicode which to_bytes converts to utf8
- tools.eq_(converters.to_bytes(UnicodeStrCrossed(), non_string='simplerepr'), self.utf8_spanish)
+ self.assertEqual(converters.to_bytes(UnicodeStrCrossed(), non_string='simplerepr'), self.utf8_spanish)
# This object's __repr__ returns unicode which to_bytes converts to utf8
- tools.eq_(converters.to_bytes(ReprUnicode(), non_string='simplerepr'),
+ self.assertEqual(converters.to_bytes(ReprUnicode(), non_string='simplerepr'),
'ReprUnicode(El veloz murciélago saltó sobre el perro perezoso.)'.encode('utf8'))
- tools.eq_(converters.to_bytes(ReprUnicode(), non_string='repr'),
+ self.assertEqual(converters.to_bytes(ReprUnicode(), non_string='repr'),
'ReprUnicode(El veloz murciélago saltó sobre el perro perezoso.)'.encode('utf8'))
obj_repr = converters.to_bytes(object, non_string='simplerepr')
- tools.eq_(obj_repr, b"<class 'object'>")
- tools.assert_true(isinstance(obj_repr, bytes))
+ self.assertEqual(obj_repr, b"<class 'object'>")
+ self.assertTrue(isinstance(obj_repr, bytes))
Index: kitchen-1.2.6/kitchen3/tests/test_deprecation.py
===================================================================
--- kitchen-1.2.6.orig/kitchen3/tests/test_deprecation.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen3/tests/test_deprecation.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
import sys
import warnings
@@ -21,27 +20,27 @@ class TestDeprecated(unittest.TestCase):
def test_deprecated_functions(self):
'''Test that all deprecated functions raise DeprecationWarning'''
- tools.assert_raises(DeprecationWarning, converters.to_utf8, 'café')
- tools.assert_raises(DeprecationWarning, converters.to_str, 5)
- tools.assert_raises(DeprecationWarning, converters.to_xml, 'test')
-
- tools.assert_raises(DeprecationWarning, utf8.utf8_valid, 'test')
- tools.assert_raises(DeprecationWarning, utf8.utf8_width, 'test')
- tools.assert_raises(DeprecationWarning, utf8.utf8_width_chop, 'test')
- tools.assert_raises(DeprecationWarning, utf8.utf8_width_fill, 'test', 'asd')
- tools.assert_raises(DeprecationWarning, utf8.utf8_text_wrap, 'test')
- tools.assert_raises(DeprecationWarning, utf8.utf8_text_fill, 'test')
- tools.assert_raises(DeprecationWarning, utf8._utf8_width_le, 'test')
+ self.assertRaises(DeprecationWarning, converters.to_utf8, 'café')
+ self.assertRaises(DeprecationWarning, converters.to_str, 5)
+ self.assertRaises(DeprecationWarning, converters.to_xml, 'test')
+
+ self.assertRaises(DeprecationWarning, utf8.utf8_valid, 'test')
+ self.assertRaises(DeprecationWarning, utf8.utf8_width, 'test')
+ self.assertRaises(DeprecationWarning, utf8.utf8_width_chop, 'test')
+ self.assertRaises(DeprecationWarning, utf8.utf8_width_fill, 'test', 'asd')
+ self.assertRaises(DeprecationWarning, utf8.utf8_text_wrap, 'test')
+ self.assertRaises(DeprecationWarning, utf8.utf8_text_fill, 'test')
+ self.assertRaises(DeprecationWarning, utf8._utf8_width_le, 'test')
def test_deprecated_parameters(self):
- tools.assert_raises(DeprecationWarning, converters.to_unicode, *[5],
+ self.assertRaises(DeprecationWarning, converters.to_unicode, *[5],
**{'non_string': 'simplerepr'})
- tools.assert_raises(DeprecationWarning, converters.to_unicode, *[5],
+ self.assertRaises(DeprecationWarning, converters.to_unicode, *[5],
**{'nonstring': 'simplerepr', 'non_string': 'simplerepr'})
- tools.assert_raises(DeprecationWarning, converters.to_bytes, *[5],
+ self.assertRaises(DeprecationWarning, converters.to_bytes, *[5],
**{'non_string': 'simplerepr'})
- tools.assert_raises(DeprecationWarning, converters.to_bytes, *[5],
+ self.assertRaises(DeprecationWarning, converters.to_bytes, *[5],
**{'nonstring': 'simplerepr', 'non_string': 'simplerepr'})
@@ -57,7 +56,7 @@ class TestPendingDeprecationParameters(u
def test_parameters(self):
# test that we warn when using the python2_api parameters
- tools.assert_raises(PendingDeprecationWarning,
+ self.assertRaises(PendingDeprecationWarning,
i18n.get_translation_object, 'test', **{'python2_api': True})
- tools.assert_raises(PendingDeprecationWarning,
+ self.assertRaises(PendingDeprecationWarning,
i18n.DummyTranslations, **{'python2_api': True})
Index: kitchen-1.2.6/kitchen3/tests/test_deprecation_py3.py
===================================================================
--- kitchen-1.2.6.orig/kitchen3/tests/test_deprecation_py3.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen3/tests/test_deprecation_py3.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,6 +1,6 @@
# -*- coding: utf-8 -*-
-from nose import tools
+import unittest
import sys
import warnings
@@ -8,8 +8,8 @@ import warnings
import importlib
from kitchen.pycompat25.collections import defaultdict
-class TestPendingDeprecationModules(object):
- def __init__(self):
+class TestPendingDeprecationModules(unittest.TestCase):
+ def setUp(self):
kitchen_path = 'kitchen'
collections_path = 'kitchen/collections'
pycompat24_path = 'kitchen/pycompat24'
@@ -46,7 +46,7 @@ class TestPendingDeprecationModules(obje
('%s is deprecated' % module_name) in warning.args[0]:
warning_raised = True
break
- tools.assert_true(warning_raised, msg='%s did not raise a PendingDeprecationWarning' % module_fqn)
+ self.assertTrue(warning_raised, msg='%s did not raise a PendingDeprecationWarning' % module_fqn)
def test_modules(self):
for mod in self.module_data:
@@ -62,4 +62,4 @@ class TestPendingDeprecationModules(obje
('defaultdict is deprecated') in warning.args[0]:
warning_raised = True
break
- tools.assert_true(warning_raised, msg='kitchen.pycompat25.collections.defaultdict did not raise a PendingDeprecationWarning')
+ self.assertTrue(warning_raised, msg='kitchen.pycompat25.collections.defaultdict did not raise a PendingDeprecationWarning')
Index: kitchen-1.2.6/kitchen3/tests/test_i18n.py
===================================================================
--- kitchen-1.2.6.orig/kitchen3/tests/test_i18n.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen3/tests/test_i18n.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
import os
import types
@@ -31,17 +30,17 @@ class TestI18N_UTF8(unittest.TestCase, b
'''
_, N_ = i18n.easy_gettext_setup('foo', localedirs=
['%s/data/locale/' % os.path.dirname(__file__)])
- tools.assert_true(isinstance(_, types.MethodType))
- tools.assert_true(isinstance(N_, types.MethodType))
- tools.eq_(_.__name__, '_ugettext')
- tools.eq_(N_.__name__, '_ungettext')
-
- tools.eq_(_(self.utf8_spanish), self.u_spanish)
- tools.eq_(_(self.u_spanish), self.u_spanish)
- tools.eq_(N_(self.utf8_limao, self.utf8_limoes, 1), self.u_limao)
- tools.eq_(N_(self.utf8_limao, self.utf8_limoes, 2), self.u_limoes)
- tools.eq_(N_(self.u_limao, self.u_limoes, 1), self.u_limao)
- tools.eq_(N_(self.u_limao, self.u_limoes, 2), self.u_limoes)
+ self.assertTrue(isinstance(_, types.MethodType))
+ self.assertTrue(isinstance(N_, types.MethodType))
+ self.assertEqual(_.__name__, '_ugettext')
+ self.assertEqual(N_.__name__, '_ungettext')
+
+ self.assertEqual(_(self.utf8_spanish), self.u_spanish)
+ self.assertEqual(_(self.u_spanish), self.u_spanish)
+ self.assertEqual(N_(self.utf8_limao, self.utf8_limoes, 1), self.u_limao)
+ self.assertEqual(N_(self.utf8_limao, self.utf8_limoes, 2), self.u_limoes)
+ self.assertEqual(N_(self.u_limao, self.u_limoes, 1), self.u_limao)
+ self.assertEqual(N_(self.u_limao, self.u_limoes, 2), self.u_limoes)
def test_easy_gettext_setup_non_unicode(self):
'''Test that the easy_gettext_setup function works
@@ -49,35 +48,35 @@ class TestI18N_UTF8(unittest.TestCase, b
b_, bN_ = i18n.easy_gettext_setup('foo', localedirs=
['%s/data/locale/' % os.path.dirname(__file__)],
use_unicode=False)
- tools.assert_true(isinstance(b_, types.MethodType))
- tools.assert_true(isinstance(bN_, types.MethodType))
- tools.eq_(b_.__name__, '_lgettext')
- tools.eq_(bN_.__name__, '_lngettext')
-
- tools.eq_(b_(self.utf8_spanish), self.utf8_spanish)
- tools.eq_(b_(self.u_spanish), self.utf8_spanish)
- tools.eq_(bN_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_limao)
- tools.eq_(bN_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_limoes)
- tools.eq_(bN_(self.u_limao, self.u_limoes, 1), self.utf8_limao)
- tools.eq_(bN_(self.u_limao, self.u_limoes, 2), self.utf8_limoes)
+ self.assertTrue(isinstance(b_, types.MethodType))
+ self.assertTrue(isinstance(bN_, types.MethodType))
+ self.assertEqual(b_.__name__, '_lgettext')
+ self.assertEqual(bN_.__name__, '_lngettext')
+
+ self.assertEqual(b_(self.utf8_spanish), self.utf8_spanish)
+ self.assertEqual(b_(self.u_spanish), self.utf8_spanish)
+ self.assertEqual(bN_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_limao)
+ self.assertEqual(bN_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_limoes)
+ self.assertEqual(bN_(self.u_limao, self.u_limoes, 1), self.utf8_limao)
+ self.assertEqual(bN_(self.u_limao, self.u_limoes, 2), self.utf8_limoes)
def test_get_translation_object(self):
'''Test that the get_translation_object function works
'''
translations = i18n.get_translation_object('foo', ['%s/data/locale/' % os.path.dirname(__file__)])
- tools.eq_(translations.__class__, i18n.DummyTranslations)
- tools.assert_raises(IOError, i18n.get_translation_object, 'foo', ['%s/data/locale/' % os.path.dirname(__file__)], fallback=False)
+ self.assertEqual(translations.__class__, i18n.DummyTranslations)
+ self.assertRaises(IOError, i18n.get_translation_object, 'foo', ['%s/data/locale/' % os.path.dirname(__file__)], fallback=False)
translations = i18n.get_translation_object('test', ['%s/data/locale/' % os.path.dirname(__file__)])
- tools.eq_(translations.__class__, i18n.NewGNUTranslations)
+ self.assertEqual(translations.__class__, i18n.NewGNUTranslations)
def test_get_translation_object_create_fallback(self):
'''Test get_translation_object creates fallbacks for additional catalogs'''
translations = i18n.get_translation_object('test',
['%s/data/locale' % os.path.dirname(__file__),
'%s/data/locale-old' % os.path.dirname(__file__)])
- tools.eq_(translations.__class__, i18n.NewGNUTranslations)
- tools.eq_(translations._fallback.__class__, i18n.NewGNUTranslations)
+ self.assertEqual(translations.__class__, i18n.NewGNUTranslations)
+ self.assertEqual(translations._fallback.__class__, i18n.NewGNUTranslations)
def test_get_translation_object_copy(self):
'''Test get_translation_object shallow copies the message catalog'''
@@ -93,16 +92,16 @@ class TestI18N_UTF8(unittest.TestCase, b
# Test that portions of the translation objects are the same and other
# portions are different (which is a space optimization so that the
# translation data isn't in memory multiple times)
- tools.assert_not_equal(id(translations._fallback), id(translations2._fallback))
- tools.assert_not_equal(id(translations.output_charset()), id(translations2.output_charset()))
- tools.assert_not_equal(id(translations.input_charset), id(translations2.input_charset))
- tools.assert_not_equal(id(translations.input_charset), id(translations2.input_charset))
- tools.eq_(id(translations._catalog), id(translations2._catalog))
+ self.assertNotEqual(id(translations._fallback), id(translations2._fallback))
+ self.assertNotEqual(id(translations.output_charset()), id(translations2.output_charset()))
+ self.assertNotEqual(id(translations.input_charset), id(translations2.input_charset))
+ self.assertNotEqual(id(translations.input_charset), id(translations2.input_charset))
+ self.assertEqual(id(translations._catalog), id(translations2._catalog))
def test_get_translation_object_optional_params(self):
'''Smoketest leaving out optional parameters'''
translations = i18n.get_translation_object('test')
- tools.assert_true(translations.__class__ in (i18n.NewGNUTranslations, i18n.DummyTranslations))
+ self.assertTrue(translations.__class__ in (i18n.NewGNUTranslations, i18n.DummyTranslations))
def test_get_translation_object_python2_api_default(self):
'''Smoketest that python2_api default value yields the python2 functions'''
@@ -111,12 +110,12 @@ class TestI18N_UTF8(unittest.TestCase, b
['%s/data/locale' % os.path.dirname(__file__),
'%s/data/locale-old' % os.path.dirname(__file__)], codeset='utf-8')
translations.input_charset = 'utf-8'
- tools.eq_(translations.gettext.__name__, '_gettext')
- tools.eq_(translations.lgettext.__name__, '_lgettext')
- tools.eq_(translations.ugettext.__name__, '_ugettext')
- tools.eq_(translations.ngettext.__name__, '_ngettext')
- tools.eq_(translations.lngettext.__name__, '_lngettext')
- tools.eq_(translations.ungettext.__name__, '_ungettext')
+ self.assertEqual(translations.gettext.__name__, '_gettext')
+ self.assertEqual(translations.lgettext.__name__, '_lgettext')
+ self.assertEqual(translations.ugettext.__name__, '_ugettext')
+ self.assertEqual(translations.ngettext.__name__, '_ngettext')
+ self.assertEqual(translations.lngettext.__name__, '_lngettext')
+ self.assertEqual(translations.ungettext.__name__, '_ungettext')
def test_get_translation_object_python2_api_true(self):
'''Smoketest that setting python2_api true yields the python2 functions'''
@@ -126,12 +125,12 @@ class TestI18N_UTF8(unittest.TestCase, b
'%s/data/locale-old' % os.path.dirname(__file__)], codeset='utf-8',
python2_api=True)
translations.input_charset = 'utf-8'
- tools.eq_(translations.gettext.__name__, '_gettext')
- tools.eq_(translations.lgettext.__name__, '_lgettext')
- tools.eq_(translations.ugettext.__name__, '_ugettext')
- tools.eq_(translations.ngettext.__name__, '_ngettext')
- tools.eq_(translations.lngettext.__name__, '_lngettext')
- tools.eq_(translations.ungettext.__name__, '_ungettext')
+ self.assertEqual(translations.gettext.__name__, '_gettext')
+ self.assertEqual(translations.lgettext.__name__, '_lgettext')
+ self.assertEqual(translations.ugettext.__name__, '_ugettext')
+ self.assertEqual(translations.ngettext.__name__, '_ngettext')
+ self.assertEqual(translations.lngettext.__name__, '_lngettext')
+ self.assertEqual(translations.ungettext.__name__, '_ungettext')
def test_get_translation_object_python2_api_false(self):
'''Smoketest that setting python2_api false yields the python3 functions'''
@@ -141,23 +140,23 @@ class TestI18N_UTF8(unittest.TestCase, b
'%s/data/locale-old' % os.path.dirname(__file__)], codeset='utf-8',
python2_api=False)
translations.input_charset = 'utf-8'
- tools.eq_(translations.gettext.__name__, '_ugettext')
- tools.eq_(translations.lgettext.__name__, '_lgettext')
- tools.eq_(translations.ngettext.__name__, '_ungettext')
- tools.eq_(translations.lngettext.__name__, '_lngettext')
+ self.assertEqual(translations.gettext.__name__, '_ugettext')
+ self.assertEqual(translations.lgettext.__name__, '_lgettext')
+ self.assertEqual(translations.ngettext.__name__, '_ungettext')
+ self.assertEqual(translations.lngettext.__name__, '_lngettext')
- tools.assert_raises(AttributeError, translations.ugettext, 'message')
- tools.assert_raises(AttributeError, translations.ungettext, 'message1', 'message2')
+ self.assertRaises(AttributeError, translations.ugettext, 'message')
+ self.assertRaises(AttributeError, translations.ungettext, 'message1', 'message2')
def test_dummy_translation(self):
'''Test that we can create a DummyTranslation object
'''
- tools.assert_true(isinstance(i18n.DummyTranslations(), i18n.DummyTranslations))
+ self.assertTrue(isinstance(i18n.DummyTranslations(), i18n.DummyTranslations))
# Note: Using nose's generator tests for this so we can't subclass
# unittest.TestCase
-class TestDummyTranslations(base_classes.UnicodeTestData):
- def __init__(self):
+class TestDummyTranslations(unittest.TestCase, base_classes.UnicodeTestData):
+ def setUp(self):
self.test_data = {'bytes': (( # First set is with default charset (utf8)
(self.u_ascii, self.b_ascii),
(self.u_spanish, self.utf8_spanish),
@@ -214,14 +213,12 @@ class TestDummyTranslations(base_classes
(self.utf8_japanese, self.u_mangled_japanese_utf8_as_ascii), # String mangled but no exception
),
)
- }
-
- def setUp(self):
+ }
self.translations = i18n.DummyTranslations()
def check_gettext(self, message, value, charset=None):
self.translations.set_output_charset(charset)
- tools.eq_(self.translations.gettext(message), value,
+ self.assertEqual(self.translations.gettext(message), value,
msg='gettext(%s): trans: %s != val: %s (charset=%s)'
% (repr(message), repr(self.translations.gettext(message)),
repr(value), charset))
@@ -230,7 +227,7 @@ class TestDummyTranslations(base_classes
locale='en_US.UTF-8'):
os.environ['LC_ALL'] = locale
self.translations.set_output_charset(charset)
- tools.eq_(self.translations.lgettext(message), value,
+ self.assertEqual(self.translations.lgettext(message), value,
msg='lgettext(%s): trans: %s != val: %s (charset=%s, locale=%s)'
% (repr(message), repr(self.translations.lgettext(message)),
repr(value), charset, locale))
@@ -240,34 +237,34 @@ class TestDummyTranslations(base_classes
def check_ugettext(self, message, value, charset='utf-8'):
'''ugettext method with default values'''
self.translations.input_charset = charset
- tools.eq_(self.translations.ugettext(message), value,
+ self.assertEqual(self.translations.ugettext(message), value,
msg='ugettext(%s): trans: %s != val: %s (charset=%s)'
% (repr(message), repr(self.translations.ugettext(message)),
repr(value), charset))
def check_ngettext(self, message, value, charset=None):
self.translations.set_output_charset(charset)
- tools.eq_(self.translations.ngettext(message, 'blank', 1), value)
- tools.eq_(self.translations.ngettext('blank', message, 2), value)
- tools.assert_not_equal(self.translations.ngettext(message, 'blank', 2), value)
- tools.assert_not_equal(self.translations.ngettext('blank', message, 1), value)
+ self.assertEqual(self.translations.ngettext(message, 'blank', 1), value)
+ self.assertEqual(self.translations.ngettext('blank', message, 2), value)
+ self.assertNotEqual(self.translations.ngettext(message, 'blank', 2), value)
+ self.assertNotEqual(self.translations.ngettext('blank', message, 1), value)
def check_lngettext(self, message, value, charset=None, locale='en_US.UTF-8'):
os.environ['LC_ALL'] = locale
self.translations.set_output_charset(charset)
- tools.eq_(self.translations.lngettext(message, 'blank', 1), value,
+ self.assertEqual(self.translations.lngettext(message, 'blank', 1), value,
msg='lngettext(%s, "blank", 1): trans: %s != val: %s (charset=%s, locale=%s)'
% (repr(message), repr(self.translations.lngettext(message,
'blank', 1)), repr(value), charset, locale))
- tools.eq_(self.translations.lngettext('blank', message, 2), value,
+ self.assertEqual(self.translations.lngettext('blank', message, 2), value,
msg='lngettext("blank", %s, 2): trans: %s != val: %s (charset=%s, locale=%s)'
% (repr(message), repr(self.translations.lngettext('blank',
message, 2)), repr(value), charset, locale))
- tools.assert_not_equal(self.translations.lngettext(message, 'blank', 2), value,
+ self.assertNotEqual(self.translations.lngettext(message, 'blank', 2), value,
msg='lngettext(%s, "blank", 2): trans: %s, val: %s (charset=%s, locale=%s)'
% (repr(message), repr(self.translations.lngettext(message,
'blank', 2)), repr(value), charset, locale))
- tools.assert_not_equal(self.translations.lngettext('blank', message, 1), value,
+ self.assertNotEqual(self.translations.lngettext('blank', message, 1), value,
msg='lngettext("blank", %s, 1): trans: %s != val: %s (charset=%s, locale=%s)'
% (repr(message), repr(self.translations.lngettext('blank',
message, 1)), repr(value), charset, locale))
@@ -276,10 +273,10 @@ class TestDummyTranslations(base_classes
# tearDown each time check_* is run.
def check_ungettext(self, message, value, charset='utf-8'):
self.translations.input_charset = charset
- tools.eq_(self.translations.ungettext(message, 'blank', 1), value)
- tools.eq_(self.translations.ungettext('blank', message, 2), value)
- tools.assert_not_equal(self.translations.ungettext(message, 'blank', 2), value)
- tools.assert_not_equal(self.translations.ungettext('blank', message, 1), value)
+ self.assertEqual(self.translations.ungettext(message, 'blank', 1), value)
+ self.assertEqual(self.translations.ungettext('blank', message, 2), value)
+ self.assertNotEqual(self.translations.ungettext(message, 'blank', 2), value)
+ self.assertNotEqual(self.translations.ungettext('blank', message, 1), value)
def test_gettext(self):
'''gettext method with default values'''
@@ -370,12 +367,12 @@ class TestDummyTranslations(base_classes
yield self.check_ungettext, message, value, 'ascii'
def test_nonbasestring(self):
- tools.eq_(self.translations.gettext(dict(hi='there')), self.b_empty_string)
- tools.eq_(self.translations.ngettext(dict(hi='there'), dict(hi='two'), 1), self.b_empty_string)
- tools.eq_(self.translations.lgettext(dict(hi='there')), self.b_empty_string)
- tools.eq_(self.translations.lngettext(dict(hi='there'), dict(hi='two'), 1), self.b_empty_string)
- tools.eq_(self.translations.ugettext(dict(hi='there')), self.u_empty_string)
- tools.eq_(self.translations.ungettext(dict(hi='there'), dict(hi='two'), 1), self.u_empty_string)
+ self.assertEqual(self.translations.gettext(dict(hi='there')), self.b_empty_string)
+ self.assertEqual(self.translations.ngettext(dict(hi='there'), dict(hi='two'), 1), self.b_empty_string)
+ self.assertEqual(self.translations.lgettext(dict(hi='there')), self.b_empty_string)
+ self.assertEqual(self.translations.lngettext(dict(hi='there'), dict(hi='two'), 1), self.b_empty_string)
+ self.assertEqual(self.translations.ugettext(dict(hi='there')), self.u_empty_string)
+ self.assertEqual(self.translations.ungettext(dict(hi='there'), dict(hi='two'), 1), self.u_empty_string)
class TestI18N_Latin1(unittest.TestCase, base_classes.UnicodeTestData):
@@ -401,12 +398,12 @@ class TestI18N_Latin1(unittest.TestCase,
['%s/data/locale/' % os.path.dirname(__file__)],
use_unicode=False)
- tools.eq_(b_(self.utf8_spanish), self.utf8_spanish)
- tools.eq_(b_(self.u_spanish), self.latin1_spanish)
- tools.eq_(bN_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_limao)
- tools.eq_(bN_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_limoes)
- tools.eq_(bN_(self.u_limao, self.u_limoes, 1), self.latin1_limao)
- tools.eq_(bN_(self.u_limao, self.u_limoes, 2), self.latin1_limoes)
+ self.assertEqual(b_(self.utf8_spanish), self.utf8_spanish)
+ self.assertEqual(b_(self.u_spanish), self.latin1_spanish)
+ self.assertEqual(bN_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_limao)
+ self.assertEqual(bN_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_limoes)
+ self.assertEqual(bN_(self.u_limao, self.u_limoes, 1), self.latin1_limao)
+ self.assertEqual(bN_(self.u_limao, self.u_limoes, 2), self.latin1_limoes)
class TestNewGNUTranslationsNoMatch(TestDummyTranslations):
@@ -448,104 +445,104 @@ class TestNewGNURealTranslations_UTF8(un
def test_gettext(self):
_ = self.translations.gettext
- tools.eq_(_(self.utf8_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.utf8_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
# This is not translated to utf8_yes_in_fallback because this test is
# without the fallback message catalog
- tools.eq_(_(self.utf8_in_fallback), self.utf8_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.u_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.utf8_ja_kuratomi)
# This is not translated to utf8_yes_in_fallback because this test is
# without the fallback message catalog
- tools.eq_(_(self.u_in_fallback), self.utf8_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
def test_ngettext(self):
_ = self.translations.ngettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
def test_lgettext(self):
_ = self.translations.lgettext
- tools.eq_(_(self.utf8_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.utf8_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
# This is not translated to utf8_yes_in_fallback because this test is
# without the fallback message catalog
- tools.eq_(_(self.utf8_in_fallback), self.utf8_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.u_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.utf8_ja_kuratomi)
# This is not translated to utf8_yes_in_fallback because this test is
# without the fallback message catalog
- tools.eq_(_(self.u_in_fallback), self.utf8_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
def test_lngettext(self):
_ = self.translations.lngettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
def test_ugettext(self):
_ = self.translations.ugettext
- tools.eq_(_(self.utf8_kitchen), self.u_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.u_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.u_ja_kuratomi)
+ self.assertEqual(_(self.utf8_kitchen), self.u_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.u_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.u_ja_kuratomi)
# This is not translated to utf8_yes_in_fallback because this test is
# without the fallback message catalog
- tools.eq_(_(self.utf8_in_fallback), self.u_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.u_not_in_catalog)
+ self.assertEqual(_(self.utf8_in_fallback), self.u_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.u_not_in_catalog)
- tools.eq_(_(self.u_kitchen), self.u_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.u_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.u_ja_kuratomi)
+ self.assertEqual(_(self.u_kitchen), self.u_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.u_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.u_ja_kuratomi)
# This is not translated to utf8_yes_in_fallback because this test is
# without the fallback message catalog
- tools.eq_(_(self.u_in_fallback), self.u_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.u_not_in_catalog)
+ self.assertEqual(_(self.u_in_fallback), self.u_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.u_not_in_catalog)
def test_ungettext(self):
_ = self.translations.ungettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.u_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.u_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.u_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.u_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.u_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.u_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.u_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.u_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.u_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.u_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.u_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.u_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.u_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.u_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.u_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.u_lemons)
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
class TestNewGNURealTranslations_Latin1(TestNewGNURealTranslations_UTF8):
@@ -568,43 +565,43 @@ class TestNewGNURealTranslations_Latin1(
def test_lgettext(self):
_ = self.translations.lgettext
- tools.eq_(_(self.utf8_kitchen), self.latin1_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.latin1_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.latin1_ja_kuratomi)
+ self.assertEqual(_(self.utf8_kitchen), self.latin1_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.latin1_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.latin1_ja_kuratomi)
# Neither of the following two tests encode to proper latin-1 because:
# any byte is valid in latin-1 so there's no way to know that what
# we're given in the string is really utf-8
#
# This is not translated to latin1_yes_in_fallback because this test
# is without the fallback message catalog
- tools.eq_(_(self.utf8_in_fallback), self.utf8_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_kitchen), self.latin1_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.latin1_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.latin1_ja_kuratomi)
+ self.assertEqual(_(self.u_kitchen), self.latin1_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.latin1_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.latin1_ja_kuratomi)
# This is not translated to latin1_yes_in_fallback because this test
# is without the fallback message catalog
- tools.eq_(_(self.u_in_fallback), self.latin1_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.latin1_not_in_catalog)
+ self.assertEqual(_(self.u_in_fallback), self.latin1_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.latin1_not_in_catalog)
def test_lngettext(self):
_ = self.translations.lngettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.latin1_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.latin1_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.latin1_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.latin1_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.latin1_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.latin1_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.latin1_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.latin1_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.latin1_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.latin1_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.latin1_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.latin1_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.latin1_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.latin1_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.latin1_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.latin1_lemons)
# This unfortunately does not encode to proper latin-1 because:
# any byte is valid in latin-1 so there's no way to know that what
# we're given in the string is really utf-8
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.latin1_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.latin1_not_in_catalog)
class TestFallbackNewGNUTranslationsNoMatch(TestDummyTranslations):
@@ -650,90 +647,90 @@ class TestFallbackNewGNURealTranslations
def test_gettext(self):
_ = self.translations.gettext
- tools.eq_(_(self.utf8_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
- tools.eq_(_(self.utf8_in_fallback), self.utf8_yes_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
-
- tools.eq_(_(self.u_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.utf8_ja_kuratomi)
- tools.eq_(_(self.u_in_fallback), self.utf8_yes_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.utf8_in_fallback), self.utf8_yes_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
+
+ self.assertEqual(_(self.u_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.u_in_fallback), self.utf8_yes_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
def test_ngettext(self):
_ = self.translations.ngettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
def test_lgettext(self):
_ = self.translations.lgettext
- tools.eq_(_(self.utf8_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
- tools.eq_(_(self.utf8_in_fallback), self.utf8_yes_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
-
- tools.eq_(_(self.u_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.utf8_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.utf8_ja_kuratomi)
- tools.eq_(_(self.u_in_fallback), self.utf8_yes_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.utf8_in_fallback), self.utf8_yes_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
+
+ self.assertEqual(_(self.u_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.u_in_fallback), self.utf8_yes_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.utf8_not_in_catalog)
def test_lngettext(self):
_ = self.translations.lngettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.utf8_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.utf8_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.utf8_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.utf8_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.utf8_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.utf8_lemons)
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
def test_ugettext(self):
_ = self.translations.ugettext
- tools.eq_(_(self.utf8_kitchen), self.u_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.u_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.u_ja_kuratomi)
- tools.eq_(_(self.utf8_in_fallback), self.u_yes_in_fallback)
- tools.eq_(_(self.utf8_not_in_catalog), self.u_not_in_catalog)
-
- tools.eq_(_(self.u_kitchen), self.u_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.u_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.u_ja_kuratomi)
- tools.eq_(_(self.u_in_fallback), self.u_yes_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.u_not_in_catalog)
+ self.assertEqual(_(self.utf8_kitchen), self.u_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.u_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.u_ja_kuratomi)
+ self.assertEqual(_(self.utf8_in_fallback), self.u_yes_in_fallback)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.u_not_in_catalog)
+
+ self.assertEqual(_(self.u_kitchen), self.u_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.u_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.u_ja_kuratomi)
+ self.assertEqual(_(self.u_in_fallback), self.u_yes_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.u_not_in_catalog)
def test_ungettext(self):
_ = self.translations.ungettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.u_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.u_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.u_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.u_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.u_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.u_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.u_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.u_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.u_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.u_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.u_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.u_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.u_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.u_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.u_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.u_lemons)
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.u_not_in_catalog)
class TestFallbackNewGNURealTranslations_Latin1(TestFallbackNewGNURealTranslations_UTF8):
@@ -758,38 +755,38 @@ class TestFallbackNewGNURealTranslations
def test_lgettext(self):
_ = self.translations.lgettext
- tools.eq_(_(self.utf8_kitchen), self.latin1_pt_kitchen)
- tools.eq_(_(self.utf8_ja_kuratomi), self.latin1_kuratomi)
- tools.eq_(_(self.utf8_kuratomi), self.latin1_ja_kuratomi)
- tools.eq_(_(self.utf8_in_fallback), self.latin1_yes_in_fallback)
+ self.assertEqual(_(self.utf8_kitchen), self.latin1_pt_kitchen)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.latin1_kuratomi)
+ self.assertEqual(_(self.utf8_kuratomi), self.latin1_ja_kuratomi)
+ self.assertEqual(_(self.utf8_in_fallback), self.latin1_yes_in_fallback)
# This unfortunately does not encode to proper latin-1 because:
# any byte is valid in latin-1 so there's no way to know that what
# we're given in the string is really utf-8
- tools.eq_(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_kitchen), self.latin1_pt_kitchen)
- tools.eq_(_(self.u_ja_kuratomi), self.latin1_kuratomi)
- tools.eq_(_(self.u_kuratomi), self.latin1_ja_kuratomi)
- tools.eq_(_(self.u_in_fallback), self.latin1_yes_in_fallback)
- tools.eq_(_(self.u_not_in_catalog), self.latin1_not_in_catalog)
+ self.assertEqual(_(self.u_kitchen), self.latin1_pt_kitchen)
+ self.assertEqual(_(self.u_ja_kuratomi), self.latin1_kuratomi)
+ self.assertEqual(_(self.u_kuratomi), self.latin1_ja_kuratomi)
+ self.assertEqual(_(self.u_in_fallback), self.latin1_yes_in_fallback)
+ self.assertEqual(_(self.u_not_in_catalog), self.latin1_not_in_catalog)
def test_lngettext(self):
_ = self.translations.lngettext
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 1), self.latin1_limao)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 1), self.latin1_lemon)
- tools.eq_(_(self.u_lemon, self.u_lemons, 1), self.latin1_limao)
- tools.eq_(_(self.u_limao, self.u_limoes, 1), self.latin1_lemon)
-
- tools.eq_(_(self.utf8_lemon, self.utf8_lemons, 2), self.latin1_limoes)
- tools.eq_(_(self.utf8_limao, self.utf8_limoes, 2), self.latin1_lemons)
- tools.eq_(_(self.u_lemon, self.u_lemons, 2), self.latin1_limoes)
- tools.eq_(_(self.u_limao, self.u_limoes, 2), self.latin1_lemons)
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 1), self.latin1_limao)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 1), self.latin1_lemon)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 1), self.latin1_limao)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 1), self.latin1_lemon)
+
+ self.assertEqual(_(self.utf8_lemon, self.utf8_lemons, 2), self.latin1_limoes)
+ self.assertEqual(_(self.utf8_limao, self.utf8_limoes, 2), self.latin1_lemons)
+ self.assertEqual(_(self.u_lemon, self.u_lemons, 2), self.latin1_limoes)
+ self.assertEqual(_(self.u_limao, self.u_limoes, 2), self.latin1_lemons)
# This unfortunately does not encode to proper latin-1 because:
# any byte is valid in latin-1 so there's no way to know that what
# we're given in the string is really utf-8
- tools.eq_(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
- tools.eq_(_(self.u_not_in_catalog, 'throwaway', 1), self.latin1_not_in_catalog)
+ self.assertEqual(_(self.utf8_not_in_catalog, 'throwaway', 1), self.utf8_not_in_catalog)
+ self.assertEqual(_(self.u_not_in_catalog, 'throwaway', 1), self.latin1_not_in_catalog)
class TestFallback(unittest.TestCase, base_classes.UnicodeTestData):
@@ -820,21 +817,21 @@ class TestFallback(unittest.TestCase, ba
def test_invalid_fallback_no_raise(self):
'''Test when we have an invalid fallback that it does not raise.'''
- tools.eq_(self.gtranslations.gettext(self.u_spanish), self.utf8_spanish)
- tools.eq_(self.gtranslations.ugettext(self.u_spanish), self.u_spanish)
- tools.eq_(self.gtranslations.lgettext(self.u_spanish), self.latin1_spanish)
-
- tools.eq_(self.gtranslations.ngettext(self.u_spanish, 'cde', 1), self.utf8_spanish)
- tools.eq_(self.gtranslations.ungettext(self.u_spanish, 'cde', 1), self.u_spanish)
- tools.eq_(self.gtranslations.lngettext(self.u_spanish, 'cde', 1), self.latin1_spanish)
-
- tools.eq_(self.dtranslations.gettext(self.u_spanish), self.utf8_spanish)
- tools.eq_(self.dtranslations.ugettext(self.u_spanish), self.u_spanish)
- tools.eq_(self.dtranslations.lgettext(self.u_spanish), self.latin1_spanish)
-
- tools.eq_(self.dtranslations.ngettext(self.u_spanish, 'cde', 1), self.utf8_spanish)
- tools.eq_(self.dtranslations.ungettext(self.u_spanish, 'cde', 1), self.u_spanish)
- tools.eq_(self.dtranslations.lngettext(self.u_spanish, 'cde', 1), self.latin1_spanish)
+ self.assertEqual(self.gtranslations.gettext(self.u_spanish), self.utf8_spanish)
+ self.assertEqual(self.gtranslations.ugettext(self.u_spanish), self.u_spanish)
+ self.assertEqual(self.gtranslations.lgettext(self.u_spanish), self.latin1_spanish)
+
+ self.assertEqual(self.gtranslations.ngettext(self.u_spanish, 'cde', 1), self.utf8_spanish)
+ self.assertEqual(self.gtranslations.ungettext(self.u_spanish, 'cde', 1), self.u_spanish)
+ self.assertEqual(self.gtranslations.lngettext(self.u_spanish, 'cde', 1), self.latin1_spanish)
+
+ self.assertEqual(self.dtranslations.gettext(self.u_spanish), self.utf8_spanish)
+ self.assertEqual(self.dtranslations.ugettext(self.u_spanish), self.u_spanish)
+ self.assertEqual(self.dtranslations.lgettext(self.u_spanish), self.latin1_spanish)
+
+ self.assertEqual(self.dtranslations.ngettext(self.u_spanish, 'cde', 1), self.utf8_spanish)
+ self.assertEqual(self.dtranslations.ungettext(self.u_spanish, 'cde', 1), self.u_spanish)
+ self.assertEqual(self.dtranslations.lngettext(self.u_spanish, 'cde', 1), self.latin1_spanish)
class TestDefaultLocaleDir(unittest.TestCase, base_classes.UnicodeTestData):
@@ -863,16 +860,16 @@ class TestDefaultLocaleDir(unittest.Test
def test_gettext(self):
_ = self.translations.gettext
- tools.eq_(_(self.utf8_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
- tools.eq_(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.utf8_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.utf8_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.utf8_ja_kuratomi), self.utf8_kuratomi)
# Returns msgid because the string is in a fallback catalog which we
# haven't setup
- tools.eq_(_(self.utf8_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.utf8_in_fallback), self.utf8_in_fallback)
- tools.eq_(_(self.u_kitchen), self.utf8_pt_kitchen)
- tools.eq_(_(self.u_kuratomi), self.utf8_ja_kuratomi)
- tools.eq_(_(self.u_ja_kuratomi), self.utf8_kuratomi)
+ self.assertEqual(_(self.u_kitchen), self.utf8_pt_kitchen)
+ self.assertEqual(_(self.u_kuratomi), self.utf8_ja_kuratomi)
+ self.assertEqual(_(self.u_ja_kuratomi), self.utf8_kuratomi)
# Returns msgid because the string is in a fallback catalog which we
# haven't setup
- tools.eq_(_(self.u_in_fallback), self.utf8_in_fallback)
+ self.assertEqual(_(self.u_in_fallback), self.utf8_in_fallback)
Index: kitchen-1.2.6/kitchen3/tests/test_iterutils.py
===================================================================
--- kitchen-1.2.6.orig/kitchen3/tests/test_iterutils.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen3/tests/test_iterutils.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
from kitchen import iterutils
@@ -31,32 +30,32 @@ class TestIterutils(unittest.TestCase):
def test_isiterable(self):
for item in self.iterable_data:
- tools.ok_(iterutils.isiterable(item) == True)
+ self.assertTrue(iterutils.isiterable(item) == True)
for item in self.non_iterable_data:
- tools.ok_(iterutils.isiterable(item) == False)
+ self.assertTrue(iterutils.isiterable(item) == False)
# strings
- tools.ok_(iterutils.isiterable(b'a', include_string=True) == True)
- tools.ok_(iterutils.isiterable(b'a', include_string=False) == False)
- tools.ok_(iterutils.isiterable(b'a') == False)
- tools.ok_(iterutils.isiterable('a', include_string=True) == True)
- tools.ok_(iterutils.isiterable('a', include_string=False) == False)
- tools.ok_(iterutils.isiterable('a') == False)
+ self.assertTrue(iterutils.isiterable(b'a', include_string=True) == True)
+ self.assertTrue(iterutils.isiterable(b'a', include_string=False) == False)
+ self.assertTrue(iterutils.isiterable(b'a') == False)
+ self.assertTrue(iterutils.isiterable('a', include_string=True) == True)
+ self.assertTrue(iterutils.isiterable('a', include_string=False) == False)
+ self.assertTrue(iterutils.isiterable('a') == False)
def test_iterate(self):
iterutils.iterate(None)
for item in self.non_iterable_data:
- tools.ok_(list(iterutils.iterate(item)) == [item])
+ self.assertTrue(list(iterutils.iterate(item)) == [item])
for item in self.iterable_data[:-1]:
- tools.ok_(list(iterutils.iterate(item)) == list(item))
+ self.assertTrue(list(iterutils.iterate(item)) == list(item))
# iter() is exhausted after use so we have to test separately
- tools.ok_(list(iterutils.iterate(iter([1, 2, 3]))) == [1, 2, 3])
+ self.assertTrue(list(iterutils.iterate(iter([1, 2, 3]))) == [1, 2, 3])
# strings
- tools.ok_(list(iterutils.iterate(b'abc')) == [b'abc'])
- tools.eq_(list(iterutils.iterate(b'abc', include_string=True)), [ord(b'a'), ord(b'b'), ord(b'c')])
- tools.ok_(list(iterutils.iterate('abc')) == ['abc'])
- tools.ok_(list(iterutils.iterate('abc', include_string=True)) == ['a', 'b', 'c'])
+ self.assertTrue(list(iterutils.iterate(b'abc')) == [b'abc'])
+ self.assertEqual(list(iterutils.iterate(b'abc', include_string=True)), [ord(b'a'), ord(b'b'), ord(b'c')])
+ self.assertTrue(list(iterutils.iterate('abc')) == ['abc'])
+ self.assertTrue(list(iterutils.iterate('abc', include_string=True)) == ['a', 'b', 'c'])
Index: kitchen-1.2.6/kitchen3/tests/test_pycompat.py
===================================================================
--- kitchen-1.2.6.orig/kitchen3/tests/test_pycompat.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen3/tests/test_pycompat.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
class TestUsableModules(unittest.TestCase):
def test_subprocess(self):
@@ -10,11 +9,11 @@ class TestUsableModules(unittest.TestCas
try:
from kitchen.pycompat24.subprocess import Popen
except ImportError:
- tools.ok_(False, 'Unable to import pycompat24.subprocess as a module')
+ self.assertTrue(False, 'Unable to import pycompat24.subprocess as a module')
try:
from kitchen.pycompat27.subprocess import Popen
except ImportError:
- tools.ok_(False, 'Unable to import pycompat27.subprocess as a module')
+ self.assertTrue(False, 'Unable to import pycompat27.subprocess as a module')
def test_base64(self):
'''Test that importing base64 as a module works
@@ -22,4 +21,4 @@ class TestUsableModules(unittest.TestCas
try:
from kitchen.pycompat24.base64 import b64encode
except ImportError:
- tools.ok_(False, 'Unable to import pycompat24.base64 as a module')
+ self.assertTrue(False, 'Unable to import pycompat24.base64 as a module')
Index: kitchen-1.2.6/kitchen3/tests/test_text_display.py
===================================================================
--- kitchen-1.2.6.orig/kitchen3/tests/test_text_display.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen3/tests/test_text_display.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
from kitchen.text.exceptions import ControlCharError
@@ -14,19 +13,19 @@ class TestDisplay(base_classes.UnicodeTe
def test_internal_interval_bisearch(self):
'''Test that we can find things in an interval table'''
table = ((0, 3), (5, 7), (9, 10))
- tools.assert_true(display._interval_bisearch(0, table))
- tools.assert_true(display._interval_bisearch(1, table))
- tools.assert_true(display._interval_bisearch(2, table))
- tools.assert_true(display._interval_bisearch(3, table))
- tools.assert_true(display._interval_bisearch(5, table))
- tools.assert_true(display._interval_bisearch(6, table))
- tools.assert_true(display._interval_bisearch(7, table))
- tools.assert_true(display._interval_bisearch(9, table))
- tools.assert_true(display._interval_bisearch(10, table))
- tools.assert_false(display._interval_bisearch(-1, table))
- tools.assert_false(display._interval_bisearch(4, table))
- tools.assert_false(display._interval_bisearch(8, table))
- tools.assert_false(display._interval_bisearch(11, table))
+ self.assertTrue(display._interval_bisearch(0, table))
+ self.assertTrue(display._interval_bisearch(1, table))
+ self.assertTrue(display._interval_bisearch(2, table))
+ self.assertTrue(display._interval_bisearch(3, table))
+ self.assertTrue(display._interval_bisearch(5, table))
+ self.assertTrue(display._interval_bisearch(6, table))
+ self.assertTrue(display._interval_bisearch(7, table))
+ self.assertTrue(display._interval_bisearch(9, table))
+ self.assertTrue(display._interval_bisearch(10, table))
+ self.assertFalse(display._interval_bisearch(-1, table))
+ self.assertFalse(display._interval_bisearch(4, table))
+ self.assertFalse(display._interval_bisearch(8, table))
+ self.assertFalse(display._interval_bisearch(11, table))
def test_internal_generate_combining_table(self):
'''Test that the combining table we generate is equal to or a subset of what's in the current table
@@ -40,27 +39,27 @@ class TestDisplay(base_classes.UnicodeTe
new_table = display._generate_combining_table()
for interval in new_table:
if interval[0] == interval[1]:
- tools.assert_true(display._interval_bisearch(interval[0], old_table))
+ self.assertTrue(display._interval_bisearch(interval[0], old_table))
else:
for codepoint in range(interval[0], interval[1] + 1):
- tools.assert_true(display._interval_bisearch(interval[0], old_table))
+ self.assertTrue(display._interval_bisearch(interval[0], old_table))
def test_internal_ucp_width(self):
'''Test that ucp_width returns proper width for characters'''
for codepoint in range(0, 0xFFFFF + 1):
if codepoint < 32 or (codepoint < 0xa0 and codepoint >= 0x7f):
# With strict on, we should raise an error
- tools.assert_raises(ControlCharError, display._ucp_width, codepoint, 'strict')
+ self.assertRaises(ControlCharError, display._ucp_width, codepoint, 'strict')
if codepoint in (0x08, 0x1b, 0x7f, 0x94):
# Backspace, delete, clear delete remove one char
- tools.eq_(display._ucp_width(codepoint), -1)
+ self.assertEqual(display._ucp_width(codepoint), -1)
else:
# Everything else returns 0
- tools.eq_(display._ucp_width(codepoint), 0)
+ self.assertEqual(display._ucp_width(codepoint), 0)
elif display._interval_bisearch(codepoint, display._COMBINING):
# Combining character
- tools.eq_(display._ucp_width(codepoint), 0)
+ self.assertEqual(display._ucp_width(codepoint), 0)
elif (codepoint >= 0x1100 and
(codepoint <= 0x115f or # Hangul Jamo init. consonants
codepoint == 0x2329 or codepoint == 0x232a or
@@ -74,87 +73,87 @@ class TestDisplay(base_classes.UnicodeTe
(codepoint >= 0xffe0 and codepoint <= 0xffe6) or
(codepoint >= 0x20000 and codepoint <= 0x2fffd) or
(codepoint >= 0x30000 and codepoint <= 0x3fffd))):
- tools.eq_(display._ucp_width(codepoint), 2)
+ self.assertEqual(display._ucp_width(codepoint), 2)
else:
- tools.eq_(display._ucp_width(codepoint), 1)
+ self.assertEqual(display._ucp_width(codepoint), 1)
def test_textual_width(self):
'''Test that we find the proper number of spaces that a utf8 string will consume'''
- tools.eq_(display.textual_width(self.u_japanese), 31)
- tools.eq_(display.textual_width(self.u_spanish), 50)
- tools.eq_(display.textual_width(self.u_mixed), 23)
+ self.assertEqual(display.textual_width(self.u_japanese), 31)
+ self.assertEqual(display.textual_width(self.u_spanish), 50)
+ self.assertEqual(display.textual_width(self.u_mixed), 23)
def test_textual_width_chop(self):
'''utf8_width_chop with byte strings'''
- tools.eq_(display.textual_width_chop(self.u_mixed, 1000), self.u_mixed)
- tools.eq_(display.textual_width_chop(self.u_mixed, 23), self.u_mixed)
- tools.eq_(display.textual_width_chop(self.u_mixed, 22), self.u_mixed[:-1])
- tools.eq_(display.textual_width_chop(self.u_mixed, 19), self.u_mixed[:-4])
- tools.eq_(display.textual_width_chop(self.u_mixed, 1), '')
- tools.eq_(display.textual_width_chop(self.u_mixed, 2), self.u_mixed[0])
- tools.eq_(display.textual_width_chop(self.u_mixed, 3), self.u_mixed[:2])
- tools.eq_(display.textual_width_chop(self.u_mixed, 4), self.u_mixed[:3])
- tools.eq_(display.textual_width_chop(self.u_mixed, 5), self.u_mixed[:4])
- tools.eq_(display.textual_width_chop(self.u_mixed, 6), self.u_mixed[:5])
- tools.eq_(display.textual_width_chop(self.u_mixed, 7), self.u_mixed[:5])
- tools.eq_(display.textual_width_chop(self.u_mixed, 8), self.u_mixed[:6])
- tools.eq_(display.textual_width_chop(self.u_mixed, 9), self.u_mixed[:7])
- tools.eq_(display.textual_width_chop(self.u_mixed, 10), self.u_mixed[:8])
- tools.eq_(display.textual_width_chop(self.u_mixed, 11), self.u_mixed[:9])
- tools.eq_(display.textual_width_chop(self.u_mixed, 12), self.u_mixed[:10])
- tools.eq_(display.textual_width_chop(self.u_mixed, 13), self.u_mixed[:10])
- tools.eq_(display.textual_width_chop(self.u_mixed, 14), self.u_mixed[:11])
- tools.eq_(display.textual_width_chop(self.u_mixed, 15), self.u_mixed[:12])
- tools.eq_(display.textual_width_chop(self.u_mixed, 16), self.u_mixed[:13])
- tools.eq_(display.textual_width_chop(self.u_mixed, 17), self.u_mixed[:14])
- tools.eq_(display.textual_width_chop(self.u_mixed, 18), self.u_mixed[:15])
- tools.eq_(display.textual_width_chop(self.u_mixed, 19), self.u_mixed[:15])
- tools.eq_(display.textual_width_chop(self.u_mixed, 20), self.u_mixed[:16])
- tools.eq_(display.textual_width_chop(self.u_mixed, 21), self.u_mixed[:17])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 1000), self.u_mixed)
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 23), self.u_mixed)
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 22), self.u_mixed[:-1])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 19), self.u_mixed[:-4])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 1), '')
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 2), self.u_mixed[0])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 3), self.u_mixed[:2])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 4), self.u_mixed[:3])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 5), self.u_mixed[:4])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 6), self.u_mixed[:5])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 7), self.u_mixed[:5])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 8), self.u_mixed[:6])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 9), self.u_mixed[:7])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 10), self.u_mixed[:8])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 11), self.u_mixed[:9])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 12), self.u_mixed[:10])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 13), self.u_mixed[:10])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 14), self.u_mixed[:11])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 15), self.u_mixed[:12])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 16), self.u_mixed[:13])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 17), self.u_mixed[:14])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 18), self.u_mixed[:15])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 19), self.u_mixed[:15])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 20), self.u_mixed[:16])
+ self.assertEqual(display.textual_width_chop(self.u_mixed, 21), self.u_mixed[:17])
def test_textual_width_fill(self):
'''Pad a utf8 string'''
- tools.eq_(display.textual_width_fill(self.u_mixed, 1), self.u_mixed)
- tools.eq_(display.textual_width_fill(self.u_mixed, 25), self.u_mixed + ' ')
- tools.eq_(display.textual_width_fill(self.u_mixed, 25, left=False), ' ' + self.u_mixed)
- tools.eq_(display.textual_width_fill(self.u_mixed, 25, chop=18), self.u_mixed[:-4] + ' ')
- tools.eq_(display.textual_width_fill(self.u_mixed, 25, chop=18, prefix=self.u_spanish, suffix=self.u_spanish), self.u_spanish + self.u_mixed[:-4] + self.u_spanish + ' ')
- tools.eq_(display.textual_width_fill(self.u_mixed, 25, chop=18), self.u_mixed[:-4] + ' ')
- tools.eq_(display.textual_width_fill(self.u_mixed, 25, chop=18, prefix=self.u_spanish, suffix=self.u_spanish), self.u_spanish + self.u_mixed[:-4] + self.u_spanish + ' ')
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 1), self.u_mixed)
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 25), self.u_mixed + ' ')
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 25, left=False), ' ' + self.u_mixed)
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 25, chop=18), self.u_mixed[:-4] + ' ')
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 25, chop=18, prefix=self.u_spanish, suffix=self.u_spanish), self.u_spanish + self.u_mixed[:-4] + self.u_spanish + ' ')
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 25, chop=18), self.u_mixed[:-4] + ' ')
+ self.assertEqual(display.textual_width_fill(self.u_mixed, 25, chop=18, prefix=self.u_spanish, suffix=self.u_spanish), self.u_spanish + self.u_mixed[:-4] + self.u_spanish + ' ')
def test_internal_textual_width_le(self):
test_data = ''.join([self.u_mixed, self.u_spanish])
tw = display.textual_width(test_data)
- tools.eq_(display._textual_width_le(68, self.u_mixed, self.u_spanish), (tw <= 68))
- tools.eq_(display._textual_width_le(69, self.u_mixed, self.u_spanish), (tw <= 69))
- tools.eq_(display._textual_width_le(137, self.u_mixed, self.u_spanish), (tw <= 137))
- tools.eq_(display._textual_width_le(138, self.u_mixed, self.u_spanish), (tw <= 138))
- tools.eq_(display._textual_width_le(78, self.u_mixed, self.u_spanish), (tw <= 78))
- tools.eq_(display._textual_width_le(79, self.u_mixed, self.u_spanish), (tw <= 79))
+ self.assertEqual(display._textual_width_le(68, self.u_mixed, self.u_spanish), (tw <= 68))
+ self.assertEqual(display._textual_width_le(69, self.u_mixed, self.u_spanish), (tw <= 69))
+ self.assertEqual(display._textual_width_le(137, self.u_mixed, self.u_spanish), (tw <= 137))
+ self.assertEqual(display._textual_width_le(138, self.u_mixed, self.u_spanish), (tw <= 138))
+ self.assertEqual(display._textual_width_le(78, self.u_mixed, self.u_spanish), (tw <= 78))
+ self.assertEqual(display._textual_width_le(79, self.u_mixed, self.u_spanish), (tw <= 79))
def test_wrap(self):
'''Test that text wrapping works'''
- tools.eq_(display.wrap(self.u_mixed), [self.u_mixed])
- tools.eq_(display.wrap(self.u_paragraph), self.u_paragraph_out)
- tools.eq_(display.wrap(self.utf8_paragraph), self.u_paragraph_out)
- tools.eq_(display.wrap(self.u_mixed_para), self.u_mixed_para_out)
- tools.eq_(display.wrap(self.u_mixed_para, width=57,
+ self.assertEqual(display.wrap(self.u_mixed), [self.u_mixed])
+ self.assertEqual(display.wrap(self.u_paragraph), self.u_paragraph_out)
+ self.assertEqual(display.wrap(self.utf8_paragraph), self.u_paragraph_out)
+ self.assertEqual(display.wrap(self.u_mixed_para), self.u_mixed_para_out)
+ self.assertEqual(display.wrap(self.u_mixed_para, width=57,
initial_indent=' ', subsequent_indent='----'),
self.u_mixed_para_57_initial_subsequent_out)
def test_fill(self):
- tools.eq_(display.fill(self.u_paragraph), '\n'.join(self.u_paragraph_out))
- tools.eq_(display.fill(self.utf8_paragraph), '\n'.join(self.u_paragraph_out))
- tools.eq_(display.fill(self.u_mixed_para), '\n'.join(self.u_mixed_para_out))
- tools.eq_(display.fill(self.u_mixed_para, width=57,
+ self.assertEqual(display.fill(self.u_paragraph), '\n'.join(self.u_paragraph_out))
+ self.assertEqual(display.fill(self.utf8_paragraph), '\n'.join(self.u_paragraph_out))
+ self.assertEqual(display.fill(self.u_mixed_para), '\n'.join(self.u_mixed_para_out))
+ self.assertEqual(display.fill(self.u_mixed_para, width=57,
initial_indent=' ', subsequent_indent='----'),
'\n'.join(self.u_mixed_para_57_initial_subsequent_out))
def test_byte_string_textual_width_fill(self):
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 1), self.utf8_mixed)
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 25), self.utf8_mixed + b' ')
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 25, left=False), b' ' + self.utf8_mixed)
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18), self.u_mixed[:-4].encode('utf8') + b' ')
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18, prefix=self.utf8_spanish, suffix=self.utf8_spanish), self.utf8_spanish + self.u_mixed[:-4].encode('utf8') + self.utf8_spanish + b' ')
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18), self.u_mixed[:-4].encode('utf8') + b' ')
- tools.eq_(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18, prefix=self.utf8_spanish, suffix=self.utf8_spanish), self.utf8_spanish + self.u_mixed[:-4].encode('utf8') + self.utf8_spanish + b' ')
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 1), self.utf8_mixed)
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 25), self.utf8_mixed + b' ')
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 25, left=False), b' ' + self.utf8_mixed)
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18), self.u_mixed[:-4].encode('utf8') + b' ')
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18, prefix=self.utf8_spanish, suffix=self.utf8_spanish), self.utf8_spanish + self.u_mixed[:-4].encode('utf8') + self.utf8_spanish + b' ')
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18), self.u_mixed[:-4].encode('utf8') + b' ')
+ self.assertEqual(display.byte_string_textual_width_fill(self.utf8_mixed, 25, chop=18, prefix=self.utf8_spanish, suffix=self.utf8_spanish), self.utf8_spanish + self.u_mixed[:-4].encode('utf8') + self.utf8_spanish + b' ')
Index: kitchen-1.2.6/kitchen3/tests/test_text_misc.py
===================================================================
--- kitchen-1.2.6.orig/kitchen3/tests/test_text_misc.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen3/tests/test_text_misc.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,8 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
-from nose.plugins.skip import SkipTest
try:
import chardet
@@ -18,136 +16,136 @@ import base_classes
class TestTextMisc(unittest.TestCase, base_classes.UnicodeTestData):
def test_guess_encoding_no_chardet(self):
# Test that unicode strings are not allowed
- tools.assert_raises(TypeError, misc.guess_encoding, self.u_spanish)
+ self.assertRaises(TypeError, misc.guess_encoding, self.u_spanish)
- tools.ok_(misc.guess_encoding(self.utf8_spanish, disable_chardet=True) == 'utf-8')
- tools.ok_(misc.guess_encoding(self.latin1_spanish, disable_chardet=True) == 'latin-1')
- tools.ok_(misc.guess_encoding(self.utf8_japanese, disable_chardet=True) == 'utf-8')
- tools.ok_(misc.guess_encoding(self.euc_jp_japanese, disable_chardet=True) == 'latin-1')
+ self.assertTrue(misc.guess_encoding(self.utf8_spanish, disable_chardet=True) == 'utf-8')
+ self.assertTrue(misc.guess_encoding(self.latin1_spanish, disable_chardet=True) == 'latin-1')
+ self.assertTrue(misc.guess_encoding(self.utf8_japanese, disable_chardet=True) == 'utf-8')
+ self.assertTrue(misc.guess_encoding(self.euc_jp_japanese, disable_chardet=True) == 'latin-1')
def test_guess_encoding_with_chardet(self):
# We go this slightly roundabout way because multiple encodings can
# output the same byte sequence. What we're really interested in is
# if we can get the original unicode string without knowing the
# converters beforehand
- tools.ok_(to_unicode(self.utf8_spanish,
+ self.assertTrue(to_unicode(self.utf8_spanish,
misc.guess_encoding(self.utf8_spanish)) == self.u_spanish)
- tools.ok_(to_unicode(self.latin1_spanish,
+ self.assertTrue(to_unicode(self.latin1_spanish,
misc.guess_encoding(self.latin1_spanish)) == self.u_spanish)
- tools.ok_(to_unicode(self.utf8_japanese,
+ self.assertTrue(to_unicode(self.utf8_japanese,
misc.guess_encoding(self.utf8_japanese)) == self.u_japanese)
def test_guess_encoding_with_chardet_installed(self):
if chardet:
- tools.ok_(to_unicode(self.euc_jp_japanese,
+ self.assertTrue(to_unicode(self.euc_jp_japanese,
misc.guess_encoding(self.euc_jp_japanese)) == self.u_japanese)
else:
- raise SkipTest('chardet not installed, euc_jp will not be guessed correctly')
+ self.skipTest('chardet not installed, euc_jp will not be guessed correctly')
def test_guess_encoding_with_chardet_uninstalled(self):
if chardet:
- raise SkipTest('chardet installed, euc_jp will not be mangled')
+ self.skipTest('chardet installed, euc_jp will not be mangled')
else:
- tools.ok_(to_unicode(self.euc_jp_japanese,
+ self.assertTrue(to_unicode(self.euc_jp_japanese,
misc.guess_encoding(self.euc_jp_japanese)) ==
self.u_mangled_euc_jp_as_latin1)
def test_str_eq(self):
# str vs str:
- tools.ok_(misc.str_eq(self.euc_jp_japanese, self.euc_jp_japanese) == True)
- tools.ok_(misc.str_eq(self.utf8_japanese, self.utf8_japanese) == True)
- tools.ok_(misc.str_eq(self.b_ascii, self.b_ascii) == True)
- tools.ok_(misc.str_eq(self.euc_jp_japanese, self.latin1_spanish) == False)
- tools.ok_(misc.str_eq(self.utf8_japanese, self.euc_jp_japanese) == False)
- tools.ok_(misc.str_eq(self.b_ascii, self.b_ascii[:-2]) == False)
+ self.assertTrue(misc.str_eq(self.euc_jp_japanese, self.euc_jp_japanese) == True)
+ self.assertTrue(misc.str_eq(self.utf8_japanese, self.utf8_japanese) == True)
+ self.assertTrue(misc.str_eq(self.b_ascii, self.b_ascii) == True)
+ self.assertTrue(misc.str_eq(self.euc_jp_japanese, self.latin1_spanish) == False)
+ self.assertTrue(misc.str_eq(self.utf8_japanese, self.euc_jp_japanese) == False)
+ self.assertTrue(misc.str_eq(self.b_ascii, self.b_ascii[:-2]) == False)
# unicode vs unicode:
- tools.ok_(misc.str_eq(self.u_japanese, self.u_japanese) == True)
- tools.ok_(misc.str_eq(self.u_ascii, self.u_ascii) == True)
- tools.ok_(misc.str_eq(self.u_japanese, self.u_spanish) == False)
- tools.ok_(misc.str_eq(self.u_ascii, self.u_ascii[:-2]) == False)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.u_japanese) == True)
+ self.assertTrue(misc.str_eq(self.u_ascii, self.u_ascii) == True)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.u_spanish) == False)
+ self.assertTrue(misc.str_eq(self.u_ascii, self.u_ascii[:-2]) == False)
# unicode vs str with default utf-8 conversion:
- tools.ok_(misc.str_eq(self.u_japanese, self.utf8_japanese) == True)
- tools.ok_(misc.str_eq(self.u_ascii, self.b_ascii) == True)
- tools.ok_(misc.str_eq(self.u_japanese, self.euc_jp_japanese) == False)
- tools.ok_(misc.str_eq(self.u_ascii, self.b_ascii[:-2]) == False)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.utf8_japanese) == True)
+ self.assertTrue(misc.str_eq(self.u_ascii, self.b_ascii) == True)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.euc_jp_japanese) == False)
+ self.assertTrue(misc.str_eq(self.u_ascii, self.b_ascii[:-2]) == False)
# unicode vs str with explicit encodings:
- tools.ok_(misc.str_eq(self.u_japanese, self.euc_jp_japanese, encoding='euc_jp') == True)
- tools.ok_(misc.str_eq(self.u_japanese, self.utf8_japanese, encoding='utf8') == True)
- tools.ok_(misc.str_eq(self.u_ascii, self.b_ascii, encoding='latin1') == True)
- tools.ok_(misc.str_eq(self.u_japanese, self.euc_jp_japanese, encoding='latin1') == False)
- tools.ok_(misc.str_eq(self.u_japanese, self.utf8_japanese, encoding='euc_jp') == False)
- tools.ok_(misc.str_eq(self.u_japanese, self.utf8_japanese, encoding='euc_jp') == False)
- tools.ok_(misc.str_eq(self.u_ascii, self.b_ascii[:-2], encoding='latin1') == False)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.euc_jp_japanese, encoding='euc_jp') == True)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.utf8_japanese, encoding='utf8') == True)
+ self.assertTrue(misc.str_eq(self.u_ascii, self.b_ascii, encoding='latin1') == True)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.euc_jp_japanese, encoding='latin1') == False)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.utf8_japanese, encoding='euc_jp') == False)
+ self.assertTrue(misc.str_eq(self.u_japanese, self.utf8_japanese, encoding='euc_jp') == False)
+ self.assertTrue(misc.str_eq(self.u_ascii, self.b_ascii[:-2], encoding='latin1') == False)
# str vs unicode (reverse parameter order of unicode vs str)
- tools.ok_(misc.str_eq(self.utf8_japanese, self.u_japanese) == True)
- tools.ok_(misc.str_eq(self.b_ascii, self.u_ascii) == True)
- tools.ok_(misc.str_eq(self.euc_jp_japanese, self.u_japanese) == False)
- tools.ok_(misc.str_eq(self.b_ascii, self.u_ascii[:-2]) == False)
-
- tools.ok_(misc.str_eq(self.euc_jp_japanese, self.u_japanese, encoding='euc_jp') == True)
- tools.ok_(misc.str_eq(self.utf8_japanese, self.u_japanese, encoding='utf8') == True)
- tools.ok_(misc.str_eq(self.b_ascii, self.u_ascii, encoding='latin1') == True)
- tools.ok_(misc.str_eq(self.euc_jp_japanese, self.u_japanese, encoding='latin1') == False)
- tools.ok_(misc.str_eq(self.utf8_japanese, self.u_japanese, encoding='euc_jp') == False)
- tools.ok_(misc.str_eq(self.utf8_japanese, self.u_japanese, encoding='euc_jp') == False)
- tools.ok_(misc.str_eq(self.b_ascii, self.u_ascii[:-2], encoding='latin1') == False)
+ self.assertTrue(misc.str_eq(self.utf8_japanese, self.u_japanese) == True)
+ self.assertTrue(misc.str_eq(self.b_ascii, self.u_ascii) == True)
+ self.assertTrue(misc.str_eq(self.euc_jp_japanese, self.u_japanese) == False)
+ self.assertTrue(misc.str_eq(self.b_ascii, self.u_ascii[:-2]) == False)
+
+ self.assertTrue(misc.str_eq(self.euc_jp_japanese, self.u_japanese, encoding='euc_jp') == True)
+ self.assertTrue(misc.str_eq(self.utf8_japanese, self.u_japanese, encoding='utf8') == True)
+ self.assertTrue(misc.str_eq(self.b_ascii, self.u_ascii, encoding='latin1') == True)
+ self.assertTrue(misc.str_eq(self.euc_jp_japanese, self.u_japanese, encoding='latin1') == False)
+ self.assertTrue(misc.str_eq(self.utf8_japanese, self.u_japanese, encoding='euc_jp') == False)
+ self.assertTrue(misc.str_eq(self.utf8_japanese, self.u_japanese, encoding='euc_jp') == False)
+ self.assertTrue(misc.str_eq(self.b_ascii, self.u_ascii[:-2], encoding='latin1') == False)
def test_process_control_chars(self):
- tools.assert_raises(TypeError, misc.process_control_chars, b'byte string')
- tools.assert_raises(ControlCharError, misc.process_control_chars,
+ self.assertRaises(TypeError, misc.process_control_chars, b'byte string')
+ self.assertRaises(ControlCharError, misc.process_control_chars,
*[self.u_ascii_chars], **{'strategy': 'strict'})
- tools.ok_(misc.process_control_chars(self.u_ascii_chars,
+ self.assertTrue(misc.process_control_chars(self.u_ascii_chars,
strategy='ignore') == self.u_ascii_no_ctrl)
- tools.ok_(misc.process_control_chars(self.u_ascii_chars,
+ self.assertTrue(misc.process_control_chars(self.u_ascii_chars,
strategy='replace') == self.u_ascii_ctrl_replace)
def test_html_entities_unescape(self):
- tools.assert_raises(TypeError, misc.html_entities_unescape, b'byte string')
- tools.ok_(misc.html_entities_unescape(self.u_entity_escape) == self.u_entity)
- tools.ok_(misc.html_entities_unescape('<tag>%s</tag>'
+ self.assertRaises(TypeError, misc.html_entities_unescape, b'byte string')
+ self.assertTrue(misc.html_entities_unescape(self.u_entity_escape) == self.u_entity)
+ self.assertTrue(misc.html_entities_unescape('<tag>%s</tag>'
% self.u_entity_escape) == self.u_entity)
- tools.ok_(misc.html_entities_unescape('a�b') == 'a�b')
- tools.ok_(misc.html_entities_unescape('a�b') == 'a\ufffdb')
- tools.ok_(misc.html_entities_unescape('a�b') == 'a\ufffdb')
+ self.assertTrue(misc.html_entities_unescape('a�b') == 'a�b')
+ self.assertTrue(misc.html_entities_unescape('a�b') == 'a\ufffdb')
+ self.assertTrue(misc.html_entities_unescape('a�b') == 'a\ufffdb')
def test_byte_string_valid_xml(self):
- tools.ok_(misc.byte_string_valid_xml('unicode string') == False)
+ self.assertTrue(misc.byte_string_valid_xml('unicode string') == False)
- tools.ok_(misc.byte_string_valid_xml(self.utf8_japanese))
- tools.ok_(misc.byte_string_valid_xml(self.euc_jp_japanese, 'euc_jp'))
+ self.assertTrue(misc.byte_string_valid_xml(self.utf8_japanese))
+ self.assertTrue(misc.byte_string_valid_xml(self.euc_jp_japanese, 'euc_jp'))
- tools.ok_(misc.byte_string_valid_xml(self.utf8_japanese, 'euc_jp') == False)
- tools.ok_(misc.byte_string_valid_xml(self.euc_jp_japanese, 'utf8') == False)
+ self.assertTrue(misc.byte_string_valid_xml(self.utf8_japanese, 'euc_jp') == False)
+ self.assertTrue(misc.byte_string_valid_xml(self.euc_jp_japanese, 'utf8') == False)
- tools.ok_(misc.byte_string_valid_xml(self.utf8_ascii_chars) == False)
+ self.assertTrue(misc.byte_string_valid_xml(self.utf8_ascii_chars) == False)
def test_byte_string_valid_encoding(self):
'''Test that a byte sequence is validated'''
- tools.ok_(misc.byte_string_valid_encoding(self.utf8_japanese) == True)
- tools.ok_(misc.byte_string_valid_encoding(self.euc_jp_japanese, encoding='euc_jp') == True)
+ self.assertTrue(misc.byte_string_valid_encoding(self.utf8_japanese) == True)
+ self.assertTrue(misc.byte_string_valid_encoding(self.euc_jp_japanese, encoding='euc_jp') == True)
def test_byte_string_invalid_encoding(self):
'''Test that we return False with non-encoded chars'''
- tools.ok_(misc.byte_string_valid_encoding(b'\xff') == False)
- tools.ok_(misc.byte_string_valid_encoding(self.euc_jp_japanese) == False)
+ self.assertTrue(misc.byte_string_valid_encoding(b'\xff') == False)
+ self.assertTrue(misc.byte_string_valid_encoding(self.euc_jp_japanese) == False)
class TestIsStringTypes(unittest.TestCase):
def test_isbasestring(self):
- tools.assert_true(misc.isbasestring(b'abc'))
- tools.assert_true(misc.isbasestring('abc'))
- tools.assert_false(misc.isbasestring(5))
+ self.assertTrue(misc.isbasestring(b'abc'))
+ self.assertTrue(misc.isbasestring('abc'))
+ self.assertFalse(misc.isbasestring(5))
def test_isbytestring(self):
- tools.assert_true(misc.isbytestring(b'abc'))
- tools.assert_false(misc.isbytestring('abc'))
- tools.assert_false(misc.isbytestring(5))
+ self.assertTrue(misc.isbytestring(b'abc'))
+ self.assertFalse(misc.isbytestring('abc'))
+ self.assertFalse(misc.isbytestring(5))
def test_isunicodestring(self):
- tools.assert_false(misc.isunicodestring(b'abc'))
- tools.assert_true(misc.isunicodestring('abc'))
- tools.assert_false(misc.isunicodestring(5))
+ self.assertFalse(misc.isunicodestring(b'abc'))
+ self.assertTrue(misc.isunicodestring('abc'))
+ self.assertFalse(misc.isunicodestring(5))
Index: kitchen-1.2.6/kitchen3/tests/test_text_utf8.py
===================================================================
--- kitchen-1.2.6.orig/kitchen3/tests/test_text_utf8.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen3/tests/test_text_utf8.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
#
import unittest
-from nose import tools
import warnings
@@ -19,9 +18,9 @@ class TestUTF8(base_classes.UnicodeTestD
def test_utf8_width(self):
'''Test that we find the proper number of spaces that a utf8 string will consume'''
- tools.ok_(utf8.utf8_width(self.utf8_japanese) == 31)
- tools.ok_(utf8.utf8_width(self.utf8_spanish) == 50)
- tools.ok_(utf8.utf8_width(self.utf8_mixed) == 23)
+ self.assertTrue(utf8.utf8_width(self.utf8_japanese) == 31)
+ self.assertTrue(utf8.utf8_width(self.utf8_spanish) == 50)
+ self.assertTrue(utf8.utf8_width(self.utf8_mixed) == 23)
def test_utf8_width_non_utf8(self):
'''Test that we handle non-utf8 bytes in utf8_width without backtracing'''
@@ -35,58 +34,58 @@ class TestUTF8(base_classes.UnicodeTestD
# El veloz murci�go salt�bre el perro perezoso.
if len(str('\xe9la'.encode('latin1'), 'utf8', 'replace')) == 1:
# Python < 2.7
- tools.ok_(utf8.utf8_width(self.latin1_spanish) == 45)
+ self.assertTrue(utf8.utf8_width(self.latin1_spanish) == 45)
else:
# Python >= 2.7
- tools.ok_(utf8.utf8_width(self.latin1_spanish) == 50)
+ self.assertTrue(utf8.utf8_width(self.latin1_spanish) == 50)
def test_utf8_width_chop(self):
'''utf8_width_chop with byte strings'''
- tools.ok_(utf8.utf8_width_chop(self.utf8_mixed) == (23, self.utf8_mixed))
- tools.ok_(utf8.utf8_width_chop(self.utf8_mixed, 23) == (23, self.utf8_mixed))
- tools.ok_(utf8.utf8_width_chop(self.utf8_mixed, 22) == (22, self.utf8_mixed[:-1]))
- tools.ok_(utf8.utf8_width_chop(self.utf8_mixed, 19) == (18, self.u_mixed[:-4].encode('utf8')))
- tools.ok_(utf8.utf8_width_chop(self.utf8_mixed, 2) == (2, self.u_mixed[0].encode('utf8')))
- tools.ok_(utf8.utf8_width_chop(self.utf8_mixed, 1) == (0, b''))
+ self.assertTrue(utf8.utf8_width_chop(self.utf8_mixed) == (23, self.utf8_mixed))
+ self.assertTrue(utf8.utf8_width_chop(self.utf8_mixed, 23) == (23, self.utf8_mixed))
+ self.assertTrue(utf8.utf8_width_chop(self.utf8_mixed, 22) == (22, self.utf8_mixed[:-1]))
+ self.assertTrue(utf8.utf8_width_chop(self.utf8_mixed, 19) == (18, self.u_mixed[:-4].encode('utf8')))
+ self.assertTrue(utf8.utf8_width_chop(self.utf8_mixed, 2) == (2, self.u_mixed[0].encode('utf8')))
+ self.assertTrue(utf8.utf8_width_chop(self.utf8_mixed, 1) == (0, b''))
def test_utf8_width_chop_unicode(self):
'''utf8_width_chop with unicode input'''
- tools.ok_(utf8.utf8_width_chop(self.u_mixed) == (23, self.u_mixed))
- tools.ok_(utf8.utf8_width_chop(self.u_mixed, 23) == (23, self.u_mixed))
- tools.ok_(utf8.utf8_width_chop(self.u_mixed, 22) == (22, self.u_mixed[:-1]))
- tools.ok_(utf8.utf8_width_chop(self.u_mixed, 19) == (18, self.u_mixed[:-4]))
- tools.ok_(utf8.utf8_width_chop(self.u_mixed, 2) == (2, self.u_mixed[0]))
- tools.ok_(utf8.utf8_width_chop(self.u_mixed, 1), (0, ''))
+ self.assertTrue(utf8.utf8_width_chop(self.u_mixed) == (23, self.u_mixed))
+ self.assertTrue(utf8.utf8_width_chop(self.u_mixed, 23) == (23, self.u_mixed))
+ self.assertTrue(utf8.utf8_width_chop(self.u_mixed, 22) == (22, self.u_mixed[:-1]))
+ self.assertTrue(utf8.utf8_width_chop(self.u_mixed, 19) == (18, self.u_mixed[:-4]))
+ self.assertTrue(utf8.utf8_width_chop(self.u_mixed, 2) == (2, self.u_mixed[0]))
+ self.assertTrue(utf8.utf8_width_chop(self.u_mixed, 1), (0, ''))
def test_utf8_width_fill(self):
'''Pad a utf8 string'''
- tools.ok_(utf8.utf8_width_fill(self.utf8_mixed, 1) == self.utf8_mixed)
- tools.ok_(utf8.utf8_width_fill(self.utf8_mixed, 25) == self.utf8_mixed + b' ')
- tools.ok_(utf8.utf8_width_fill(self.utf8_mixed, 25, left=False) == b' ' + self.utf8_mixed)
- tools.ok_(utf8.utf8_width_fill(self.utf8_mixed, 25, chop=18) == self.u_mixed[:-4].encode('utf8') + b' ')
- tools.ok_(utf8.utf8_width_fill(self.utf8_mixed, 25, chop=18, prefix=self.utf8_spanish, suffix=self.utf8_spanish) == self.utf8_spanish + self.u_mixed[:-4].encode('utf8') + self.utf8_spanish + b' ')
- tools.ok_(utf8.utf8_width_fill(self.utf8_mixed, 25, chop=18) == self.u_mixed[:-4].encode('utf8') + b' ')
- tools.ok_(utf8.utf8_width_fill(self.u_mixed, 25, chop=18, prefix=self.u_spanish, suffix=self.utf8_spanish) == self.u_spanish.encode('utf8') + self.u_mixed[:-4].encode('utf8') + self.u_spanish.encode('utf8') + b' ')
+ self.assertTrue(utf8.utf8_width_fill(self.utf8_mixed, 1) == self.utf8_mixed)
+ self.assertTrue(utf8.utf8_width_fill(self.utf8_mixed, 25) == self.utf8_mixed + b' ')
+ self.assertTrue(utf8.utf8_width_fill(self.utf8_mixed, 25, left=False) == b' ' + self.utf8_mixed)
+ self.assertTrue(utf8.utf8_width_fill(self.utf8_mixed, 25, chop=18) == self.u_mixed[:-4].encode('utf8') + b' ')
+ self.assertTrue(utf8.utf8_width_fill(self.utf8_mixed, 25, chop=18, prefix=self.utf8_spanish, suffix=self.utf8_spanish) == self.utf8_spanish + self.u_mixed[:-4].encode('utf8') + self.utf8_spanish + b' ')
+ self.assertTrue(utf8.utf8_width_fill(self.utf8_mixed, 25, chop=18) == self.u_mixed[:-4].encode('utf8') + b' ')
+ self.assertTrue(utf8.utf8_width_fill(self.u_mixed, 25, chop=18, prefix=self.u_spanish, suffix=self.utf8_spanish) == self.u_spanish.encode('utf8') + self.u_mixed[:-4].encode('utf8') + self.u_spanish.encode('utf8') + b' ')
pass
def test_utf8_valid(self):
'''Test that a utf8 byte sequence is validated'''
warnings.simplefilter('ignore', DeprecationWarning)
- tools.ok_(utf8.utf8_valid(self.utf8_japanese) == True)
- tools.ok_(utf8.utf8_valid(self.utf8_spanish) == True)
+ self.assertTrue(utf8.utf8_valid(self.utf8_japanese) == True)
+ self.assertTrue(utf8.utf8_valid(self.utf8_spanish) == True)
warnings.simplefilter('default', DeprecationWarning)
def test_utf8_invalid(self):
'''Test that we return False with non-utf8 chars'''
warnings.simplefilter('ignore', DeprecationWarning)
- tools.ok_(utf8.utf8_valid(b'\xff') == False)
- tools.ok_(utf8.utf8_valid(self.latin1_spanish) == False)
+ self.assertTrue(utf8.utf8_valid(b'\xff') == False)
+ self.assertTrue(utf8.utf8_valid(self.latin1_spanish) == False)
warnings.simplefilter('default', DeprecationWarning)
def test_utf8_text_wrap(self):
- tools.ok_(utf8.utf8_text_wrap(self.utf8_mixed) == [self.utf8_mixed])
- tools.ok_(utf8.utf8_text_wrap(self.utf8_paragraph) == self.utf8_paragraph_out)
- tools.ok_(utf8.utf8_text_wrap(self.utf8_mixed_para) == self.utf8_mixed_para_out)
- tools.ok_(utf8.utf8_text_wrap(self.utf8_mixed_para, width=57,
+ self.assertTrue(utf8.utf8_text_wrap(self.utf8_mixed) == [self.utf8_mixed])
+ self.assertTrue(utf8.utf8_text_wrap(self.utf8_paragraph) == self.utf8_paragraph_out)
+ self.assertTrue(utf8.utf8_text_wrap(self.utf8_mixed_para) == self.utf8_mixed_para_out)
+ self.assertTrue(utf8.utf8_text_wrap(self.utf8_mixed_para, width=57,
initial_indent=b' ', subsequent_indent=b'----') ==
self.utf8_mixed_para_57_initial_subsequent_out)
Index: kitchen-1.2.6/kitchen3/tests/test_versioning.py
===================================================================
--- kitchen-1.2.6.orig/kitchen3/tests/test_versioning.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen3/tests/test_versioning.py 2020-09-09 14:50:23.914571774 +0200
@@ -1,12 +1,13 @@
# -*- coding: utf-8 -*-
#
-from nose import tools
+
+import unittest
from kitchen.versioning import version_tuple_to_string
# Note: Using nose's generator tests for this so we can't subclass
# unittest.TestCase
-class TestVersionTuple(object):
+class TestVersionTuple(unittest.TestCase):
ver_to_tuple = {'1': ((1,),),
'1.0': ((1, 0),),
'1.0.0': ((1, 0, 0),),
@@ -25,7 +26,7 @@ class TestVersionTuple(object):
}
def check_ver_tuple_to_str(self, v_tuple, v_str):
- tools.eq_(version_tuple_to_string(v_tuple), v_str)
+ self.assertEqual(version_tuple_to_string(v_tuple), v_str)
def test_version_tuple_to_string(self):
'''Test that version_tuple_to_string outputs PEP-386 compliant strings
Index: kitchen-1.2.6/kitchen2/tests/test_subprocess.py
===================================================================
--- kitchen-1.2.6.orig/kitchen2/tests/test_subprocess.py 2019-05-14 21:47:33.000000000 +0200
+++ kitchen-1.2.6/kitchen2/tests/test_subprocess.py 2020-09-09 14:50:38.670660921 +0200
@@ -1,5 +1,4 @@
import unittest
-from nose.plugins.skip import SkipTest
from kitchen.pycompat27.subprocess import _subprocess as subprocess
import sys
import StringIO
@@ -481,7 +480,7 @@ class ProcessTestCase(BaseTestCase):
# Test for the fd leak reported in http://bugs.python.org/issue2791.
def test_communicate_pipe_fd_leak(self):
if not os.path.isdir('/proc/%d/fd' % os.getpid()):
- raise SkipTest('Linux specific')
+ self.skipTest('Linux specific')
fd_directory = '/proc/%d/fd' % os.getpid()
num_fds_before_popen = len(os.listdir(fd_directory))
p = subprocess.Popen([sys.executable, "-c", "print()"],
@@ -602,7 +601,7 @@ class ProcessTestCase(BaseTestCase):
def test_no_leaking(self):
if not test_support:
- raise SkipTest("No test_support module available.")
+ self.skipTest("No test_support module available.")
# Make sure we leak no resources
if not mswindows:
@@ -623,7 +622,7 @@ class ProcessTestCase(BaseTestCase):
# python-2.3 unittest doesn't have skipTest. Reimplement with nose
#self.skipTest("failed to reach the file descriptor limit "
# "(tried %d)" % max_handles)
- raise SkipTest("failed to reach the file descriptor limit "
+ self.skipTest("failed to reach the file descriptor limit "
"(tried %d)" % max_handles)
# Close a couple of them (should be enough for a subprocess)
@@ -805,7 +804,7 @@ class _SuppressCoreFiles(object):
# "Requires signal.SIGALRM")
def test_communicate_eintr(self):
if not hasattr(signal, 'SIGALRM'):
- raise SkipTest('Requires signal.SIGALRM')
+ self.skipTest('Requires signal.SIGALRM')
# Issue #12493: communicate() should handle EINTR
def handler(signum, frame):
pass
@@ -832,7 +831,7 @@ class _SuppressCoreFiles(object):
class POSIXProcessTestCase(BaseTestCase):
def setUp(self):
if mswindows:
- raise SkipTest('POSIX specific tests')
+ self.skipTest('POSIX specific tests')
def test_exceptions(self):
# caught & re-raised exceptions
@@ -965,7 +964,7 @@ class POSIXProcessTestCase(BaseTestCase)
# skipTest unavailable on python<2.7 reimplement with nose
#self.skipTest("bash or ksh required for this test")
- raise SkipTest("bash or ksh required for this test")
+ self.skipTest("bash or ksh required for this test")
sh = '/bin/sh'
if os.path.isfile(sh) and not os.path.islink(sh):
# Test will fail if /bin/sh is a symlink to csh.
@@ -1132,7 +1131,7 @@ class POSIXProcessTestCase(BaseTestCase)
def test_wait_when_sigchild_ignored(self):
# NOTE: sigchild_ignore.py may not be an effective test on all OSes.
if not test_support:
- raise SkipTest("No test_support module available.")
+ self.skipTest("No test_support module available.")
sigchild_ignore = test_support.findfile(os.path.join("subprocessdata",
"sigchild_ignore.py"))
p = subprocess.Popen([sys.executable, sigchild_ignore],
@@ -1252,7 +1251,7 @@ class POSIXProcessTestCase(BaseTestCase)
class Win32ProcessTestCase(BaseTestCase):
def setUp(self):
if not mswindows:
- raise SkipTest('Windows specific tests')
+ self.skipTest('Windows specific tests')
def test_startupinfo(self):
# startupinfo argument
@@ -1367,7 +1366,7 @@ class Win32ProcessTestCase(BaseTestCase)
class ProcessTestCaseNoPoll(ProcessTestCase):
def setUp(self):
if not getattr(subprocess, '_has_poll', False):
- raise SkipTest('poll system call not supported')
+ self.skipTest('poll system call not supported')
subprocess._has_poll = False
ProcessTestCase.setUp(self)
@@ -1382,7 +1381,7 @@ class HelperFunctionTests(unittest.TestC
#@unittest.skipIf(mswindows, "errno and EINTR make no sense on windows")
def test_eintr_retry_call(self):
if mswindows:
- raise SkipTest('errno and EINTR make no sense on windows')
+ self.skipTest('errno and EINTR make no sense on windows')
record_calls = []
def fake_os_func(*args):
record_calls.append(args)
@@ -1408,7 +1407,7 @@ class CommandsWithSpaces (BaseTestCase):
def setUp(self):
if not mswindows:
- raise SkipTest('mswindows only')
+ self.skipTest('mswindows only')
super(CommandsWithSpaces, self).setUp()
f, fname = mkstemp(".py", "te st")
