def test_no_scalar(self):
self.assertEqual(iterutils.listify(['foo'], scalar_ok=False), ['foo'])
self.assertEqual(
iterutils.listify(['foo'], always_copy=True, scalar_ok=False),
['foo'])
self.assertRaises(TypeError, iterutils.listify, 1, scalar_ok=False)
self.assertRaises(TypeError, iterutils.listify, 'foo', scalar_ok=False)
def test_type(self):
x = 'foo'
res = iterutils.listify(x, type=tuple)
self.assertEqual(res, ('foo', ))
y = ['foo', 'bar']
res = iterutils.listify(y, type=tuple)
self.assertEqual(res, ('foo', 'bar'))
def assertPopen(self,
command,
input=None,
*,
env=None,
extra_env=None,
returncode=0):
final_env = env if env is not None else os.environ
if extra_env:
final_env = final_env.copy()
final_env.update(extra_env)
command = [self.target_path(i) for i in command]
proc = subprocess.run(command,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
input=input,
env=final_env,
universal_newlines=True)
if not (returncode == 'any' or
(returncode == 'fail' and proc.returncode != 0)
or proc.returncode in listify(returncode)):
raise SubprocessError(proc.returncode, extra_env or env,
proc.stdout)
return proc.stdout
def output_file(self, name, context={}, lang='c++', mode=None, extra={}):
compiler = getattr(self.env.builder(lang), mode or self.mode)
context = AttrDict(**context)
output = compiler.output_file(name, context)
public_output = compiler.post_build(self.build, [], output, context)
result = [i for i in listify(public_output or output) if not i.private]
for i in result:
for k, v in iteritems(extra):
setattr(i, k, v)
return unlistify(result)
def output_file(self, name, step={}, lang='c++', mode=None, extra={}):
compiler = getattr(self.env.builder(lang), mode or self.mode)
step = AttrDict(**step)
output = compiler.output_file(name, step)
public_output = compiler.post_output(self.build, [], output, step)
result = [i for i in listify(public_output or output) if not i.private]
for i in result:
for k, v in extra.items():
setattr(i, k, v)
return unlistify(result)
def assertEdge(self, edge, raw_output, output=default_sentinel,
public_output=default_sentinel, extra_deps=[],
description=None):
if output is default_sentinel:
output = listify(raw_output)
if public_output is default_sentinel:
public_output = raw_output
self.assertEqual(edge.raw_output, raw_output)
self.assertEqual(edge.output, output)
self.assertEqual(edge.public_output, public_output)
self.assertEqual(edge.extra_deps, extra_deps)
self.assertEqual(edge.description, description)
def output_file(self, name, context={}, lang='c++', mode=None, extra={}):
linker = self.env.builder(lang).linker(mode or self.mode)
context_args = {'langs': [lang]}
context_args.update(context)
context = AttrDict(**context_args)
output = linker.output_file(name, context)
public_output = linker.post_build(self.build, [], output, context)
result = [i for i in listify(public_output or output) if not i.private]
for i in result:
for k, v in iteritems(extra):
setattr(i, k, v)
return unlistify(result)
def output_file(self, name, step={}, lang='c++', mode=None, extra={}):
linker = self.env.builder(lang).linker(mode or self.mode)
step_args = {'langs': [lang]}
step_args.update(step)
step = AttrDict(**step_args)
output = linker.output_file(name, step)
public_output = linker.post_build(self.context, [], output, step)
result = [i for i in listify(public_output or output) if not i.private]
for i in result:
for k, v in extra.items():
setattr(i, k, v)
return unlistify(result)
def output_file(self, name, step={}, lang=None, input_langs=['c++'],
mode=None, extra={}):
linker = self.linker(lang or input_langs[0], mode)
step_args = {'langs': [lang] if lang else input_langs,
'input_langs': input_langs}
step_args.update(step)
step = AttrDict(**step_args)
output = linker.output_file(name, step)
public_output = linker.post_output(self.context, [], output, step)
result = [i for i in listify(public_output or output) if not i.private]
for i in result:
for k, v in extra.items():
setattr(i, k, v)
return unlistify(result)
def assertPopen(self, command, env=None, env_update=True, input=None,
returncode=0):
final_env = env
if env is not None and env_update:
final_env = dict(os.environ)
final_env.update(env)
command = [self.target_path(i) for i in command]
proc = subprocess.Popen(
command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT, env=final_env, universal_newlines=True
)
output = proc.communicate(input)[0]
if not (returncode == 'any' or
(returncode == 'fail' and proc.returncode != 0) or
proc.returncode in listify(returncode)):
raise SubprocessError(proc.returncode, env, output)
return output
def test_always_copy(self):
x = ['foo', 'bar']
res = iterutils.listify(x, always_copy=True)
self.assertEqual(res, x)
self.assertTrue(x is not res)
def test_many(self):
x = ['foo', 'bar']
res = iterutils.listify(x)
self.assertEqual(res, x)
self.assertTrue(x is res)
def test_one(self):
self.assertEqual(iterutils.listify('foo'), ['foo'])
def test_none(self):
self.assertEqual(iterutils.listify(None), [])
def output_file(self, compiler, name, context):
output = compiler.output_file(name, context)
public_output = compiler.post_build(self.build, [], output, context)
return unlistify([i for i in listify(public_output or output)
if not i.private])
