Adjust tests to new ArgumentParser design

The new ArgumentParser interface is slightly different to the old one, and
doesn't require a call to a recognize_compiler() function to construct.

Signed-off-by: John Pennycook <john.pennycook@intel.com>

Author: Pennycook

tests/compilers/test_compilers.py

@@ -8,6 +8,7 @@
 from pathlib import Path
 
 from codebasin import config
+from codebasin.config import ArgumentParser
 
 
 class TestCompilers(unittest.TestCase):
@@ -42,120 +43,136 @@ def test_common(self):
             "MACRO_AFTER_SPACE",
             "test.cpp",
         ]
-        args = config._parse_compiler_args(argv)
-        self.assertEqual(
-            args.defines,
+        parser = ArgumentParser(argv[0])
+
+        passes = parser.parse_args(argv[1:])
+        self.assertEqual(len(passes), 1)
+
+        self.assertEqual(passes[0].pass_name, "default")
+
+        self.assertCountEqual(
+            passes[0].defines,
             ["MACRO", "FUNCTION_MACRO=1", "MACRO_AFTER_SPACE"],
         )
-        self.assertEqual(
-            args.include_paths,
+        self.assertCountEqual(
+            passes[0].include_paths,
             ["/path", "/path/after/space", "/system/path"],
         )
-        self.assertEqual(args.include_files, ["foo.inc", "bar.inc"])
+        self.assertCountEqual(passes[0].include_files, ["foo.inc", "bar.inc"])
 
     def test_gnu(self):
         """compilers/gnu"""
         argv = ["g++", "-fopenmp", "test.cpp"]
 
-        parser = config.recognize_compiler(argv[0])
-        self.assertTrue(type(parser) is config.GnuArgumentParser)
+        parser = ArgumentParser(argv[0])
 
         passes = parser.parse_args(argv[1:])
         self.assertEqual(len(passes), 1)
 
         self.assertEqual(passes[0].pass_name, "default")
 
         defines = passes[0].defines
-        self.assertEqual(defines, ["_OPENMP"])
+        self.assertCountEqual(defines, ["_OPENMP"])
 
     def test_clang(self):
         """compilers/clang"""
         argv = ["clang", "-fsycl-is-device", "test.cpp"]
 
-        parser = config.recognize_compiler(argv[0])
-        self.assertTrue(type(parser) is config.ClangArgumentParser)
+        parser = ArgumentParser(argv[0])
 
         passes = parser.parse_args(argv[1:])
         self.assertEqual(len(passes), 1)
 
         self.assertEqual(passes[0].pass_name, "default")
 
         defines = passes[0].defines
-        self.assertEqual(defines, ["__SYCL_DEVICE_ONLY__"])
+        self.assertCountEqual(defines, ["__SYCL_DEVICE_ONLY__"])
 
     def test_intel_sycl(self):
         """compilers/intel_sycl"""
         argv = ["icpx", "-fsycl", "test.cpp"]
 
-        parser = config.recognize_compiler(argv[0])
-        self.assertTrue(type(parser) is config.ClangArgumentParser)
+        parser = ArgumentParser(argv[0])
 
         passes = parser.parse_args(argv[1:])
         self.assertEqual(len(passes), 2)
 
         pass_names = {p.pass_name for p in passes}
-        self.assertEqual(pass_names, {"default", "spir64"})
+        self.assertCountEqual(pass_names, {"default", "sycl-spir64"})
 
         for p in passes:
             if p.pass_name == "default":
-                expected = []
+                expected = ["SYCL_LANGUAGE_VERSION"]
             else:
-                expected = ["__SYCL_DEVICE_ONLY__", "__SPIR__", "__SPIRV__"]
-            self.assertEqual(p.defines, expected)
+                expected = [
+                    "SYCL_LANGUAGE_VERSION",
+                    "__SYCL_DEVICE_ONLY__",
+                    "__SPIR__",
+                    "__SPIRV__",
+                ]
+            self.assertCountEqual(p.defines, expected)
 
     def test_intel_targets(self):
         """compilers/intel_targets"""
         argv = [
             "icpx",
             "-fsycl",
-            "-fsycl-targets=spir64,x86_64",
+            "-fsycl-targets=spir64,spir64_x86_64",
             "-fopenmp",
             "test.cpp",
         ]
 
-        parser = config.recognize_compiler(argv[0])
-        self.assertTrue(type(parser) is config.ClangArgumentParser)
+        parser = ArgumentParser(argv[0])
 
         passes = parser.parse_args(argv[1:])
 
         pass_names = {p.pass_name for p in passes}
-        self.assertEqual(pass_names, {"default", "spir64", "x86_64"})
+        self.assertCountEqual(
+            pass_names,
+            {"default", "sycl-spir64", "sycl-spir64_x86_64"},
+        )
 
         for p in passes:
             if p.pass_name == "default":
-                expected = ["_OPENMP"]
-                self.assertEqual(p.defines, ["_OPENMP"])
-            elif p.pass_name == "spir64" or p.pass_name == "x86_64":
-                expected = ["__SYCL_DEVICE_ONLY__", "__SPIR__", "__SPIRV__"]
-            self.assertEqual(p.defines, expected)
+                expected = ["SYCL_LANGUAGE_VERSION", "_OPENMP"]
+            elif (
+                p.pass_name == "sycl-spir64"
+                or p.pass_name == "sycl-spir64_x86_64"
+            ):
+                expected = [
+                    "SYCL_LANGUAGE_VERSION",
+                    "__SYCL_DEVICE_ONLY__",
+                    "__SPIR__",
+                    "__SPIRV__",
+                ]
+            self.assertCountEqual(p.defines, expected)
 
     def test_nvcc(self):
         """compilers/nvcc"""
         argv = [
             "nvcc",
             "-fopenmp",
-            "--gpu-architecture=compute_50",
-            "--gpu-code=compute_50,sm_50,sm_52",
+            "--gpu-architecture=compute_70",
+            "--gpu-code=compute_70,sm_70,sm_75",
             "test.cpp",
         ]
 
-        parser = config.recognize_compiler(argv[0])
-        self.assertTrue(type(parser) is config.NvccArgumentParser)
+        parser = ArgumentParser(argv[0])
 
         passes = parser.parse_args(argv[1:])
 
         pass_names = {p.pass_name for p in passes}
-        self.assertEqual(pass_names, {"default", "50", "52"})
+        self.assertCountEqual(pass_names, {"default", "sm_70", "sm_75"})
 
         defaults = ["__NVCC__", "__CUDACC__"]
         for p in passes:
             if p.pass_name == "default":
                 expected = defaults + ["_OPENMP"]
-            elif p.pass_name == "50":
-                expected = defaults + ["__CUDA_ARCH__=500"]
-            elif p.pass_name == "52":
-                expected = defaults + ["__CUDA_ARCH__=520"]
-            self.assertEqual(p.defines, expected)
+            elif p.pass_name == "sm_70":
+                expected = defaults + ["__CUDA_ARCH__=700"]
+            elif p.pass_name == "sm_75":
+                expected = defaults + ["__CUDA_ARCH__=750"]
+            self.assertCountEqual(p.defines, expected)
 
     def test_user_options(self):
         """Check that we import user-defined options"""
@@ -166,14 +183,15 @@ def test_user_options(self):
         with open(path / ".cbi" / "config", mode="w") as f:
             f.write('[compiler."c++"]\n')
             f.write('options = ["-D", "ASDF"]\n')
-        config.load_importcfg()
+        config._importcfg = None
+        config._load_compilers()
 
         argv = [
             "c++",
             "test.cpp",
         ]
 
-        parser = config.recognize_compiler(argv[0])
+        parser = ArgumentParser(argv[0])
         passes = parser.parse_args(argv[1:])
         self.assertEqual(len(passes), 1)
         self.assertCountEqual(passes[0].defines, ["ASDF"])