[python] Fix most Python binding unittests on Windows

[ethanhs]

Summary

This fixes all but one of the test cases for Windows. TestCDB will
take more work to debug, as CompilationDatabase seems not to work correctly.

[bkramer]

I don't know much about the python bindings, but this is probably fine.

[ethanhs]

In D47864#1124948, @bkramer wrote:

I don't know much about the python bindings, but this is probably fine.

Yeah I wasn't really sure who to add so I looked at the commit history. Thank you for adding the right people.

[jbcoe]

Would you like me to commit this for you?

[ethanhs]

In D47864#1139750, @jbcoe wrote:

Would you like me to commit this for you?

Sure, that would be great! I don't have commit rights so I was waiting for someone to do it. Thanks!

bindings/python/tests/cindex/test_cdb.py

 from clang.cindex import CompilationDatabase
 from clang.cindex import CompilationDatabaseError
 from clang.cindex import CompileCommands
 from clang.cindex import CompileCommand
 import os
 import gc
 import unittest
+import sys
 
 
 kInputsDir = os.path.join(os.path.dirname(__file__), 'INPUTS')
 
 
[e-mail](sys.platform == 'win32', "TODO: Fix these tests on Windows")
 class TestCDB(unittest.TestCase):
     def test_create_fail(self):
         """Check we fail loading a database with an assertion"""
         path = os.path.dirname(__file__)
         with self.assertRaises(CompilationDatabaseError) as cm:
             cdb = CompilationDatabase.fromDirectory(path)
         e = cm.exception
         self.assertEqual(e.cdb_error,

bindings/python/tests/cindex/test_cursor.py

class TestCursor(unittest.TestCase):
 
     def test_enum_type(self):
         tu = get_tu('enum TEST { FOO=1, BAR=2 };')
         enum = get_cursor(tu, 'TEST')
         self.assertIsNotNone(enum)
 
         self.assertEqual(enum.kind, CursorKind.ENUM_DECL)
         enum_type = enum.enum_type
-        self.assertEqual(enum_type.kind, TypeKind.UINT)
+        self.assertIn(enum_type.kind, (TypeKind.UINT, TypeKind.INT))
 
     def test_enum_type_cpp(self):
         tu = get_tu('enum TEST : long long { FOO=1, BAR=2 };', lang="cpp")
         enum = get_cursor(tu, 'TEST')
         self.assertIsNotNone(enum)
 
         self.assertEqual(enum.kind, CursorKind.ENUM_DECL)
         self.assertEqual(enum.enum_type.kind, TypeKind.LONGLONG)
def test_mangled_name(self):
         tu = get_tu(kInputForMangling, lang='cpp')
         foo = get_cursor(tu, 'foo')
 
         # Since libclang does not link in targets, we cannot pass a triple to it
         # and force the target. To enable this test to pass on all platforms, accept
         # all valid manglings.
         # [c-index-test handles this by running the source through clang, emitting
         #  an AST file and running libclang on that AST file]
-        self.assertIn(foo.mangled_name, ('_Z3fooii', '__Z3fooii', '?foo@@YAHHH'))
+        self.assertIn(foo.mangled_name, ('_Z3fooii', '__Z3fooii', '?foo@@YAHHH', '?foo@@YAHHH@Z'))

bindings/python/tests/cindex/test_translation_unit.py

+from contextlib import contextmanager
 import gc
 import os
 import tempfile
 import unittest
 
 from clang.cindex import CursorKind
 from clang.cindex import Cursor
 from clang.cindex import File
 from clang.cindex import Index
 from clang.cindex import SourceLocation
 from clang.cindex import SourceRange
 from clang.cindex import TranslationUnitSaveError
 from clang.cindex import TranslationUnitLoadError
 from clang.cindex import TranslationUnit
 from .util import get_cursor
 from .util import get_tu
 
 
 kInputsDir = os.path.join(os.path.dirname(__file__), 'INPUTS')
 
 
+@contextmanager
 def save_tu(tu):
     """Convenience API to save a TranslationUnit to a file.
 
     Returns the filename it was saved to.
     """
-    _, path = tempfile.mkstemp()
-    tu.save(path)
-
-    return path
+    with tempfile.NamedTemporaryFile() as t:
+        tu.save(t.name)
+        yield t.name
 
 
 class TestTranslationUnit(unittest.TestCase):
     def test_spelling(self):
         path = os.path.join(kInputsDir, 'hello.cpp')
         tu = TranslationUnit.from_source(path)
         self.assertEqual(tu.spelling, path)
 
def test_inclusion_directive(self):
         for i in zip(inc, inclusion_directive_files):
             self.assert_normpaths_equal(i[0], i[1])
 
     def test_save(self):
         """Ensure TranslationUnit.save() works."""
 
         tu = get_tu('int foo();')
 
-        path = save_tu(tu)
+        with save_tu(tu) as path:
             self.assertTrue(os.path.exists(path))
             self.assertGreater(os.path.getsize(path), 0)
-        os.unlink(path)
 
     def test_save_translation_errors(self):
         """Ensure that saving to an invalid directory raises."""
 
         tu = get_tu('int foo();')
 
         path = '/does/not/exist/llvm-test.ast'
         self.assertFalse(os.path.exists(os.path.dirname(path)))
 
         with self.assertRaises(TranslationUnitSaveError) as cm:
             tu.save(path)
         ex = cm.exception
         expected = TranslationUnitSaveError.ERROR_UNKNOWN
         self.assertEqual(ex.save_error, expected)
 
     def test_load(self):
         """Ensure TranslationUnits can be constructed from saved files."""
 
         tu = get_tu('int foo();')
         self.assertEqual(len(tu.diagnostics), 0)
-        path = save_tu(tu)
-
+        with save_tu(tu) as path:
             self.assertTrue(os.path.exists(path))
             self.assertGreater(os.path.getsize(path), 0)
 
             tu2 = TranslationUnit.from_ast_file(filename=path)
             self.assertEqual(len(tu2.diagnostics), 0)
 
             foo = get_cursor(tu2, 'foo')
             self.assertIsNotNone(foo)
 
             # Just in case there is an open file descriptor somewhere.
             del tu2
 
-        os.unlink(path)
-
     def test_index_parse(self):
         path = os.path.join(kInputsDir, 'hello.cpp')
         index = Index.create()
         tu = index.parse(path)
         self.assertIsInstance(tu, TranslationUnit)
 
     def test_get_file(self):
         """Ensure tu.get_file() works appropriately."""