tests: Use the appropriate assertion method

- assertEqual(value, None) → assertIsNone(value)
- assertTrue(value is not None) → assertIsNotNone(value)
- assertTrue(isinstance(value, Type)) → assertIsInstance(value, Type)

1 files changed, 55 insertions, 53 deletions

diff --git a/tests/scanner/test_transformer.py b/tests/scanner/test_transformer.py
index 1b7aef3c..87b94cb3 100644
--- a/tests/scanner/test_transformer.py
+++ b/tests/scanner/test_transformer.py
@@ -95,8 +95,8 @@ class TestStructTypedefs(unittest.TestCase):
             """)
         self.assertEqual(len(self.namespace.names), 1)
         node = self.namespace.get('Struct')
-        self.assertTrue(node is not None)
-        self.assertTrue(isinstance(node, ast.Record))
+        self.assertIsNotNone(node)
+        self.assertIsInstance(node, ast.Record)
         self.assertFalse(node.opaque)
         self.assertFalse(node.pointer)
         self.assertFalse(node.disguised)
@@ -111,8 +111,8 @@ class TestStructTypedefs(unittest.TestCase):
             """)
         self.assertEqual(len(self.namespace.names), 1)
         node = self.namespace.get('Struct')
-        self.assertTrue(node is not None)
-        self.assertTrue(isinstance(node, ast.Record))
+        self.assertIsNotNone(node)
+        self.assertIsInstance(node, ast.Record)
         self.assertFalse(node.opaque)
         self.assertFalse(node.pointer)
         self.assertFalse(node.disguised)
@@ -127,8 +127,8 @@ class TestStructTypedefs(unittest.TestCase):
             """)
         self.assertEqual(len(self.namespace.names), 1)
         node = self.namespace.get('Struct')
-        self.assertTrue(node is not None)
-        self.assertTrue(isinstance(node, ast.Record))
+        self.assertIsNotNone(node)
+        self.assertIsInstance(node, ast.Record)
         self.assertFalse(node.opaque)
         self.assertFalse(node.pointer)
         self.assertFalse(node.disguised)
@@ -142,8 +142,8 @@ class TestStructTypedefs(unittest.TestCase):
             """)
         self.assertEqual(len(self.namespace.names), 1)
         node = self.namespace.get('Struct')
-        self.assertTrue(node is not None)
-        self.assertTrue(isinstance(node, ast.Record))
+        self.assertIsNotNone(node)
+        self.assertIsInstance(node, ast.Record)
         self.assertFalse(node.opaque)
         self.assertFalse(node.pointer)
         self.assertFalse(node.disguised)
@@ -157,8 +157,8 @@ class TestStructTypedefs(unittest.TestCase):
             """)
         self.assertEqual(len(self.namespace.names), 1)
         node = self.namespace.get('Struct')
-        self.assertTrue(node is not None)
-        self.assertTrue(isinstance(node, ast.Record))
+        self.assertIsNotNone(node)
+        self.assertIsInstance(node, ast.Record)
         self.assertFalse(node.opaque)
         self.assertFalse(node.pointer)
         self.assertFalse(node.disguised)
@@ -175,20 +175,20 @@ class TestStructTypedefs(unittest.TestCase):
         self.assertEqual(len(self.namespace.names), 3)
 
         node = self.namespace.get('Struct')
-        self.assertTrue(node is not None)
-        self.assertTrue(isinstance(node, ast.Record))
+        self.assertIsNotNone(node)
+        self.assertIsInstance(node, ast.Record)
         self.assertFalse(node.opaque)
         self.assertFalse(node.pointer)
         self.assertFalse(node.disguised)
         self.assertEqual(len(node.fields), 1)
 
         alias = self.namespace.get('StructAlias1')
-        self.assertTrue(isinstance(alias, ast.Alias))
+        self.assertIsInstance(alias, ast.Alias)
         self.assertEqual(alias.target, node)
         self.assertEqual(alias.ctype, 'TestStructAlias1')
 
         alias = self.namespace.get('StructAlias2')
-        self.assertTrue(isinstance(alias, ast.Alias))
+        self.assertIsInstance(alias, ast.Alias)
         self.assertEqual(alias.target, node)
         self.assertEqual(alias.ctype, 'TestStructAlias2')
 
@@ -204,8 +204,8 @@ class TestStructTypedefs(unittest.TestCase):
         self.assertEqual(len(self.namespace.names), 2)
 
         node = self.namespace.get('Struct')
-        self.assertTrue(node is not None)
-        self.assertTrue(isinstance(node, ast.Record))
+        self.assertIsNotNone(node)
+        self.assertIsInstance(node, ast.Record)
         self.assertFalse(node.opaque)
         self.assertFalse(node.pointer)
         self.assertFalse(node.disguised)
@@ -213,8 +213,8 @@ class TestStructTypedefs(unittest.TestCase):
         self.assertEqual(node.ctype, 'TestStruct')
 
         shared = self.namespace.get('StructAlias')
-        self.assertTrue(shared is not None)
-        self.assertTrue(isinstance(shared, ast.Record))
+        self.assertIsNotNone(shared)
+        self.assertIsInstance(shared, ast.Record)
         self.assertFalse(shared.opaque)
         self.assertFalse(shared.pointer)
         self.assertFalse(shared.disguised)
@@ -232,8 +232,8 @@ class TestStructTypedefs(unittest.TestCase):
         self.assertEqual(len(self.namespace.names), 2)
 
         node = self.namespace.get('Struct')
-        self.assertTrue(node is not None)
-        self.assertTrue(isinstance(node, ast.Record))
+        self.assertIsNotNone(node)
+        self.assertIsInstance(node, ast.Record)
         self.assertFalse(node.opaque)
         self.assertFalse(node.pointer)
         self.assertFalse(node.disguised)
@@ -241,8 +241,8 @@ class TestStructTypedefs(unittest.TestCase):
         self.assertEqual(node.ctype, 'TestStruct')
 
         shared = self.namespace.get('StructAlias')
-        self.assertTrue(shared is not None)
-        self.assertTrue(isinstance(shared, ast.Record))
+        self.assertIsNotNone(shared)
+        self.assertIsInstance(shared, ast.Record)
         self.assertFalse(shared.opaque)
         self.assertFalse(shared.pointer)
         self.assertFalse(shared.disguised)
@@ -259,14 +259,14 @@ class TestStructTypedefs(unittest.TestCase):
         self.assertEqual(len(self.namespace.names), 2)
 
         node = self.namespace.get('Struct')
-        self.assertTrue(node is not None)
-        self.assertTrue(isinstance(node, ast.Record))
+        self.assertIsNotNone(node)
+        self.assertIsInstance(node, ast.Record)
         self.assertEqual(len(node.fields), 1)
         self.assertEqual(node.ctype, 'TestStruct')
 
         ptr = self.namespace.get('StructPtr')
-        self.assertTrue(ptr is not None)
-        self.assertTrue(isinstance(ptr, ast.Alias))
+        self.assertIsNotNone(ptr)
+        self.assertIsInstance(ptr, ast.Alias)
         self.assertEqual(ptr.ctype, 'TestStructPtr')
 
     def test_struct_tag_pointer(self):
@@ -280,8 +280,8 @@ class TestStructTypedefs(unittest.TestCase):
         self.assertEqual(len(self.namespace.names), 2)
 
         node = self.namespace.get('Struct')
-        self.assertTrue(node is not None)
-        self.assertTrue(isinstance(node, ast.Record))
+        self.assertIsNotNone(node)
+        self.assertIsInstance(node, ast.Record)
         self.assertFalse(node.opaque)
         self.assertFalse(node.pointer)
         self.assertFalse(node.disguised)
@@ -289,9 +289,9 @@ class TestStructTypedefs(unittest.TestCase):
         self.assertEqual(len(node.fields), 1)
 
         ptr = self.namespace.get('StructPtr')
-        self.assertTrue(ptr is not None)
+        self.assertIsNotNone(ptr)
         # This currently gives a disguised Record instead of an Alias
-        self.assertTrue(isinstance(ptr, ast.Record))
+        self.assertIsInstance(ptr, ast.Record)
         self.assertFalse(ptr.opaque)
         self.assertTrue(ptr.pointer)
         self.assertTrue(ptr.disguised)
@@ -336,11 +336,11 @@ class TestNestedStructs(unittest.TestCase):
         self.assertEqual(len(node.fields), 1)
 
         simple = self.namespace.get('SimpleStruct')
-        self.assertTrue(node is not None)
+        self.assertIsNotNone(node)
 
         field = node.fields[0]
-        self.assertTrue(field is not None)
-        self.assertTrue(isinstance(field, ast.Field))
+        self.assertIsNotNone(field)
+        self.assertIsInstance(field, ast.Field)
         self.assertEqual(field.type, simple)
         self.assertEqual(field.name, 'nested_struct')
 
@@ -357,17 +357,18 @@ class TestNestedStructs(unittest.TestCase):
         self.assertEqual(len(node.fields), 1)
 
         field = node.fields[0]
-        self.assertTrue(field is not None)
-        self.assertTrue(isinstance(field, ast.Field))
-        self.assertEqual(field.name, None)
+        self.assertIsNotNone(field)
+        self.assertIsInstance(field, ast.Field)
+        self.assertIsNone(field.name)
 
         anon = field.anonymous_node
-        self.assertTrue(isinstance(anon, ast.Record))
+        self.assertIsNotNone(anon)
+        self.assertIsInstance(anon, ast.Record)
         self.assertEqual(len(anon.fields), 1)
 
         anon_field = anon.fields[0]
-        self.assertTrue(anon_field is not None)
-        self.assertTrue(isinstance(anon_field, ast.Field))
+        self.assertIsNotNone(anon_field)
+        self.assertIsInstance(anon_field, ast.Field)
         self.assertEqual(anon_field.name, 'value')
 
     def test_nested(self):
@@ -383,18 +384,19 @@ class TestNestedStructs(unittest.TestCase):
         self.assertEqual(len(node.fields), 1)
 
         field = node.fields[0]
-        self.assertTrue(field is not None)
-        self.assertTrue(isinstance(field, ast.Field))
+        self.assertIsNotNone(field)
+        self.assertIsInstance(field, ast.Field)
         self.assertEqual(field.name, 'nested')
 
         nested = field.anonymous_node
-        self.assertTrue(isinstance(nested, ast.Record))
+        self.assertIsNotNone(nested)
+        self.assertIsInstance(nested, ast.Record)
         self.assertEqual(len(nested.fields), 1)
         self.assertEqual(nested.name, 'nested')
 
         nested_field = nested.fields[0]
-        self.assertTrue(nested_field is not None)
-        self.assertTrue(isinstance(nested_field, ast.Field))
+        self.assertIsNotNone(nested_field)
+        self.assertIsInstance(nested_field, ast.Field)
         self.assertEqual(nested_field.name, 'value')
 
     def test_struct_ptr(self):
@@ -412,11 +414,11 @@ class TestNestedStructs(unittest.TestCase):
         self.assertEqual(len(node.fields), 1)
 
         simple = self.namespace.get('SimpleStruct')
-        self.assertTrue(simple is not None)
+        self.assertIsNotNone(simple)
 
         field = node.fields[0]
-        self.assertTrue(field is not None)
-        self.assertTrue(isinstance(field, ast.Field))
+        self.assertIsNotNone(field)
+        self.assertIsInstance(field, ast.Field)
         self.assertEqual(field.type.ctype, 'TestSimpleStruct*')
         self.assertEqual(field.name, 'struct_ptr')
 
@@ -444,7 +446,7 @@ class TestUnions(unittest.TestCase):
         self.assertEqual(len(node.fields), 2)
 
         simple = self.namespace.get('SimpleStruct')
-        self.assertTrue(node is not None)
+        self.assertIsNotNone(node)
 
         field = node.fields[0]
         self.assertEqual(field.type, simple)
@@ -471,7 +473,7 @@ class TestUnions(unittest.TestCase):
         self.assertEqual(field.name, 'nested')
 
         nested = field.anonymous_node
-        self.assertTrue(isinstance(nested, ast.Union))
+        self.assertIsInstance(nested, ast.Union)
         self.assertEqual(nested.name, 'nested')
         self.assertEqual(len(nested.fields), 2)
 
@@ -492,11 +494,11 @@ class TestUnions(unittest.TestCase):
         self.assertEqual(len(node.fields), 1)
 
         field = node.fields[0]
-        self.assertEqual(field.name, None)
+        self.assertIsNone(field.name)
 
         nested = field.anonymous_node
-        self.assertTrue(isinstance(nested, ast.Union))
-        self.assertEqual(nested.name, None)
+        self.assertIsInstance(nested, ast.Union)
+        self.assertIsNone(nested.name)
         self.assertEqual(len(nested.fields), 2)
 
         self.assertEqual(nested.fields[0].name, 'ival')
@@ -519,7 +521,7 @@ class TestCallbacks(unittest.TestCase):
             """)
         self.assertEqual(len(self.namespace.names), 1)
         node = self.namespace.get('Callback')
-        self.assertTrue(isinstance(node, ast.Callback))
+        self.assertIsInstance(node, ast.Callback)
 
 
 class TestArrays(unittest.TestCase):