|
|
from Cython.Build.Cythonize import ( |
|
|
create_args_parser, parse_args_raw, parse_args, |
|
|
parallel_compiles |
|
|
) |
|
|
|
|
|
from Cython.Compiler import Options |
|
|
from Cython.Compiler.Tests.Utils import backup_Options, restore_Options, check_global_options |
|
|
|
|
|
from unittest import TestCase |
|
|
|
|
|
import sys |
|
|
from io import StringIO |
|
|
|
|
|
|
|
|
class TestCythonizeArgsParser(TestCase): |
|
|
|
|
|
def setUp(self): |
|
|
TestCase.setUp(self) |
|
|
self.parse_args = lambda x, parser=create_args_parser() : parse_args_raw(parser, x) |
|
|
|
|
|
|
|
|
def are_default(self, options, skip): |
|
|
|
|
|
empty_containers = ['directives', 'compile_time_env', 'options', 'excludes'] |
|
|
are_none = ['language_level', 'annotate', 'build', 'build_inplace', 'force', 'quiet', 'lenient', 'keep_going', 'no_docstrings'] |
|
|
for opt_name in empty_containers: |
|
|
if len(getattr(options, opt_name))!=0 and (opt_name not in skip): |
|
|
self.assertEqual(opt_name,"", msg="For option "+opt_name) |
|
|
return False |
|
|
for opt_name in are_none: |
|
|
if (getattr(options, opt_name) is not None) and (opt_name not in skip): |
|
|
self.assertEqual(opt_name,"", msg="For option "+opt_name) |
|
|
return False |
|
|
if options.parallel!=parallel_compiles and ('parallel' not in skip): |
|
|
return False |
|
|
return True |
|
|
|
|
|
|
|
|
def test_directive_short(self): |
|
|
options, args = self.parse_args(['-X', 'cdivision=True']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['directives'])) |
|
|
self.assertEqual(options.directives['cdivision'], True) |
|
|
|
|
|
def test_directive_long(self): |
|
|
options, args = self.parse_args(['--directive', 'cdivision=True']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['directives'])) |
|
|
self.assertEqual(options.directives['cdivision'], True) |
|
|
|
|
|
def test_directive_multiple(self): |
|
|
options, args = self.parse_args(['-X', 'cdivision=True', '-X', 'c_string_type=bytes']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['directives'])) |
|
|
self.assertEqual(options.directives['cdivision'], True) |
|
|
self.assertEqual(options.directives['c_string_type'], 'bytes') |
|
|
|
|
|
def test_directive_multiple_v2(self): |
|
|
options, args = self.parse_args(['-X', 'cdivision=True,c_string_type=bytes']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['directives'])) |
|
|
self.assertEqual(options.directives['cdivision'], True) |
|
|
self.assertEqual(options.directives['c_string_type'], 'bytes') |
|
|
|
|
|
def test_directive_value_yes(self): |
|
|
options, args = self.parse_args(['-X', 'cdivision=YeS']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['directives'])) |
|
|
self.assertEqual(options.directives['cdivision'], True) |
|
|
|
|
|
def test_directive_value_no(self): |
|
|
options, args = self.parse_args(['-X', 'cdivision=no']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['directives'])) |
|
|
self.assertEqual(options.directives['cdivision'], False) |
|
|
|
|
|
def test_directive_value_invalid(self): |
|
|
with self.assertRaises(ValueError) as context: |
|
|
options, args = self.parse_args(['-X', 'cdivision=sadfasd']) |
|
|
|
|
|
def test_directive_key_invalid(self): |
|
|
with self.assertRaises(ValueError) as context: |
|
|
options, args = self.parse_args(['-X', 'abracadabra']) |
|
|
|
|
|
def test_directive_no_value(self): |
|
|
with self.assertRaises(ValueError) as context: |
|
|
options, args = self.parse_args(['-X', 'cdivision']) |
|
|
|
|
|
def test_directives_types(self): |
|
|
directives = [ |
|
|
('auto_pickle', True), |
|
|
('c_string_type', 'bytearray'), |
|
|
('c_string_type', 'bytes'), |
|
|
('c_string_type', 'str'), |
|
|
('c_string_type', 'bytearray'), |
|
|
('c_string_type', 'unicode'), |
|
|
('c_string_encoding', 'ascii'), |
|
|
('language_level', '2'), |
|
|
('language_level', '3'), |
|
|
|
|
|
('set_initial_path', 'my_initial_path'), |
|
|
] |
|
|
for key, value in directives: |
|
|
cmd = '{key}={value}'.format(key=key, value=str(value)) |
|
|
options, args = self.parse_args(['-X', cmd]) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['directives']), msg = "Error for option: "+cmd) |
|
|
if value == 'unicode': |
|
|
value = 'str' |
|
|
self.assertEqual(options.directives[key], value, msg = "Error for option: "+cmd) |
|
|
|
|
|
def test_directives_wrong(self): |
|
|
directives = [ |
|
|
('auto_pickle', 42), |
|
|
('auto_pickle', 'NONONO'), |
|
|
('c_string_type', 'bites'), |
|
|
|
|
|
|
|
|
] |
|
|
for key, value in directives: |
|
|
cmd = '{key}={value}'.format(key=key, value=str(value)) |
|
|
with self.assertRaises(ValueError, msg = "Error for option: "+cmd) as context: |
|
|
options, args = self.parse_args(['-X', cmd]) |
|
|
|
|
|
def test_compile_time_env_short(self): |
|
|
options, args = self.parse_args(['-E', 'MYSIZE=10']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['compile_time_env'])) |
|
|
self.assertEqual(options.compile_time_env['MYSIZE'], 10) |
|
|
|
|
|
def test_compile_time_env_long(self): |
|
|
options, args = self.parse_args(['--compile-time-env', 'MYSIZE=10']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['compile_time_env'])) |
|
|
self.assertEqual(options.compile_time_env['MYSIZE'], 10) |
|
|
|
|
|
def test_compile_time_env_multiple(self): |
|
|
options, args = self.parse_args(['-E', 'MYSIZE=10', '-E', 'ARRSIZE=11']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['compile_time_env'])) |
|
|
self.assertEqual(options.compile_time_env['MYSIZE'], 10) |
|
|
self.assertEqual(options.compile_time_env['ARRSIZE'], 11) |
|
|
|
|
|
def test_compile_time_env_multiple_v2(self): |
|
|
options, args = self.parse_args(['-E', 'MYSIZE=10,ARRSIZE=11']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['compile_time_env'])) |
|
|
self.assertEqual(options.compile_time_env['MYSIZE'], 10) |
|
|
self.assertEqual(options.compile_time_env['ARRSIZE'], 11) |
|
|
|
|
|
|
|
|
def test_option_short(self): |
|
|
options, args = self.parse_args(['-s', 'docstrings=True']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['options'])) |
|
|
self.assertEqual(options.options['docstrings'], True) |
|
|
|
|
|
def test_option_long(self): |
|
|
options, args = self.parse_args(['--option', 'docstrings=True']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['options'])) |
|
|
self.assertEqual(options.options['docstrings'], True) |
|
|
|
|
|
def test_option_multiple(self): |
|
|
options, args = self.parse_args(['-s', 'docstrings=True', '-s', 'buffer_max_dims=8']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['options'])) |
|
|
self.assertEqual(options.options['docstrings'], True) |
|
|
self.assertEqual(options.options['buffer_max_dims'], True) |
|
|
|
|
|
def test_option_multiple_v2(self): |
|
|
options, args = self.parse_args(['-s', 'docstrings=True,buffer_max_dims=8']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['options'])) |
|
|
self.assertEqual(options.options['docstrings'], True) |
|
|
self.assertEqual(options.options['buffer_max_dims'], True) |
|
|
|
|
|
def test_option_value_yes(self): |
|
|
options, args = self.parse_args(['-s', 'docstrings=YeS']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['options'])) |
|
|
self.assertEqual(options.options['docstrings'], True) |
|
|
|
|
|
def test_option_value_4242(self): |
|
|
options, args = self.parse_args(['-s', 'docstrings=4242']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['options'])) |
|
|
self.assertEqual(options.options['docstrings'], True) |
|
|
|
|
|
def test_option_value_0(self): |
|
|
options, args = self.parse_args(['-s', 'docstrings=0']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['options'])) |
|
|
self.assertEqual(options.options['docstrings'], False) |
|
|
|
|
|
def test_option_value_emptystr(self): |
|
|
options, args = self.parse_args(['-s', 'docstrings=']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['options'])) |
|
|
self.assertEqual(options.options['docstrings'], True) |
|
|
|
|
|
def test_option_value_a_str(self): |
|
|
options, args = self.parse_args(['-s', 'docstrings=BB']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['options'])) |
|
|
self.assertEqual(options.options['docstrings'], True) |
|
|
|
|
|
def test_option_value_no(self): |
|
|
options, args = self.parse_args(['-s', 'docstrings=nO']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['options'])) |
|
|
self.assertEqual(options.options['docstrings'], False) |
|
|
|
|
|
def test_option_no_value(self): |
|
|
options, args = self.parse_args(['-s', 'docstrings']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['options'])) |
|
|
self.assertEqual(options.options['docstrings'], True) |
|
|
|
|
|
def test_option_any_key(self): |
|
|
options, args = self.parse_args(['-s', 'abracadabra']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['options'])) |
|
|
self.assertEqual(options.options['abracadabra'], True) |
|
|
|
|
|
def test_language_level_2(self): |
|
|
options, args = self.parse_args(['-2']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['language_level'])) |
|
|
self.assertEqual(options.language_level, 2) |
|
|
|
|
|
def test_language_level_3(self): |
|
|
options, args = self.parse_args(['-3']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['language_level'])) |
|
|
self.assertEqual(options.language_level, 3) |
|
|
|
|
|
def test_language_level_3str(self): |
|
|
options, args = self.parse_args(['--3str']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['language_level'])) |
|
|
self.assertEqual(options.language_level, 3) |
|
|
|
|
|
def test_annotate_short(self): |
|
|
options, args = self.parse_args(['-a']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['annotate'])) |
|
|
self.assertEqual(options.annotate, 'default') |
|
|
|
|
|
def test_annotate_long(self): |
|
|
options, args = self.parse_args(['--annotate']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['annotate'])) |
|
|
self.assertEqual(options.annotate, 'default') |
|
|
|
|
|
def test_annotate_fullc(self): |
|
|
options, args = self.parse_args(['--annotate-fullc']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['annotate'])) |
|
|
self.assertEqual(options.annotate, 'fullc') |
|
|
|
|
|
def test_annotate_and_positional(self): |
|
|
options, args = self.parse_args(['-a', 'foo.pyx']) |
|
|
self.assertEqual(args, ['foo.pyx']) |
|
|
self.assertTrue(self.are_default(options, ['annotate'])) |
|
|
self.assertEqual(options.annotate, 'default') |
|
|
|
|
|
def test_annotate_and_optional(self): |
|
|
options, args = self.parse_args(['-a', '--3str']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['annotate', 'language_level'])) |
|
|
self.assertEqual(options.annotate, 'default') |
|
|
self.assertEqual(options.language_level, 3) |
|
|
|
|
|
def test_exclude_short(self): |
|
|
options, args = self.parse_args(['-x', '*.pyx']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['excludes'])) |
|
|
self.assertTrue('*.pyx' in options.excludes) |
|
|
|
|
|
def test_exclude_long(self): |
|
|
options, args = self.parse_args(['--exclude', '*.pyx']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['excludes'])) |
|
|
self.assertTrue('*.pyx' in options.excludes) |
|
|
|
|
|
def test_exclude_multiple(self): |
|
|
options, args = self.parse_args(['--exclude', '*.pyx', '--exclude', '*.py', ]) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['excludes'])) |
|
|
self.assertEqual(options.excludes, ['*.pyx', '*.py']) |
|
|
|
|
|
def test_build_short(self): |
|
|
options, args = self.parse_args(['-b']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['build'])) |
|
|
self.assertEqual(options.build, True) |
|
|
|
|
|
def test_build_long(self): |
|
|
options, args = self.parse_args(['--build']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['build'])) |
|
|
self.assertEqual(options.build, True) |
|
|
|
|
|
def test_inplace_short(self): |
|
|
options, args = self.parse_args(['-i']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['build_inplace'])) |
|
|
self.assertEqual(options.build_inplace, True) |
|
|
|
|
|
def test_inplace_long(self): |
|
|
options, args = self.parse_args(['--inplace']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['build_inplace'])) |
|
|
self.assertEqual(options.build_inplace, True) |
|
|
|
|
|
def test_parallel_short(self): |
|
|
options, args = self.parse_args(['-j', '42']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['parallel'])) |
|
|
self.assertEqual(options.parallel, 42) |
|
|
|
|
|
def test_parallel_long(self): |
|
|
options, args = self.parse_args(['--parallel', '42']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['parallel'])) |
|
|
self.assertEqual(options.parallel, 42) |
|
|
|
|
|
def test_force_short(self): |
|
|
options, args = self.parse_args(['-f']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['force'])) |
|
|
self.assertEqual(options.force, True) |
|
|
|
|
|
def test_force_long(self): |
|
|
options, args = self.parse_args(['--force']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['force'])) |
|
|
self.assertEqual(options.force, True) |
|
|
|
|
|
def test_quite_short(self): |
|
|
options, args = self.parse_args(['-q']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['quiet'])) |
|
|
self.assertEqual(options.quiet, True) |
|
|
|
|
|
def test_quite_long(self): |
|
|
options, args = self.parse_args(['--quiet']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['quiet'])) |
|
|
self.assertEqual(options.quiet, True) |
|
|
|
|
|
def test_lenient_long(self): |
|
|
options, args = self.parse_args(['--lenient']) |
|
|
self.assertTrue(self.are_default(options, ['lenient'])) |
|
|
self.assertFalse(args) |
|
|
self.assertEqual(options.lenient, True) |
|
|
|
|
|
def test_keep_going_short(self): |
|
|
options, args = self.parse_args(['-k']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['keep_going'])) |
|
|
self.assertEqual(options.keep_going, True) |
|
|
|
|
|
def test_keep_going_long(self): |
|
|
options, args = self.parse_args(['--keep-going']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['keep_going'])) |
|
|
self.assertEqual(options.keep_going, True) |
|
|
|
|
|
def test_no_docstrings_long(self): |
|
|
options, args = self.parse_args(['--no-docstrings']) |
|
|
self.assertFalse(args) |
|
|
self.assertTrue(self.are_default(options, ['no_docstrings'])) |
|
|
self.assertEqual(options.no_docstrings, True) |
|
|
|
|
|
def test_file_name(self): |
|
|
options, args = self.parse_args(['file1.pyx', 'file2.pyx']) |
|
|
self.assertEqual(len(args), 2) |
|
|
self.assertEqual(args[0], 'file1.pyx') |
|
|
self.assertEqual(args[1], 'file2.pyx') |
|
|
self.assertTrue(self.are_default(options, [])) |
|
|
|
|
|
def test_option_first(self): |
|
|
options, args = self.parse_args(['-i', 'file.pyx']) |
|
|
self.assertEqual(args, ['file.pyx']) |
|
|
self.assertEqual(options.build_inplace, True) |
|
|
self.assertTrue(self.are_default(options, ['build_inplace'])) |
|
|
|
|
|
def test_file_inbetween(self): |
|
|
options, args = self.parse_args(['-i', 'file.pyx', '-a']) |
|
|
self.assertEqual(args, ['file.pyx']) |
|
|
self.assertEqual(options.build_inplace, True) |
|
|
self.assertEqual(options.annotate, 'default') |
|
|
self.assertTrue(self.are_default(options, ['build_inplace', 'annotate'])) |
|
|
|
|
|
def test_option_trailing(self): |
|
|
options, args = self.parse_args(['file.pyx', '-i']) |
|
|
self.assertEqual(args, ['file.pyx']) |
|
|
self.assertEqual(options.build_inplace, True) |
|
|
self.assertTrue(self.are_default(options, ['build_inplace'])) |
|
|
|
|
|
def test_interspersed_positional(self): |
|
|
options, sources = self.parse_args([ |
|
|
'file1.pyx', '-a', |
|
|
'file2.pyx' |
|
|
]) |
|
|
self.assertEqual(sources, ['file1.pyx', 'file2.pyx']) |
|
|
self.assertEqual(options.annotate, 'default') |
|
|
self.assertTrue(self.are_default(options, ['annotate'])) |
|
|
|
|
|
def test_interspersed_positional2(self): |
|
|
options, sources = self.parse_args([ |
|
|
'file1.pyx', '-a', |
|
|
'file2.pyx', '-a', 'file3.pyx' |
|
|
]) |
|
|
self.assertEqual(sources, ['file1.pyx', 'file2.pyx', 'file3.pyx']) |
|
|
self.assertEqual(options.annotate, 'default') |
|
|
self.assertTrue(self.are_default(options, ['annotate'])) |
|
|
|
|
|
def test_interspersed_positional3(self): |
|
|
options, sources = self.parse_args([ |
|
|
'-f', 'f1', 'f2', '-a', |
|
|
'f3', 'f4', '-a', 'f5' |
|
|
]) |
|
|
self.assertEqual(sources, ['f1', 'f2', 'f3', 'f4', 'f5']) |
|
|
self.assertEqual(options.annotate, 'default') |
|
|
self.assertEqual(options.force, True) |
|
|
self.assertTrue(self.are_default(options, ['annotate', 'force'])) |
|
|
|
|
|
def test_wrong_option(self): |
|
|
old_stderr = sys.stderr |
|
|
stderr = sys.stderr = StringIO() |
|
|
try: |
|
|
self.assertRaises(SystemExit, self.parse_args, |
|
|
['--unknown-option'] |
|
|
) |
|
|
finally: |
|
|
sys.stderr = old_stderr |
|
|
self.assertTrue(stderr.getvalue()) |
|
|
|
|
|
|
|
|
class TestParseArgs(TestCase): |
|
|
def setUp(self): |
|
|
self._options_backup = backup_Options() |
|
|
|
|
|
def tearDown(self): |
|
|
restore_Options(self._options_backup) |
|
|
|
|
|
def check_default_global_options(self, white_list=[]): |
|
|
self.assertEqual(check_global_options(self._options_backup, white_list), "") |
|
|
|
|
|
def test_build_set_for_inplace(self): |
|
|
options, args = parse_args(['foo.pyx', '-i']) |
|
|
self.assertEqual(options.build, True) |
|
|
self.check_default_global_options() |
|
|
|
|
|
def test_lenient(self): |
|
|
options, sources = parse_args(['foo.pyx', '--lenient']) |
|
|
self.assertEqual(sources, ['foo.pyx']) |
|
|
self.assertEqual(Options.error_on_unknown_names, False) |
|
|
self.assertEqual(Options.error_on_uninitialized, False) |
|
|
self.check_default_global_options(['error_on_unknown_names', 'error_on_uninitialized']) |
|
|
|
|
|
def test_annotate(self): |
|
|
options, sources = parse_args(['foo.pyx', '--annotate']) |
|
|
self.assertEqual(sources, ['foo.pyx']) |
|
|
self.assertEqual(Options.annotate, 'default') |
|
|
self.check_default_global_options(['annotate']) |
|
|
|
|
|
def test_annotate_fullc(self): |
|
|
options, sources = parse_args(['foo.pyx', '--annotate-fullc']) |
|
|
self.assertEqual(sources, ['foo.pyx']) |
|
|
self.assertEqual(Options.annotate, 'fullc') |
|
|
self.check_default_global_options(['annotate']) |
|
|
|
|
|
def test_no_docstrings(self): |
|
|
options, sources = parse_args(['foo.pyx', '--no-docstrings']) |
|
|
self.assertEqual(sources, ['foo.pyx']) |
|
|
self.assertEqual(Options.docstrings, False) |
|
|
self.check_default_global_options(['docstrings']) |
|
|
|
