Test compiling (#46)

Added acceptance tests for more CPU-architectures. Added acceptance tests for PE-files for x86.

test/acceptance/test_cwe190.py

@@ -8,33 +8,159 @@ class TestCwe190(unittest.TestCase):
         self.target = '190'
         self.string = b'Integer Overflow or Wraparound'
 
+    @unittest.skip("FIXME")
     def test_cwe190_01_arm_gcc(self):
         expect_res = 3
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe190_01_aarch64_gcc(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
     def test_cwe190_01_x86_gcc(self):
         expect_res = 3
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
     def test_cwe190_01_x64_gcc(self):
         expect_res = 3
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe190_01_mips_gcc(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe190_01_mipsel_gcc(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe190_01_mips64_gcc(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe190_01_mips64el_gcc(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe190_01_ppc_gcc(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe190_01_ppc64_gcc(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe190_01_ppc64le_gcc(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe190_01_arm_clang(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe190_01_aarch64_clang(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe190_01_x86_clang(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     def test_cwe190_01_x64_clang(self):
         expect_res = 3
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Depends on proper MIPS support in BAP")
-    def test_cwe190_01_mips_gcc(self):
+    def test_cwe190_01_mips_clang(self):
         expect_res = 3
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe190_01_ppc_gcc(self):
+    @unittest.skip("FIXME")
+    def test_cwe190_01_mipsel_clang(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe190_01_mips64_clang(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe190_01_mips64el_clang(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe190_01_ppc64_clang(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe190_01_ppc64le_clang(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe190_01_x86_mingw_gcc(self):
+        expect_res = 3
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'mingw32-gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe190_01_x64_mingw_gcc(self):
         expect_res = 3
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'mingw32-gcc', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe215.py

@@ -9,32 +9,146 @@ class TestCwe215(unittest.TestCase):
         self.filename = '476'
         self.string = b'Information Exposure Through Debug Information'
 
-    def test_cwe215_01_arm_gcc(self):
+    def test_cwe215_01_x64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'x64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe215_01_x64_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.filename, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'x64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     def test_cwe215_01_x86_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.filename, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'x86', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe215_01_x64_gcc(self):
+    def test_cwe215_01_x86_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.filename, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'x86', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe215_01_x64_clang(self):
+    def test_cwe215_01_arm_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.filename, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'arm', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe215_01_ppc_gcc(self):
+    def test_cwe215_01_arm_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'arm', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe215_01_aarch64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'aarch64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe215_01_aarch64_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.filename, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'aarch64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     def test_cwe215_01_mips_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.filename, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe215_01_mips_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'mips', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe215_01_mipsel_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'mipsel', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe215_01_mipsel_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe215_01_mips64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe215_01_mips64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe215_01_mips64el_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe215_01_mips64el_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'mips64el', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe215_01_ppc_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe215_01_ppc64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe215_01_ppc64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe215_01_ppc64le_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe215_01_ppc64le_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'ppc64le', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe215_01_x86_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'x86', 'mingw32-gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe215_01_x64_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.filename, self.target, 'x64', 'mingw32-gcc', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe243.py

@@ -8,65 +8,292 @@ class TestCwe243(unittest.TestCase):
         self.target = '243'
         self.string = b'The program utilizes chroot without dropping privileges and/or changing the directory'
 
-    def test_cwe243_01_arm_gcc(self):
+    def test_cwe243_01_x64_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe243_01_x64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     def test_cwe243_01_x86_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe243_01_x64_gcc(self):
+    def test_cwe243_01_x86_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe243_01_x64_clang(self):
+    @unittest.skip("FIXME")
+    def test_cwe243_01_arm_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe243_01_ppc_gcc(self):
+    @unittest.skip("FIXME")
+    def test_cwe243_01_arm_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    @unittest.skip("Depends on proper MIPS support in BAP")
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe243_01_aarch64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe243_01_aarch64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
     def test_cwe243_01_mips_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe243_02_arm_gcc(self):
+    @unittest.skip("Depends on proper MIPS support in BAP")
+    def test_cwe243_01_mips_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_01_mipsel_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_01_mipsel_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_01_mips64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_01_mips64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_01_mips64el_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_01_mips64el_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_01_ppc_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe243_01_ppc64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe243_01_ppc64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_01_ppc64le_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_01_ppc64le_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_02_x64_gcc(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'x64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_02_x64_clang(self):
         expect_res = 0
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target + "_clean", self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'x64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Investigate and fix this issue")
     def test_cwe243_02_x86_gcc(self):
         expect_res = 0
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target + "_clean", self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'x86', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe243_02_x64_gcc(self):
+    @unittest.skip("FIXME")
+    def test_cwe243_02_x86_clang(self):
         expect_res = 0
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target + "_clean", self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'x86', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe243_02_x64_clang(self):
+    @unittest.skip("FIXME")
+    def test_cwe243_02_arm_gcc(self):
         expect_res = 0
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target + "_clean", self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'arm', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe243_02_ppc_gcc(self):
+    @unittest.skip("FIXME")
+    def test_cwe243_02_arm_clang(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'arm', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe243_02_aarch64_gcc(self):
         expect_res = 0
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target + "_clean", self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'aarch64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe243_02_aarch64_clang(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'aarch64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Depends on proper MIPS support in BAP")
-    def test_cwe476_02_mips_gcc(self):
+    def test_cwe243_02_mips_gcc(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_02_mips_clang(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'mips', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_02_mipsel_gcc(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'mipsel', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_02_mipsel_clang(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_02_mips64_gcc(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_02_mips64_clang(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_02_mips64el_gcc(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_02_mips64el_clang(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'mips64el', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_02_ppc_gcc(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe243_02_ppc64_gcc(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe243_02_ppc64_clang(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_02_ppc64le_gcc(self):
+        expect_res = 0
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe243_02_ppc64le_clang(self):
         expect_res = 0
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target + "_clean", self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target + '_clean', 'ppc64le', 'clang', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe248.py

@@ -8,35 +8,106 @@ class TestCwe248(unittest.TestCase):
         self.target = '248'
         self.string = b'Possibly Uncaught Exception'
 
-    def test_cwe248_01_arm_gcc(self):
+    def test_cwe248_01_x64_gcc(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'g++', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe248_01_x64_clang(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'clang++', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Fix CPP compilation issue for x86")
     def test_cwe248_01_x86_gcc(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'g++', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe248_01_x64_gcc(self):
+    @unittest.skip("FIXME")
+    def test_cwe248_01_x86_clang(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'clang++', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe248_01_x64_clang(self):
+    @unittest.skip("FIXME")
+    def test_cwe248_01_arm_gcc(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'g++', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe248_01_aarch64_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'g++', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Depends on proper MIPS support in BAP")
     def test_cwe248_01_mips_gcc(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'g++', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe248_01_mipsel_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'g++', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe248_01_mips64_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'g++', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe248_01_mips64el_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'g++', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("FIXME")
     def test_cwe248_01_ppc_gcc(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc', 'g++', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe248_01_ppc64_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'g++', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe248_01_ppc64le_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'g++', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe248_01_x86_mingw_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'mingw32-g++', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe248_01_x64_mingw_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'mingw32-g++', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe332.py

@@ -8,33 +8,159 @@ class TestCwe332(unittest.TestCase):
         self.target = '332'
         self.string = b'Insufficient Entropy in PRNG'
 
-    def test_cwe332_01_arm_gcc(self):
+    def test_cwe332_01_x64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe332_01_x64_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     def test_cwe332_01_x86_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe332_01_x64_gcc(self):
+    def test_cwe332_01_x86_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe332_01_x64_clang(self):
+    @unittest.skip("FIXME")
+    def test_cwe332_01_arm_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe332_01_arm_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe332_01_aarch64_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    @unittest.skip("Depends on proper MIPS support in BAP")
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe332_01_aarch64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
     def test_cwe332_01_mips_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe332_01_mips_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe332_01_mipsel_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
+    @unittest.skip("FIXME")
+    def test_cwe332_01_mipsel_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Depends on proper MIPS support in BAP')
+    def test_cwe332_01_mips64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe332_01_mips64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe332_01_mips64el_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe332_01_mips64el_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
     def test_cwe332_01_ppc_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe332_01_ppc64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe332_01_ppc64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe332_01_ppc64le_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe332_01_ppc64le_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe332_01_x86_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'mingw32-gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe332_01_x64_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'mingw32-gcc', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe367.py

@@ -8,33 +8,159 @@ class TestCwe367(unittest.TestCase):
         self.target = '367'
         self.string = b'Time-of-check Time-of-use Race Condition'
 
-    def test_cwe367_01_arm_gcc(self):
+    def test_cwe367_01_x64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe367_01_x64_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     def test_cwe367_01_x86_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe367_01_x64_gcc(self):
+    def test_cwe367_01_x86_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe367_01_x64_clang(self):
+    @unittest.skip('FIXME!')
+    def test_cwe367_01_arm_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe367_01_arm_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe367_01_aarch64_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    @unittest.skip("Depends on proper MIPS support in BAP")
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe367_01_aarch64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Depends on proper MIPS support in BAP')
     def test_cwe367_01_mips_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe367_01_mips_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe367_01_mipsel_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
+    @unittest.skip('FIXME!')
+    def test_cwe367_01_mipsel_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe367_01_mips64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe367_01_mips64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe367_01_mips64el_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe367_01_mips64el_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
     def test_cwe367_01_ppc_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe367_01_ppc64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe367_01_ppc64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe367_01_ppc64le_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe367_01_ppc64le_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe367_01_x86_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'mingw32-gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe367_01_x64_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'mingw32-gcc', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe415.py

@@ -8,35 +8,162 @@ class TestCwe415(unittest.TestCase):
         self.target = '415'
         self.string = b'Double Free'
 
-    def test_cwe415_01_arm_gcc(self):
-        expect_res = 5
-        res = cwe_checker_testlib.execute_emulation_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
-        self.assertEqual(res, expect_res)
-
-    def test_cwe415_01_x86_gcc(self):
-        expect_res = 5
-        res = cwe_checker_testlib.execute_emulation_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
-        self.assertEqual(res, expect_res)
-
     @unittest.skip("FIXME: broken on Ubuntu 18.04 with the corresponding gcc version")
     def test_cwe415_01_x64_gcc(self):
         expect_res = 9
-        res = cwe_checker_testlib.execute_emulation_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("FIXME: broken on Ubuntu 18.04 with the corresponding clang version")
     def test_cwe415_01_x64_clang(self):
         expect_res = 9
-        res = cwe_checker_testlib.execute_emulation_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME: yields different results on Ubuntu 16.04 and 18.04")
+    def test_cwe415_01_x86_gcc(self):
+        expect_res = 5
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'x86', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe415_01_x86_clang(self):
+        expect_res = 5
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'x86', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe415_01_arm_gcc(self):
+        expect_res = 5
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'arm', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe415_01_arm_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'arm', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe415_01_aarch64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'aarch64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe415_01_aarch64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'aarch64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Depends on proper MIPS support in BAP")
     def test_cwe415_01_mips_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_emulation_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe415_01_mips_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mips', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe415_01_mipsel_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mipsel', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
+    @unittest.skip("FIXME")
+    def test_cwe415_01_mipsel_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe415_01_mips64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe415_01_mips64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe415_01_mips64el_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe415_01_mips64el_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mips64el', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
     def test_cwe415_01_ppc_gcc(self):
         expect_res = 3
-        res = cwe_checker_testlib.execute_emulation_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe415_01_ppc64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe415_01_ppc64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe415_01_ppc64le_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe415_01_ppc64le_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe415_01_x86_mingw_gcc(self):
+        expect_res = 5
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'x86', 'mingw32-gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe415_01_x64_mingw_gcc(self):
+        expect_res = 9
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'x64', 'mingw32-gcc', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe416.py

@@ -8,35 +8,162 @@ class TestCwe416(unittest.TestCase):
         self.target = '416'
         self.string = b'Use After Free'
 
+    @unittest.skip("FIXME: broken on Ubuntu 18.04 with the corresponding gcc version")
+    def test_cwe416_01_x64_gcc(self):
+        expect_res = 4
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME: broken on Ubuntu 18.04 with the corresponding clang version")
+    def test_cwe416_01_x64_clang(self):
+        expect_res = 4
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME: yields different results on Ubuntu 16.04 and 18.04")
+    def test_cwe416_01_x86_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'x86', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe416_01_x86_clang(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'x86', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
     def test_cwe416_01_arm_gcc(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_emulation_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'arm', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe416_01_x86_gcc(self):
+    @unittest.skip("FIXME")
+    def test_cwe416_01_arm_clang(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_emulation_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'arm', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    @unittest.skip("FIXME: broken on Ubuntu 18.04 with the corresponding gcc version")
-    def test_cwe416_01_x64_gcc(self):
-        expect_res = 4
-        res = cwe_checker_testlib.execute_emulation_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe416_01_aarch64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'aarch64', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    @unittest.skip("FIXME: broken on Ubuntu 18.04 with the corresponding clang version")
-    def test_cwe416_01_x64_clang(self):
-        expect_res = 4
-        res = cwe_checker_testlib.execute_emulation_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe416_01_aarch64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'aarch64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Depends on proper MIPS support in BAP")
     def test_cwe416_01_mips_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_emulation_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe416_01_mips_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mips', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
+    @unittest.skip("FIXME")
+    def test_cwe416_01_mipsel_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mipsel', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe416_01_mipsel_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe416_01_mips64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe416_01_mips64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe416_01_mips64el_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe416_01_mips64el_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'mips64el', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
     def test_cwe416_01_ppc_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_emulation_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe416_01_ppc64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe416_01_ppc64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe416_01_ppc64le_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe416_01_ppc64le_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe416_01_x86_mingw_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'x86', 'mingw32-gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe416_01_x64_mingw_gcc(self):
+        expect_res = 4
+        res = cwe_checker_testlib.execute_emulation_and_check_occurence(
+            self.target, self.target, 'x64', 'mingw32-gcc', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe426.py

@@ -8,34 +8,147 @@ class TestCwe426(unittest.TestCase):
         self.target = '426'
         self.string = b'Untrusted Search Path'
 
-    def test_cwe426_01_arm_gcc(self):
+    def test_cwe426_01_x64_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    @unittest.skip("FIXME")
+    def test_cwe426_01_x64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
     def test_cwe426_01_x86_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe426_01_x64_gcc(self):
+    def test_cwe426_01_x86_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe426_01_x64_clang(self):
+    @unittest.skip('FIXME!')
+    def test_cwe426_01_arm_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe426_01_arm_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe426_01_aarch64_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe426_01_aarch64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Depends on proper MIPS support in BAP")
     def test_cwe426_01_mips_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+
+    @unittest.skip('FIXME!')
+    def test_cwe426_01_mips_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe426_01_mipsel_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe426_01_mipsel_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe426_01_mips64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe426_01_mips64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe426_01_mips64el_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe426_01_mips64el_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
+    @unittest.skip('FIXME!')
     def test_cwe426_01_ppc_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe426_01_ppc64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe426_01_ppc64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe426_01_ppc64le_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe426_01_ppc64le_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'clang', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe457.py

@@ -9,37 +9,162 @@ class TestCwe457(unittest.TestCase):
         self.string = b'Use of Uninitialized Variable'
 
     @unittest.skip("FIXME")
-    def test_cwe457_01_arm_gcc(self):
+    def test_cwe457_01_x64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe457_01_x64_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("FIXME")
     def test_cwe457_01_x86_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe457_01_x86_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("FIXME")
-    def test_cwe457_01_x64_gcc(self):
+    def test_cwe457_01_arm_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("FIXME")
-    def test_cwe457_01_x64_clang(self):
+    def test_cwe457_01_arm_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe457_01_aarch64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe457_01_aarch64_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Depends on proper MIPS support in BAP")
     def test_cwe457_01_mips_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe457_01_mips_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe457_01_mipsel_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe457_01_mipsel_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe457_01_mips64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe457_01_mips64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe457_01_mips64el_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe457_01_mips64el_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("FIXME")
     def test_cwe457_01_ppc_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe457_01_ppc64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe457_01_ppc64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe457_01_ppc64le_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe457_01_ppc64le_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe457_01_x86_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'mingw32-gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe457_01_x64_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'mingw32-gcc', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe467.py

@@ -8,34 +8,160 @@ class TestCwe467(unittest.TestCase):
         self.target = '467'
         self.string = b'Use of sizeof on a Pointer Type'
 
-    def test_cwe467_01_arm_gcc(self):
+    def test_cwe467_01_x64_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe467_01_x64_clang(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    @unittest.skip("FIXME")
+    @unittest.skip('FIXME!')
     def test_cwe467_01_x86_gcc(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe467_01_x64_gcc(self):
+    def test_cwe467_01_x86_clang(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe467_01_x64_clang(self):
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_arm_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_arm_clang(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe467_01_aarch64_gcc(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe467_01_aarch64_clang(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Depends on proper MIPS support in BAP")
     def test_cwe467_01_mips_gcc(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_mips_clang(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_mipsel_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_mipsel_clang(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_mips64_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_mips64_clang(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_mips64el_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_mips64el_clang(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
     def test_cwe467_01_ppc_gcc(self):
         expect_res = 2
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe467_01_ppc64_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe467_01_ppc64_clang(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_ppc64le_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_ppc64le_clang(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_x86_mingw_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'mingw32-gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe467_01_x64_mingw_gcc(self):
+        expect_res = 2
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'mingw32-gcc', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe476.py

@@ -8,35 +8,161 @@ class TestCwe476(unittest.TestCase):
         self.target = '476'
         self.string = b'NULL Pointer Dereference'
 
-    def test_cwe476_01_arm_gcc(self):
+    def test_cwe476_01_x64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_x64_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     def test_cwe476_01_x86_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe476_01_x64_gcc(self):
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_x86_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    @unittest.skip("FIXME")
-    def test_cwe476_01_x64_clang(self):
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_arm_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_arm_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe476_01_aarch64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe476_01_aarch64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Depends on proper MIPS support in BAP")
     def test_cwe476_01_mips_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_mips_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_mipsel_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_mipsel_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_mips64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_mips64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_mips64el_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_mips64el_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Fix issue in CWE476 implementation to support PPC")
     def test_cwe476_01_ppc_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("Fix issue in CWE476 implementation to support PPC")
+    def test_cwe476_01_ppc64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("Fix issue in CWE476 implementation to support PPC")
+    def test_cwe476_01_ppc64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("Fix issue in CWE476 implementation to support PPC")
+    def test_cwe476_01_ppc64le_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("Fix issue in CWE476 implementation to support PPC")
+    def test_cwe476_01_ppc64le_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_x86_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'mingw32-gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe476_01_x64_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'mingw32-gcc', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe560.py

@@ -8,34 +8,160 @@ class TestCwe560(unittest.TestCase):
         self.target = '560'
         self.string = b'Use of umask() with chmod-style Argument'
 
+    def test_cwe560_01_x64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe560_01_x64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe560_01_x86_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe560_01_x86_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
     @unittest.skip("Args of umask to not seem to be found by BAP. Investigate in the future")
     def test_cwe560_01_arm_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe560_01_x86_gcc(self):
+    @unittest.skip('FIXME!')
+    def test_cwe560_01_arm_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe560_01_x64_gcc(self):
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe560_01_aarch64_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe560_01_x64_clang(self):
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe560_01_aarch64_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Depends on proper MIPS support in BAP")
     def test_cwe560_01_mips_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe560_01_mips_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe560_01_mipsel_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
+    @unittest.skip('FIXME!')
+    def test_cwe560_01_mipsel_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe560_01_mips64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe560_01_mips64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe560_01_mips64el_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe560_01_mips64el_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
     def test_cwe560_01_ppc_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe560_01_ppc64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe560_01_ppc64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe560_01_ppc64le_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe560_01_ppc64le_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe560_01_x86_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'mingw32-gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe560_01_x64_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'mingw32-gcc', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe676.py

@@ -8,33 +8,159 @@ class TestCwe676(unittest.TestCase):
         self.target = '676'
         self.string = b'Use of Potentially Dangerous Function'
 
-    def test_cwe676_01_arm_gcc(self):
+    def test_cwe676_01_x64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    def test_cwe676_01_x64_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'arm', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     def test_cwe676_01_x86_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x86', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe676_01_x64_gcc(self):
+    def test_cwe676_01_x86_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
-    def test_cwe676_01_x64_clang(self):
+    @unittest.skip('FIXME!')
+    def test_cwe676_01_arm_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe676_01_arm_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'arm', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe676_01_aarch64_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe676_01_aarch64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'aarch64', 'clang', self.string)
         self.assertEqual(res, expect_res)
 
     @unittest.skip("Depends on proper MIPS support in BAP")
     def test_cwe676_01_mips_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'mips', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe676_01_mips_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe676_01_mipsel_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
+    @unittest.skip('FIXME!')
+    def test_cwe676_01_mipsel_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mipsel', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe676_01_mips64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe676_01_mips64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe676_01_mips64el_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe676_01_mips64el_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'mips64el', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
     def test_cwe676_01_ppc_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'ppc', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe676_01_ppc64_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('Not supported by BAP. (no recognizable code backtrace)')
+    def test_cwe676_01_ppc64_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe676_01_ppc64le_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip('FIXME!')
+    def test_cwe676_01_ppc64le_clang(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'ppc64le', 'clang', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe676_01_x86_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x86', 'mingw32-gcc', self.string)
+        self.assertEqual(res, expect_res)
+
+    @unittest.skip("FIXME")
+    def test_cwe676_01_x64_mingw_gcc(self):
+        expect_res = 1
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'mingw32-gcc', self.string)
         self.assertEqual(res, expect_res)

test/acceptance/test_cwe782.py

@@ -10,10 +10,12 @@ class TestCwe782(unittest.TestCase):
 
     def test_cwe782_01_x64_gcc(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'gcc', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'gcc', self.string)
         self.assertEqual(res, expect_res)
 
     def test_cwe782_01_x64_clang(self):
         expect_res = 1
-        res = cwe_checker_testlib.execute_and_check_occurence(self.target, self.target, 'x64', 'clang', self.string)
+        res = cwe_checker_testlib.execute_and_check_occurence(
+            self.target, self.target, 'x64', 'clang', self.string)
         self.assertEqual(res, expect_res)

test/artificial_samples/SConstruct

@@ -2,49 +2,80 @@ import os
 
 build_path = 'build'
 
-supported_architectures = ['x64', 'x86', 'arm', 'mips', 'ppc']
-
-c_compilers = {'x64': ['gcc', 'clang'],
-               'x86': ['./dockcross-linux-x86 gcc'],
-               'arm': ['arm-linux-gnueabi-gcc'],
-               'mips': ['mips-linux-gnu-gcc'],
-               'ppc': ['powerpc-linux-gnu-gcc']}
-
-c_linkers =   {'x86': './dockcross-linux-x86 gcc -m32'}
-
-cpp_compilers = {'x64': ['g++', 'clang'],
-                 'x86': ['./dockcross-linux-x86 g++'],
+supported_architectures = ['x64', 'x86', 'arm', 'aarch64', 'mips', 'mipsel', 'mips64', 'mips64el', 'ppc', 'ppc64', 'ppc64le']
+skip_for_pe = ['cwe_782.c', 'cwe_426.c', 'cwe_243.c', 'cwe_243_clean.c']
+
+c_compilers = {'x64': ['gcc', 'x86_64-w64-mingw32-gcc', 'clang'],
+               'x86': ['gcc', 'i686-w64-mingw32-gcc', 'clang'],
+               'arm': ['arm-linux-gnueabi-gcc', 'clang'],
+               'aarch64': ['aarch64-linux-gnu-gcc', 'clang'],
+               'mips': ['mips-linux-gnu-gcc', 'clang'],
+               'mipsel': ['mipsel-linux-gnu-gcc', 'clang'],
+               'mips64': ['mips64-linux-gnuabi64-gcc', 'clang'],
+               'mips64el': ['mips64el-linux-gnuabi64-gcc', 'clang'],
+               'ppc': ['powerpc-linux-gnu-gcc'],
+               'ppc64': ['powerpc64-linux-gnu-gcc', 'clang'],
+               'ppc64le': ['powerpc64le-linux-gnu-gcc', 'clang']}
+
+cpp_compilers = {'x64': ['g++', 'x86_64-w64-mingw32-g++', 'clang++'],
+                 'x86': ['g++', 'i686-w64-mingw32-g++', 'clang++'],
                  'arm': ['arm-linux-gnueabi-g++'],
+                 'aarch64': ['aarch64-linux-gnu-g++'],
                  'mips': ['mips-linux-gnu-g++'],
-                 'ppc': ['powerpc-linux-gnu-g++']}
-
-c_flags = {'x64': '-g -fno-stack-protector -std=c11',
-           'x86': '-g -m32 -fno-stack-protector -std=c11',
-           'arm': '-g -fno-stack-protector -std=c11',
-           'mips': '-g -fno-stack-protector -std=c11',
-           'ppc': '-g -fno-stack-protector -std=c11'}
-
-cpp_flags = {'x64': '-g -fno-stack-protector',
-             'x86': '-g -m32 -fno-stack-protector',
-             'arm': '-g -fno-stack-protector',
-             'mips': '-g -fno-stack-protector',
-             'ppc': '-g -fno-stack-protector'}
-
-cpp_linkers =   {'x86': './dockcross-linux-x86 g++ -m32'}
+                 'mipsel': ['mipsel-linux-gnu-g++'],
+                 'mips64': ['mips64-linux-gnuabi64-g++'],
+                 'mips64el': ['mips64el-linux-gnuabi64-g++'],
+                 'ppc': ['powerpc-linux-gnu-g++'],
+                 'ppc64': ['powerpc64-linux-gnu-g++'],
+                 'ppc64le': ['powerpc64le-linux-gnu-g++']}
+
+flags = {'x64': ' -g -fno-stack-protector -std=c11',
+         'x86': ' -g -m32 -fno-stack-protector -std=c11',
+         'arm': ' -g -fno-stack-protector -std=c11',
+         'aarch64': ' -g -fno-stack-protector -std=c11',
+         'mips': ' -g -fno-stack-protector -std=c11',
+         'mipsel': ' -g -fno-stack-protector -std=c11',
+         'mips64': ' -g -fno-stack-protector -std=c11',
+         'mips64el': ' -g -fno-stack-protector -std=c11',
+         'ppc': ' -g -fno-stack-protector -std=c11',
+         'ppc64': ' -g -fno-stack-protector -std=c11',
+         'ppc64le': ' -g -fno-stack-protector -std=c11'}
+
+target_flags = {'x64': '',
+               'x86': ' -m32 ',
+               'arm': ' -target arm-linux-gnueabi',
+               'aarch64': ' -target aarch64-linux-gnu',
+               'mips': ' -target mips-linux-gnu',
+               'mipsel': ' -target mipsel-linux-gnu',
+               'mips64': ' -target mips64-linux-gnuabi64',
+               'mips64el': ' -target mips64-linux-gnuabi64',
+               'ppc64': ' -target powerpc64-linux-gnu',
+               'ppc64le': ' -target powerpc64le-linux-gnu'}
+
+
+cpp_flags = {'x64': ' -g -fno-stack-protector',
+             'x86': ' -m32 -g -fno-stack-protector',
+             'arm': ' -g -fno-stack-protector',
+             'aarch64': ' -g -fno-stack-protector',
+             'mips': ' -g -fno-stack-protector',
+             'mipsel': ' -g -fno-stack-protector',
+             'mips64': ' -g -fno-stack-protector',
+             'mips64el': ' -g -fno-stack-protector',
+             'ppc': ' -g -fno-stack-protector',
+             'ppc64': ' -g -fno-stack-protector',
+             'ppc64le': ' -g -fno-stack-protector',}
 
 def which(pgm):
-    # check dockcross installation
-    if pgm.startswith('.') and os.path.isfile(pgm.split()[0]):
-        return pgm
-    elif pgm.startswith('.') and not (os.path.isfile(pgm.split()[0])):
-        return None
-
     # check compilers on path
     path = os.getenv('PATH')
     for p in path.split(os.path.pathsep):
         p = os.path.join(p,pgm)
         if os.path.exists(p) and os.access(p,os.X_OK):
             return p
+    print('Compiler %s not in path!' % pgm)
+
+    return None
+
 
 def optimize(filename):
     optimize_me = ['cwe_476.c']
@@ -53,52 +84,69 @@ def optimize(filename):
     else:
         return ' -O0'
 
+
 def get_compiler_abrev(compiler_name):
-    if 'clang' in compiler_name:
+    if 'clang' == compiler_name:
         return 'clang'
-    else:
-        return 'gcc'
+    if 'clang++' == compiler_name:
+        return 'clang++'
+    if 'mingw32-g++' in compiler_name:
+        return 'mingw32-g++'
+    if 'g++' in compiler_name:
+        return 'g++'
+    if 'mingw32-gcc' in compiler_name:
+        return 'mingw32-gcc'
+
+    return 'gcc'
+
 
 def compile_only_on_x64(filename, arch):
     only_x64 = ['cwe_782.c']
     return filename in only_x64 and arch != 'x64'
 
+
 def build_c(arch, compiler):
     if which(compiler) is not None:
-        c_programs = Glob('*.c')
-        for p in c_programs:
-            if compile_only_on_x64(str(p), arch):
-                print('Skipping architecture %s for %s' % (arch, str(p)))
+        for prog in Glob('*.c'):
+            if compile_only_on_x64(str(prog), arch):
+                print('Skipping architecture %s for %s' % (arch, str(prog)))
                 continue
-            
+
             env = Environment()
             env['CC'] = compiler
-            env['CCFLAGS'] = c_flags[arch] + optimize(str(p))
-            if arch in c_linkers:
-                env['LINK'] = c_linkers[arch]
+            if compiler == 'clang':
+                env['CCFLAGS'] = target_flags[arch] + flags[arch] + optimize(str(prog))
+                env['LINKFLAGS'] = target_flags[arch]
+            else:
+                env['CCFLAGS'] = flags[arch] + optimize(str(prog))
+                if arch == 'x86':
+                    env['LINKFLAGS'] = '-m32'
 
             compiler_abrev = get_compiler_abrev(compiler)
-            env.Program('%s/%s_%s_%s.out' % (build_path, str(p).split('.')[0], arch, compiler_abrev),
-                        env.Object(target='%s/%s_%s_%s.o' % (build_path, str(p), arch, compiler_abrev),
-                                   source='%s/%s' % (build_path, str(p))))
+            if compiler_abrev == 'mingw32-gcc' and str(prog) in skip_for_pe:
+                continue
+            env.Program('%s/%s_%s_%s.out' % (build_path, str(prog).split('.')[0], arch, compiler_abrev),
+                        env.Object(target='%s/%s_%s_%s.o' % (build_path, str(prog), arch, compiler_abrev),
+                        source='%s/%s' % (build_path, str(prog))))
     else:
         print('Compiler %s for architecture %s is not installed!' % (compiler, arch))
 
 
 def build_cpp(arch, compiler):
     if which(compiler) is not None:
-        cpp_programs = Glob('*.cpp')
-        for p in cpp_programs:
+        for prog in Glob('*.cpp'):
             env = Environment()
-            env['CCP'] = compiler
-            env['CCPFLAGS'] = cpp_flags[arch] + optimize(str(p))
-            if arch in c_linkers:
-                env['CPPLINK'] = cpp_linkers[arch]
-
+            env['CXX'] = compiler
+            env['CXXFLAGS'] = cpp_flags[arch] + optimize(str(prog))
+            if arch == 'x86':
+                env['LINKFLAGS'] = '-m32'
+ 
             compiler_abrev = get_compiler_abrev(compiler)
-            env.Program('%s/%s_%s_%s.out' % (build_path, str(p).split('.')[0], arch, compiler_abrev),
-                        env.Object(target='%s/%s_%s_%s.o' % (build_path, str(p), arch, compiler_abrev),
-                                   source='%s/%s' % (build_path, str(p))))
+            if compiler_abrev == 'mingw32-g++' and str(prog) in skip_for_pe:
+                    continue
+            env.Program('%s/%s_%s_%s.out' % (build_path, str(prog).split('.')[0], arch, compiler_abrev),
+                        env.Object(target='%s/%s_%s_%s.o' % (build_path, str(prog), arch, compiler_abrev),
+                        source='%s/%s' % (build_path, str(prog))))
     else:
         print('Compiler %s for architecture %s is not installed!' % (compiler, arch))
 
@@ -108,4 +156,5 @@ for arch in supported_architectures:
     print('Building for architecture %s' % arch)
     for compiler in c_compilers[arch]:
         build_c(arch, compiler)
+    for compiler in cpp_compilers[arch]:
         build_cpp(arch, compiler)

test/artificial_samples/cwe_190.c

-#import <stdio.h>
-#import <stdlib.h>
-#import <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #define png_t 4242
 

test/artificial_samples/cwe_191.c

@@ -10,7 +10,7 @@ void integer_underflow_subtraction(){
 
 
 
-main (void)
+int main (void)
 {
         integer_underflow_subtraction();
 }

test/artificial_samples/cwe_243.c

+#define _GNU_SOURCE
+
 #include <stdio.h>
 #include <unistd.h>
 
@@ -11,5 +13,3 @@ void chroot_fail(){
 int main(void) {
   chroot_fail();
 }
-
-     

test/artificial_samples/cwe_243_clean.c

+#define _GNU_SOURCE
+
 #include <stdio.h>
 #include <unistd.h>
 
@@ -15,7 +17,7 @@ void chroot_safe2(){
   if (chroot("/tmp") != 0) {
     perror("chroot /tmp");
   }
-  setresuid(1077);
+  setresuid(1077, 1077, 1077);
 }
 
 void chroot_safe3(){
@@ -41,5 +43,3 @@ int main(void) {
   chroot_safe3();
   chroot_safe4();
 }
-
-     

test/artificial_samples/cwe_426.c

 // taken from https://exploit-exercises.com/nebula/level01/
 
+#define _GNU_SOURCE
+
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>

test/artificial_samples/cwe_467.c

@@ -3,6 +3,7 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 
 #define AUTH_SUCCESS 1
 #define AUTH_FAIL 0

test/artificial_samples/cwe_476.c

 #include <stdlib.h>
+#include <stdio.h>
 
 void func1(){
   void* data = malloc(20000);

test/artificial_samples/install_cross_compilers.sh

 #!/bin/bash
+
 expected_version="18.04"
 actual_version=`lsb_release -r | awk '{ print $2 }'`
 
+echo "Installing cross compiler for Portable Executable x86/x86_64"
+sudo apt install -y mingw-w64
+
+
+echo "Installting multilibs for gcc and g++"
+sudo apt install -y gcc-multilib g++-multilib
 if [ "$expected_version" != "$actual_version" ]; then
-	echo "Probably running on Travis CI"
-    echo "Installing cross compiler for MIPS architecture."
-    sudo apt install -y gcc-multilib-mips-linux-gnu g++-5-mips-linux-gnu
-    echo "Installing cross compiler for PPC architecture."
-    sudo apt install -y gcc-multilib-powerpc-linux-gnu g++-5-powerpc-linux-gnu
-else
-    echo "Running on Ubuntu $expected_version"
-    echo "Installing cross compiler for MIPS architecture."
-    sudo apt install -y gcc-multilib-mips-linux-gnu g++-7-mips-linux-gnu
-    echo "Installing cross compiler for PPC architecture."
-    sudo apt install -y gcc-multilib-powerpc-linux-gnu g++-7-powerpc-linux-gnu
+    echo "Installing cross compiler for ELF x86 architecture."
+    sudo apt install -y gcc-i686-linux-gnu g++-i686-linux-gnu
 fi
+echo "Installing cross compiler for ELF ARM architecture."
+sudo apt install -y gcc-arm-linux-gnueabi g++-arm-linux-gnueabi
+sudo apt install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
+echo "Installing cross compiler for ELF MIPS architecture."
+sudo apt install -y gcc-mips-linux-gnu g++-mips-linux-gnu
+sudo apt install -y gcc-mipsel-linux-gnu g++-mipsel-linux-gnu
+sudo apt install -y gcc-mips64-linux-gnuabi64 g++-mips64-linux-gnuabi64
+sudo apt install -y gcc-mips64el-linux-gnuabi64 g++-mips64el-linux-gnuabi64
+echo "Installing cross compiler for ELF PPC architecture."
+sudo apt install -y gcc-powerpc-linux-gnu g++-powerpc-linux-gnu
+sudo apt install -y gcc-powerpc64-linux-gnu g++-powerpc64-linux-gnu
+sudo apt install -y gcc-powerpc64le-linux-gnu g++-powerpc64le-linux-gnu
+
+echo "Installing llvm compiler backend"
+sudo apt install -y llvm
+echo "Installing clang compiler frontend"
+sudo apt install -y clang
+
+sudo ln -s /usr/include/asm-generic /usr/include/asm
 
-echo "Installing cross compiler for ARM architecture."
-sudo apt install -y gcc-multilib-arm-linux-gnueabi g++-arm-linux-gnueabi
-echo "Installing dependencies for x86 compilation"
-sudo docker pull dockcross/linux-x86
-sudo docker run --rm dockcross/linux-x86 > ./dockcross-linux-x86
-chmod +x ./dockcross-linux-x86
-echo "Installing clang for x64 architecture"
-sudo apt install clang
 echo "Done."