Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
openSUSE:Factory:Rebuild
python-kitchen
python-kitchen-remove-nose.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
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")
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
