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])