From 7c5e24f948e6ce33e21b09833f8fe3a8eb1530ac Mon Sep 17 00:00:00 2001 From: Serhiy Storchaka Date: Sat, 16 Nov 2013 23:51:26 +0200 Subject: [PATCH] Issue #19591: Use specific asserts in ctype tests. --- Lib/ctypes/test/test_arrays.py | 6 ++-- Lib/ctypes/test/test_as_parameter.py | 2 +- Lib/ctypes/test/test_buffers.py | 10 +++--- Lib/ctypes/test/test_byteswap.py | 52 ++++++++++++++-------------- Lib/ctypes/test/test_cast.py | 6 ++-- Lib/ctypes/test/test_frombuffer.py | 2 +- Lib/ctypes/test/test_funcptr.py | 2 +- Lib/ctypes/test/test_functions.py | 2 +- Lib/ctypes/test/test_loading.py | 2 +- Lib/ctypes/test/test_numbers.py | 6 ++-- Lib/ctypes/test/test_parameters.py | 4 +-- Lib/ctypes/test/test_pointers.py | 8 ++--- Lib/ctypes/test/test_python_api.py | 2 +- Lib/ctypes/test/test_refcounts.py | 14 ++++---- Lib/ctypes/test/test_strings.py | 38 ++++++++++---------- Lib/ctypes/test/test_structures.py | 13 ++++--- 16 files changed, 84 insertions(+), 85 deletions(-) diff --git a/Lib/ctypes/test/test_arrays.py b/Lib/ctypes/test/test_arrays.py index cfc219e56bb..99b97aa7d8a 100644 --- a/Lib/ctypes/test/test_arrays.py +++ b/Lib/ctypes/test/test_arrays.py @@ -84,8 +84,8 @@ class ArrayTestCase(unittest.TestCase): self.assertEqual(values, [1, 2, 3, 4, 5]) def test_classcache(self): - self.assertTrue(not ARRAY(c_int, 3) is ARRAY(c_int, 4)) - self.assertTrue(ARRAY(c_int, 3) is ARRAY(c_int, 3)) + self.assertIsNot(ARRAY(c_int, 3), ARRAY(c_int, 4)) + self.assertIs(ARRAY(c_int, 3), ARRAY(c_int, 3)) def test_from_address(self): # Failed with 0.9.8, reported by JUrner @@ -125,7 +125,7 @@ class ArrayTestCase(unittest.TestCase): # Create a new array type based on it: t1 = my_int * 1 t2 = my_int * 1 - self.assertTrue(t1 is t2) + self.assertIs(t1, t2) def test_subclass(self): class T(Array): diff --git a/Lib/ctypes/test/test_as_parameter.py b/Lib/ctypes/test/test_as_parameter.py index 2657a66d112..43703e3b6ea 100644 --- a/Lib/ctypes/test/test_as_parameter.py +++ b/Lib/ctypes/test/test_as_parameter.py @@ -134,7 +134,7 @@ class BasicWrapTestCase(unittest.TestCase): f.argtypes = [c_longlong, MyCallback] def callback(value): - self.assertTrue(isinstance(value, int)) + self.assertIsInstance(value, int) return value & 0x7FFFFFFF cb = MyCallback(callback) diff --git a/Lib/ctypes/test/test_buffers.py b/Lib/ctypes/test/test_buffers.py index 2dc74841c49..0d12f47afef 100644 --- a/Lib/ctypes/test/test_buffers.py +++ b/Lib/ctypes/test/test_buffers.py @@ -7,12 +7,12 @@ class StringBufferTestCase(unittest.TestCase): b = create_string_buffer(32) self.assertEqual(len(b), 32) self.assertEqual(sizeof(b), 32 * sizeof(c_char)) - self.assertTrue(type(b[0]) is bytes) + self.assertIs(type(b[0]), bytes) b = create_string_buffer(b"abc") self.assertEqual(len(b), 4) # trailing nul char self.assertEqual(sizeof(b), 4 * sizeof(c_char)) - self.assertTrue(type(b[0]) is bytes) + self.assertIs(type(b[0]), bytes) self.assertEqual(b[0], b"a") self.assertEqual(b[:], b"abc\0") self.assertEqual(b[::], b"abc\0") @@ -33,12 +33,12 @@ class StringBufferTestCase(unittest.TestCase): b = create_unicode_buffer(32) self.assertEqual(len(b), 32) self.assertEqual(sizeof(b), 32 * sizeof(c_wchar)) - self.assertTrue(type(b[0]) is str) + self.assertIs(type(b[0]), str) b = create_unicode_buffer("abc") self.assertEqual(len(b), 4) # trailing nul char self.assertEqual(sizeof(b), 4 * sizeof(c_wchar)) - self.assertTrue(type(b[0]) is str) + self.assertIs(type(b[0]), str) self.assertEqual(b[0], "a") self.assertEqual(b[:], "abc\0") self.assertEqual(b[::], "abc\0") @@ -50,7 +50,7 @@ class StringBufferTestCase(unittest.TestCase): b = create_unicode_buffer("abc") self.assertEqual(len(b), 4) # trailing nul char self.assertEqual(sizeof(b), 4 * sizeof(c_wchar)) - self.assertTrue(type(b[0]) is str) + self.assertIs(type(b[0]), str) self.assertEqual(b[0], "a") self.assertEqual(b[:], "abc\0") self.assertEqual(b[::], "abc\0") diff --git a/Lib/ctypes/test/test_byteswap.py b/Lib/ctypes/test/test_byteswap.py index 0d2974fdd96..63dde135192 100644 --- a/Lib/ctypes/test/test_byteswap.py +++ b/Lib/ctypes/test/test_byteswap.py @@ -23,11 +23,11 @@ class Test(unittest.TestCase): def test_endian_short(self): if sys.byteorder == "little": - self.assertTrue(c_short.__ctype_le__ is c_short) - self.assertTrue(c_short.__ctype_be__.__ctype_le__ is c_short) + self.assertIs(c_short.__ctype_le__, c_short) + self.assertIs(c_short.__ctype_be__.__ctype_le__, c_short) else: - self.assertTrue(c_short.__ctype_be__ is c_short) - self.assertTrue(c_short.__ctype_le__.__ctype_be__ is c_short) + self.assertIs(c_short.__ctype_be__, c_short) + self.assertIs(c_short.__ctype_le__.__ctype_be__, c_short) s = c_short.__ctype_be__(0x1234) self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234") self.assertEqual(bin(s), "1234") @@ -50,11 +50,11 @@ class Test(unittest.TestCase): def test_endian_int(self): if sys.byteorder == "little": - self.assertTrue(c_int.__ctype_le__ is c_int) - self.assertTrue(c_int.__ctype_be__.__ctype_le__ is c_int) + self.assertIs(c_int.__ctype_le__, c_int) + self.assertIs(c_int.__ctype_be__.__ctype_le__, c_int) else: - self.assertTrue(c_int.__ctype_be__ is c_int) - self.assertTrue(c_int.__ctype_le__.__ctype_be__ is c_int) + self.assertIs(c_int.__ctype_be__, c_int) + self.assertIs(c_int.__ctype_le__.__ctype_be__, c_int) s = c_int.__ctype_be__(0x12345678) self.assertEqual(bin(struct.pack(">i", 0x12345678)), "12345678") @@ -78,11 +78,11 @@ class Test(unittest.TestCase): def test_endian_longlong(self): if sys.byteorder == "little": - self.assertTrue(c_longlong.__ctype_le__ is c_longlong) - self.assertTrue(c_longlong.__ctype_be__.__ctype_le__ is c_longlong) + self.assertIs(c_longlong.__ctype_le__, c_longlong) + self.assertIs(c_longlong.__ctype_be__.__ctype_le__, c_longlong) else: - self.assertTrue(c_longlong.__ctype_be__ is c_longlong) - self.assertTrue(c_longlong.__ctype_le__.__ctype_be__ is c_longlong) + self.assertIs(c_longlong.__ctype_be__, c_longlong) + self.assertIs(c_longlong.__ctype_le__.__ctype_be__, c_longlong) s = c_longlong.__ctype_be__(0x1234567890ABCDEF) self.assertEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF") @@ -106,11 +106,11 @@ class Test(unittest.TestCase): def test_endian_float(self): if sys.byteorder == "little": - self.assertTrue(c_float.__ctype_le__ is c_float) - self.assertTrue(c_float.__ctype_be__.__ctype_le__ is c_float) + self.assertIs(c_float.__ctype_le__, c_float) + self.assertIs(c_float.__ctype_be__.__ctype_le__, c_float) else: - self.assertTrue(c_float.__ctype_be__ is c_float) - self.assertTrue(c_float.__ctype_le__.__ctype_be__ is c_float) + self.assertIs(c_float.__ctype_be__, c_float) + self.assertIs(c_float.__ctype_le__.__ctype_be__, c_float) s = c_float(math.pi) self.assertEqual(bin(struct.pack("f", math.pi)), bin(s)) # Hm, what's the precision of a float compared to a double? @@ -124,11 +124,11 @@ class Test(unittest.TestCase): def test_endian_double(self): if sys.byteorder == "little": - self.assertTrue(c_double.__ctype_le__ is c_double) - self.assertTrue(c_double.__ctype_be__.__ctype_le__ is c_double) + self.assertIs(c_double.__ctype_le__, c_double) + self.assertIs(c_double.__ctype_be__.__ctype_le__, c_double) else: - self.assertTrue(c_double.__ctype_be__ is c_double) - self.assertTrue(c_double.__ctype_le__.__ctype_be__ is c_double) + self.assertIs(c_double.__ctype_be__, c_double) + self.assertIs(c_double.__ctype_le__.__ctype_be__, c_double) s = c_double(math.pi) self.assertEqual(s.value, math.pi) self.assertEqual(bin(struct.pack("d", math.pi)), bin(s)) @@ -140,14 +140,14 @@ class Test(unittest.TestCase): self.assertEqual(bin(struct.pack(">d", math.pi)), bin(s)) def test_endian_other(self): - self.assertTrue(c_byte.__ctype_le__ is c_byte) - self.assertTrue(c_byte.__ctype_be__ is c_byte) + self.assertIs(c_byte.__ctype_le__, c_byte) + self.assertIs(c_byte.__ctype_be__, c_byte) - self.assertTrue(c_ubyte.__ctype_le__ is c_ubyte) - self.assertTrue(c_ubyte.__ctype_be__ is c_ubyte) + self.assertIs(c_ubyte.__ctype_le__, c_ubyte) + self.assertIs(c_ubyte.__ctype_be__, c_ubyte) - self.assertTrue(c_char.__ctype_le__ is c_char) - self.assertTrue(c_char.__ctype_be__ is c_char) + self.assertIs(c_char.__ctype_le__, c_char) + self.assertIs(c_char.__ctype_be__, c_char) def test_struct_fields_1(self): if sys.byteorder == "little": diff --git a/Lib/ctypes/test/test_cast.py b/Lib/ctypes/test/test_cast.py index 702de3cffa7..32496f68636 100644 --- a/Lib/ctypes/test/test_cast.py +++ b/Lib/ctypes/test/test_cast.py @@ -38,14 +38,14 @@ class Test(unittest.TestCase): p = cast(array, POINTER(c_char_p)) # array and p share a common _objects attribute - self.assertTrue(p._objects is array._objects) + self.assertIs(p._objects, array._objects) self.assertEqual(array._objects, {'0': b"foo bar", id(array): array}) p[0] = b"spam spam" self.assertEqual(p._objects, {'0': b"spam spam", id(array): array}) - self.assertTrue(array._objects is p._objects) + self.assertIs(array._objects, p._objects) p[1] = b"foo bar" self.assertEqual(p._objects, {'1': b'foo bar', '0': b"spam spam", id(array): array}) - self.assertTrue(array._objects is p._objects) + self.assertIs(array._objects, p._objects) def test_other(self): p = cast((c_int * 4)(1, 2, 3, 4), POINTER(c_int)) diff --git a/Lib/ctypes/test/test_frombuffer.py b/Lib/ctypes/test/test_frombuffer.py index 92d61580dd1..ffb27a6ea3d 100644 --- a/Lib/ctypes/test/test_frombuffer.py +++ b/Lib/ctypes/test/test_frombuffer.py @@ -23,7 +23,7 @@ class Test(unittest.TestCase): a[0], a[-1] = 200, -200 self.assertEqual(x[:], a.tolist()) - self.assertTrue(a in x._objects.values()) + self.assertIn(a, x._objects.values()) self.assertRaises(ValueError, c_int.from_buffer, a, -1) diff --git a/Lib/ctypes/test/test_funcptr.py b/Lib/ctypes/test/test_funcptr.py index 13bf4088bf2..ff25c8febd6 100644 --- a/Lib/ctypes/test/test_funcptr.py +++ b/Lib/ctypes/test/test_funcptr.py @@ -75,7 +75,7 @@ class CFuncPtrTestCase(unittest.TestCase): ## "lpfnWndProc", WNDPROC_2(wndproc)) # instead: - self.assertTrue(WNDPROC is WNDPROC_2) + self.assertIs(WNDPROC, WNDPROC_2) # 'wndclass.lpfnWndProc' leaks 94 references. Why? self.assertEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10) diff --git a/Lib/ctypes/test/test_functions.py b/Lib/ctypes/test/test_functions.py index 45d74ec9e82..07eeb689246 100644 --- a/Lib/ctypes/test/test_functions.py +++ b/Lib/ctypes/test/test_functions.py @@ -306,7 +306,7 @@ class FunctionTestCase(unittest.TestCase): f.argtypes = [c_longlong, MyCallback] def callback(value): - self.assertTrue(isinstance(value, int)) + self.assertIsInstance(value, int) return value & 0x7FFFFFFF cb = MyCallback(callback) diff --git a/Lib/ctypes/test/test_loading.py b/Lib/ctypes/test/test_loading.py index 4029b463bcd..414363d8c82 100644 --- a/Lib/ctypes/test/test_loading.py +++ b/Lib/ctypes/test/test_loading.py @@ -43,7 +43,7 @@ class LoaderTest(unittest.TestCase): if os.name in ("nt", "ce"): def test_load_library(self): - self.assertFalse(libc_name is None) + self.assertIsNotNone(libc_name) if is_resource_enabled("printing"): print(find_library("kernel32")) print(find_library("user32")) diff --git a/Lib/ctypes/test/test_numbers.py b/Lib/ctypes/test/test_numbers.py index c02abf9c322..3b7194f31c2 100644 --- a/Lib/ctypes/test/test_numbers.py +++ b/Lib/ctypes/test/test_numbers.py @@ -181,10 +181,10 @@ class NumberTestCase(unittest.TestCase): a = array(t._type_, [3.14]) v = t.from_address(a.buffer_info()[0]) self.assertEqual(v.value, a[0]) - self.assertTrue(type(v) is t) + self.assertIs(type(v), t) a[0] = 2.3456e17 self.assertEqual(v.value, a[0]) - self.assertTrue(type(v) is t) + self.assertIs(type(v), t) def test_char_from_address(self): from ctypes import c_char @@ -194,7 +194,7 @@ class NumberTestCase(unittest.TestCase): a[0] = ord('x') v = c_char.from_address(a.buffer_info()[0]) self.assertEqual(v.value, b'x') - self.assertTrue(type(v) is c_char) + self.assertIs(type(v), c_char) a[0] = ord('?') self.assertEqual(v.value, b'?') diff --git a/Lib/ctypes/test/test_parameters.py b/Lib/ctypes/test/test_parameters.py index 9762fb915d8..12b5bd5fba1 100644 --- a/Lib/ctypes/test/test_parameters.py +++ b/Lib/ctypes/test/test_parameters.py @@ -54,7 +54,7 @@ class SimpleTypesTestCase(unittest.TestCase): # c_char_p.from_param on a Python String packs the string # into a cparam object s = b"123" - self.assertTrue(c_char_p.from_param(s)._obj is s) + self.assertIs(c_char_p.from_param(s)._obj, s) # new in 0.9.1: convert (encode) unicode to ascii self.assertEqual(c_char_p.from_param(b"123")._obj, b"123") @@ -64,7 +64,7 @@ class SimpleTypesTestCase(unittest.TestCase): # calling c_char_p.from_param with a c_char_p instance # returns the argument itself: a = c_char_p(b"123") - self.assertTrue(c_char_p.from_param(a) is a) + self.assertIs(c_char_p.from_param(a), a) def test_cw_strings(self): from ctypes import byref diff --git a/Lib/ctypes/test/test_pointers.py b/Lib/ctypes/test/test_pointers.py index d29317a3e4a..f8ef0ab830c 100644 --- a/Lib/ctypes/test/test_pointers.py +++ b/Lib/ctypes/test/test_pointers.py @@ -78,7 +78,7 @@ class PointersTestCase(unittest.TestCase): ## i = c_int(42) ## callback(byref(i)) -## self.assertTrue(i.value == 84) +## self.assertEqual(i.value, 84) doit(callback) ## print self.result @@ -91,11 +91,11 @@ class PointersTestCase(unittest.TestCase): i = ct(42) p = pointer(i) ## print type(p.contents), ct - self.assertTrue(type(p.contents) is ct) + self.assertIs(type(p.contents), ct) # p.contents is the same as p[0] ## print p.contents -## self.assertTrue(p.contents == 42) -## self.assertTrue(p[0] == 42) +## self.assertEqual(p.contents, 42) +## self.assertEqual(p[0], 42) self.assertRaises(TypeError, delitem, p, 0) diff --git a/Lib/ctypes/test/test_python_api.py b/Lib/ctypes/test/test_python_api.py index 9de3980ed44..5eb882af5eb 100644 --- a/Lib/ctypes/test/test_python_api.py +++ b/Lib/ctypes/test/test_python_api.py @@ -64,7 +64,7 @@ class PythonAPITestCase(unittest.TestCase): ref = grc(s) # id(python-object) is the address pyobj = PyObj_FromPtr(id(s)) - self.assertTrue(s is pyobj) + self.assertIs(s, pyobj) self.assertEqual(grc(s), ref + 1) del pyobj diff --git a/Lib/ctypes/test/test_refcounts.py b/Lib/ctypes/test/test_refcounts.py index a483bb0bbce..f2edfa6400e 100644 --- a/Lib/ctypes/test/test_refcounts.py +++ b/Lib/ctypes/test/test_refcounts.py @@ -26,7 +26,7 @@ class RefcountTestCase(unittest.TestCase): self.assertEqual(grc(callback), 2) cb = MyCallback(callback) - self.assertTrue(grc(callback) > 2) + self.assertGreater(grc(callback), 2) result = f(-10, cb) self.assertEqual(result, -18) cb = None @@ -46,15 +46,15 @@ class RefcountTestCase(unittest.TestCase): # the CFuncPtr instance holds at least one refcount on func: f = OtherCallback(func) - self.assertTrue(grc(func) > 2) + self.assertGreater(grc(func), 2) # and may release it again del f - self.assertTrue(grc(func) >= 2) + self.assertGreaterEqual(grc(func), 2) # but now it must be gone gc.collect() - self.assertTrue(grc(func) == 2) + self.assertEqual(grc(func), 2) class X(ctypes.Structure): _fields_ = [("a", OtherCallback)] @@ -62,11 +62,11 @@ class RefcountTestCase(unittest.TestCase): x.a = OtherCallback(func) # the CFuncPtr instance holds at least one refcount on func: - self.assertTrue(grc(func) > 2) + self.assertGreater(grc(func), 2) # and may release it again del x - self.assertTrue(grc(func) >= 2) + self.assertGreaterEqual(grc(func), 2) # and now it must be gone again gc.collect() @@ -75,7 +75,7 @@ class RefcountTestCase(unittest.TestCase): f = OtherCallback(func) # the CFuncPtr instance holds at least one refcount on func: - self.assertTrue(grc(func) > 2) + self.assertGreater(grc(func), 2) # create a cycle f.cycle = f diff --git a/Lib/ctypes/test/test_strings.py b/Lib/ctypes/test/test_strings.py index 1a9bdbc5c0f..9dc2a291a7d 100644 --- a/Lib/ctypes/test/test_strings.py +++ b/Lib/ctypes/test/test_strings.py @@ -115,24 +115,24 @@ class StringTestCase(unittest.TestCase): # New in releases later than 0.4.0: # c_string(number) returns an empty string of size number - self.assertTrue(len(c_string(32).raw) == 32) + self.assertEqual(len(c_string(32).raw), 32) self.assertRaises(ValueError, c_string, -1) self.assertRaises(ValueError, c_string, 0) # These tests fail, because it is no longer initialized -## self.assertTrue(c_string(2).value == "") -## self.assertTrue(c_string(2).raw == "\000\000") - self.assertTrue(c_string(2).raw[-1] == "\000") - self.assertTrue(len(c_string(2).raw) == 2) +## self.assertEqual(c_string(2).value, "") +## self.assertEqual(c_string(2).raw, "\000\000") + self.assertEqual(c_string(2).raw[-1], "\000") + self.assertEqual(len(c_string(2).raw), 2) def XX_test_initialized_strings(self): - self.assertTrue(c_string("ab", 4).raw[:2] == "ab") - self.assertTrue(c_string("ab", 4).raw[:2:] == "ab") - self.assertTrue(c_string("ab", 4).raw[:2:-1] == "ba") - self.assertTrue(c_string("ab", 4).raw[:2:2] == "a") - self.assertTrue(c_string("ab", 4).raw[-1] == "\000") - self.assertTrue(c_string("ab", 2).raw == "a\000") + self.assertEqual(c_string("ab", 4).raw[:2], "ab") + self.assertEqual(c_string("ab", 4).raw[:2:], "ab") + self.assertEqual(c_string("ab", 4).raw[:2:-1], "ba") + self.assertEqual(c_string("ab", 4).raw[:2:2], "a") + self.assertEqual(c_string("ab", 4).raw[-1], "\000") + self.assertEqual(c_string("ab", 2).raw, "a\000") def XX_test_toolong(self): cs = c_string("abcdef") @@ -163,22 +163,22 @@ else: # XXX This behaviour is about to change: # len returns the size of the internal buffer in bytes. # This includes the terminating NUL character. - self.assertTrue(sizeof(cs) == 14) + self.assertEqual(sizeof(cs), 14) # The value property is the string up to the first terminating NUL. - self.assertTrue(cs.value == "abcdef") - self.assertTrue(c_wstring("abc\000def").value == "abc") + self.assertEqual(cs.value, "abcdef") + self.assertEqual(c_wstring("abc\000def").value, "abc") - self.assertTrue(c_wstring("abc\000def").value == "abc") + self.assertEqual(c_wstring("abc\000def").value, "abc") # The raw property is the total buffer contents: - self.assertTrue(cs.raw == "abcdef\000") - self.assertTrue(c_wstring("abc\000def").raw == "abc\000def\000") + self.assertEqual(cs.raw, "abcdef\000") + self.assertEqual(c_wstring("abc\000def").raw, "abc\000def\000") # We can change the value: cs.value = "ab" - self.assertTrue(cs.value == "ab") - self.assertTrue(cs.raw == "ab\000\000\000\000\000") + self.assertEqual(cs.value, "ab") + self.assertEqual(cs.raw, "ab\000\000\000\000\000") self.assertRaises(TypeError, c_wstring, "123") self.assertRaises(ValueError, c_wstring, 0) diff --git a/Lib/ctypes/test/test_structures.py b/Lib/ctypes/test/test_structures.py index 9d5b99e2f82..61b9fe7c181 100644 --- a/Lib/ctypes/test/test_structures.py +++ b/Lib/ctypes/test/test_structures.py @@ -374,9 +374,9 @@ class StructureTestCase(unittest.TestCase): ## class X(Structure): ## _fields_ = [] - self.assertTrue("in_dll" in dir(type(Structure))) - self.assertTrue("from_address" in dir(type(Structure))) - self.assertTrue("in_dll" in dir(type(Structure))) + self.assertIn("in_dll", dir(type(Structure))) + self.assertIn("from_address", dir(type(Structure))) + self.assertIn("in_dll", dir(type(Structure))) def test_positional_args(self): # see also http://bugs.python.org/issue5042 @@ -446,8 +446,8 @@ class TestRecursiveStructure(unittest.TestCase): try: Recursive._fields_ = [("next", Recursive)] except AttributeError as details: - self.assertTrue("Structure or union cannot contain itself" in - str(details)) + self.assertIn("Structure or union cannot contain itself", + str(details)) else: self.fail("Structure or union cannot contain itself") @@ -463,8 +463,7 @@ class TestRecursiveStructure(unittest.TestCase): try: Second._fields_ = [("first", First)] except AttributeError as details: - self.assertTrue("_fields_ is final" in - str(details)) + self.assertIn("_fields_ is final", str(details)) else: self.fail("AttributeError not raised")