169 lines
7.3 KiB
Python
Executable File
169 lines
7.3 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
"""Test internal functions within check_cfc.py."""
|
|
|
|
import check_cfc
|
|
import os
|
|
import platform
|
|
import unittest
|
|
|
|
|
|
class TestCheckCFC(unittest.TestCase):
|
|
|
|
def test_flip_dash_g(self):
|
|
self.assertIn('-g', check_cfc.flip_dash_g(['clang', '-c']))
|
|
self.assertNotIn('-g', check_cfc.flip_dash_g(['clang', '-c', '-g']))
|
|
self.assertNotIn(
|
|
'-g', check_cfc.flip_dash_g(['clang', '-g', '-c', '-g']))
|
|
|
|
def test_remove_dir_from_path(self):
|
|
bin_path = r'/usr/bin'
|
|
space_path = r'/home/user/space in path'
|
|
superstring_path = r'/usr/bin/local'
|
|
|
|
# Test removing last thing in path
|
|
self.assertNotIn(
|
|
bin_path, check_cfc.remove_dir_from_path(bin_path, bin_path))
|
|
|
|
# Test removing one entry and leaving others
|
|
# Also tests removing repeated path
|
|
path_var = os.pathsep.join(
|
|
[superstring_path, bin_path, space_path, bin_path])
|
|
stripped_path_var = check_cfc.remove_dir_from_path(path_var, bin_path)
|
|
self.assertIn(superstring_path, stripped_path_var)
|
|
self.assertNotIn(bin_path, stripped_path_var.split(os.pathsep))
|
|
self.assertIn(space_path, stripped_path_var)
|
|
|
|
# Test removing non-canonical path
|
|
self.assertNotIn(r'/usr//bin',
|
|
check_cfc.remove_dir_from_path(r'/usr//bin', bin_path))
|
|
|
|
if platform == 'Windows':
|
|
# Windows is case insensitive so should remove a different case
|
|
# path
|
|
self.assertNotIn(
|
|
bin_path, check_cfc.remove_dir_from_path(path_var, r'/USR/BIN'))
|
|
else:
|
|
# Case sensitive so will not remove different case path
|
|
self.assertIn(
|
|
bin_path, check_cfc.remove_dir_from_path(path_var, r'/USR/BIN'))
|
|
|
|
def test_is_output_specified(self):
|
|
self.assertTrue(
|
|
check_cfc.is_output_specified(['clang', '-o', 'test.o']))
|
|
self.assertTrue(check_cfc.is_output_specified(['clang', '-otest.o']))
|
|
self.assertFalse(
|
|
check_cfc.is_output_specified(['clang', '-gline-tables-only']))
|
|
# Not specified for implied output file name
|
|
self.assertFalse(check_cfc.is_output_specified(['clang', 'test.c']))
|
|
|
|
def test_get_output_file(self):
|
|
self.assertEqual(
|
|
check_cfc.get_output_file(['clang', '-o', 'test.o']), 'test.o')
|
|
self.assertEqual(
|
|
check_cfc.get_output_file(['clang', '-otest.o']), 'test.o')
|
|
self.assertIsNone(
|
|
check_cfc.get_output_file(['clang', '-gline-tables-only']))
|
|
# Can't get output file if more than one input file
|
|
self.assertIsNone(
|
|
check_cfc.get_output_file(['clang', '-c', 'test.cpp', 'test2.cpp']))
|
|
# No output file specified
|
|
self.assertIsNone(check_cfc.get_output_file(['clang', '-c', 'test.c']))
|
|
|
|
def test_derive_output_file(self):
|
|
# Test getting implicit output file
|
|
self.assertEqual(
|
|
check_cfc.derive_output_file(['clang', '-c', 'test.c']), 'test.o')
|
|
self.assertEqual(
|
|
check_cfc.derive_output_file(['clang', '-c', 'test.cpp']), 'test.o')
|
|
self.assertIsNone(check_cfc.derive_output_file(['clang', '--version']))
|
|
|
|
def test_is_normal_compile(self):
|
|
self.assertTrue(check_cfc.is_normal_compile(
|
|
['clang', '-c', 'test.cpp', '-o', 'test2.o']))
|
|
self.assertTrue(
|
|
check_cfc.is_normal_compile(['clang', '-c', 'test.cpp']))
|
|
# Outputting bitcode is not a normal compile
|
|
self.assertFalse(
|
|
check_cfc.is_normal_compile(['clang', '-c', 'test.cpp', '-flto']))
|
|
self.assertFalse(
|
|
check_cfc.is_normal_compile(['clang', '-c', 'test.cpp', '-emit-llvm']))
|
|
# Outputting preprocessed output or assembly is not a normal compile
|
|
self.assertFalse(
|
|
check_cfc.is_normal_compile(['clang', '-E', 'test.cpp', '-o', 'test.ii']))
|
|
self.assertFalse(
|
|
check_cfc.is_normal_compile(['clang', '-S', 'test.cpp', '-o', 'test.s']))
|
|
# Input of preprocessed or assembly is not a "normal compile"
|
|
self.assertFalse(
|
|
check_cfc.is_normal_compile(['clang', '-c', 'test.s', '-o', 'test.o']))
|
|
self.assertFalse(
|
|
check_cfc.is_normal_compile(['clang', '-c', 'test.ii', '-o', 'test.o']))
|
|
# Specifying --version and -c is not a normal compile
|
|
self.assertFalse(
|
|
check_cfc.is_normal_compile(['clang', '-c', 'test.cpp', '--version']))
|
|
self.assertFalse(
|
|
check_cfc.is_normal_compile(['clang', '-c', 'test.cpp', '--help']))
|
|
# Outputting dependency files is not a normal compile
|
|
self.assertFalse(
|
|
check_cfc.is_normal_compile(['clang', '-c', '-M', 'test.cpp']))
|
|
self.assertFalse(
|
|
check_cfc.is_normal_compile(['clang', '-c', '-MM', 'test.cpp']))
|
|
# Creating a dependency file as a side effect still outputs an object file
|
|
self.assertTrue(
|
|
check_cfc.is_normal_compile(['clang', '-c', '-MD', 'test.cpp']))
|
|
self.assertTrue(
|
|
check_cfc.is_normal_compile(['clang', '-c', '-MMD', 'test.cpp']))
|
|
|
|
def test_replace_output_file(self):
|
|
self.assertEqual(check_cfc.replace_output_file(
|
|
['clang', '-o', 'test.o'], 'testg.o'), ['clang', '-o', 'testg.o'])
|
|
self.assertEqual(check_cfc.replace_output_file(
|
|
['clang', '-otest.o'], 'testg.o'), ['clang', '-otestg.o'])
|
|
with self.assertRaises(Exception):
|
|
check_cfc.replace_output_file(['clang'], 'testg.o')
|
|
|
|
def test_add_output_file(self):
|
|
self.assertEqual(check_cfc.add_output_file(
|
|
['clang'], 'testg.o'), ['clang', '-o', 'testg.o'])
|
|
|
|
def test_set_output_file(self):
|
|
# Test output not specified
|
|
self.assertEqual(
|
|
check_cfc.set_output_file(['clang'], 'test.o'), ['clang', '-o', 'test.o'])
|
|
# Test output is specified
|
|
self.assertEqual(check_cfc.set_output_file(
|
|
['clang', '-o', 'test.o'], 'testb.o'), ['clang', '-o', 'testb.o'])
|
|
|
|
def test_get_input_file(self):
|
|
# No input file
|
|
self.assertIsNone(check_cfc.get_input_file(['clang']))
|
|
# Input C file
|
|
self.assertEqual(
|
|
check_cfc.get_input_file(['clang', 'test.c']), 'test.c')
|
|
# Input C++ file
|
|
self.assertEqual(
|
|
check_cfc.get_input_file(['clang', 'test.cpp']), 'test.cpp')
|
|
# Multiple input files
|
|
self.assertIsNone(
|
|
check_cfc.get_input_file(['clang', 'test.c', 'test2.cpp']))
|
|
self.assertIsNone(
|
|
check_cfc.get_input_file(['clang', 'test.c', 'test2.c']))
|
|
# Don't handle preprocessed files
|
|
self.assertIsNone(check_cfc.get_input_file(['clang', 'test.i']))
|
|
self.assertIsNone(check_cfc.get_input_file(['clang', 'test.ii']))
|
|
# Test identifying input file with quotes
|
|
self.assertEqual(
|
|
check_cfc.get_input_file(['clang', '"test.c"']), '"test.c"')
|
|
self.assertEqual(
|
|
check_cfc.get_input_file(['clang', "'test.c'"]), "'test.c'")
|
|
# Test multiple quotes
|
|
self.assertEqual(
|
|
check_cfc.get_input_file(['clang', "\"'test.c'\""]), "\"'test.c'\"")
|
|
|
|
def test_set_input_file(self):
|
|
self.assertEqual(check_cfc.set_input_file(
|
|
['clang', 'test.c'], 'test.s'), ['clang', 'test.s'])
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|