Using appropriate checks in tests

Lib/test/test_memoryview.py

 """Unit tests for the memoryview
 
    Some tests are in test_bytes. Many tests that require _testbuffer.ndarray
    are in test_buffer.
 """
 
 import unittest
 import test.support
 import sys
 import gc
@@ skipping 39 matching lines @@
             self.check_getitem_with_type(tp)
 
     def test_iter(self):
         for tp in self._types:
             b = tp(self._source)
             m = self._view(b)
             self.assertEqual(list(m), [m[i] for i in range(len(m))])
 
     def test_setitem_readonly(self):
         if not self.ro_type:
-            return
+            self.skipTest("no read-only type to test")
         b = self.ro_type(self._source)
         oldrefcount = sys.getrefcount(b)
         m = self._view(b)
         def setitem(value):
             m[0] = value
         self.assertRaises(TypeError, setitem, b"a")
         self.assertRaises(TypeError, setitem, 65)
         self.assertRaises(TypeError, setitem, memoryview(b"a"))
         m = None
         self.assertEqual(sys.getrefcount(b), oldrefcount)
 
     def test_setitem_writable(self):
         if not self.rw_type:
-            return
+            self.skipTest("no writable type to test")
         tp = self.rw_type
         b = self.rw_type(self._source)
         oldrefcount = sys.getrefcount(b)
         m = self._view(b)
         m[0] = ord(b'1')
         self._check_contents(tp, b, b"1bcdef")
         m[0:1] = tp(b"0")
         self._check_contents(tp, b, b"0bcdef")
         m[1:3] = tp(b"12")
         self._check_contents(tp, b, b"012def")
@@ skipping 97 matching lines @@
         self.assertEqual(m.itemsize, self.itemsize)
         self.assertEqual(m.ndim, 1)
         self.assertEqual(m.shape, (6,))
         self.assertEqual(len(m), 6)
         self.assertEqual(m.strides, (self.itemsize,))
         self.assertEqual(m.suboffsets, ())
         return m
 
     def test_attributes_readonly(self):
         if not self.ro_type:
-            return
+            self.skipTest("no read-only type to test")
         m = self.check_attributes_with_type(self.ro_type)
         self.assertEqual(m.readonly, True)
 
     def test_attributes_writable(self):
         if not self.rw_type:
-            return
+            self.skipTest("no writable type to test")
         m = self.check_attributes_with_type(self.rw_type)
         self.assertEqual(m.readonly, False)
 
     def test_getbuffer(self):
         # Test PyObject_GetBuffer() on a memoryview object.
         for tp in self._types:
             b = tp(self._source)
             oldrefcount = sys.getrefcount(b)
             m = self._view(b)
             oldviewrefcount = sys.getrefcount(m)
@@ skipping 85 matching lines @@
             self._check_released(m, tp)
             # Can be called a second time (it's a no-op)
             m.release()
             self._check_released(m, tp)
 
     def test_writable_readonly(self):
         # Issue #10451: memoryview incorrectly exposes a readonly
         # buffer as writable causing a segfault if using mmap
         tp = self.ro_type
         if tp is None:
-            return
+            self.skipTest("no read-only type to test")
         b = tp(self._source)
         m = self._view(b)
         i = io.BytesIO(b'ZZZZ')
         self.assertRaises(TypeError, i.readinto, m)
 
     def test_getbuf_fail(self):
         self.assertRaises(TypeError, self._view, {})
 
     def test_hash(self):
         # Memoryviews of readonly (hashable) types are hashable, and they
@@ skipping 57 matching lines @@
     itemsize = 1
     format = 'B'
 
 class BaseArrayMemoryTests(AbstractMemoryTests):
     ro_type = None
     rw_type = lambda self, b: array.array('i', list(b))
     getitem_type = lambda self, b: array.array('i', list(b)).tobytes()
     itemsize = array.array('i').itemsize
     format = 'i'
 
+    @unittest.skip('XXX test should be adapted for non-byte buffers')
     def test_getbuffer(self):
-        # XXX Test should be adapted for non-byte buffers
         pass
 
+    @unittest.skip('XXX NotImplementedError: tolist() only supports byte views')
     def test_tolist(self):
-        # XXX NotImplementedError: tolist() only supports byte views
         pass
 
 
 # Variations on indirection levels: memoryview, slice of memoryview,
 # slice of slice of memoryview.
 # This is important to test allocation subtleties.
 
 class BaseMemoryviewTests:
     def _view(self, obj):
         return memoryview(obj)
@@ skipping 71 matching lines @@
 class ArrayMemorySliceSliceTest(unittest.TestCase,
     BaseMemorySliceSliceTests, BaseArrayMemoryTests):
     pass
 
 
 def test_main():
     test.support.run_unittest(__name__)
 
 if __name__ == "__main__":
     test_main()