o.force_True(pkg)
self.assertEqual(l, [(True, pkg, ('asdf.far', 'repo'), [2,1],)])
l[:] = []
o.force_False(pkg)
self.assertEqual(l, [(False, pkg, ('asdf.far', 'repo'), [2,1],)])
class ConditionalTest(TestCase):
def test_eq(self):
p = (packages.PackageRestriction('one', values.AlwaysTrue),)
p2 = (packages.PackageRestriction('one', values.AlwaysFalse),)
v = values.AlwaysTrue
v2 = values.AlwaysFalse
self.assertEqual(
packages.Conditional('use', v, p),
packages.Conditional('use', v, p))
self.assertNotEqual(
packages.Conditional('use', v2, p),
packages.Conditional('use', v, p))
self.assertNotEqual(
packages.Conditional('use', v, p),
packages.Conditional('use', v, p2))
self.assertNotEqual(
packages.Conditional('use1', v, p),
packages.Conditional('use', v, p))
test_cpy_used = mk_cpy_loadable_testcase('pkgcore.restrictions._restrictions',
"pkgcore.restrictions.packages", "PackageRestriction_base", "PackageRestriction")
def test_simple(self):
false_l, true_l = self.kls(lambda x: x % 2 == 0, range(100))
assert false_l == list(range(1, 100, 2))
assert true_l == list(range(0, 100, 2))
def test_key(self):
false_l, true_l = self.kls(lambda x: x % 2 == 0,
([0, x] for x in range(100)),
key=itemgetter(1))
assert false_l == [[0, x] for x in range(1, 100, 2)]
assert true_l == [[0, x] for x in range(0, 100, 2)]
cpy_loaded_Test = mk_cpy_loadable_testcase("snakeoil._sequences",
"snakeoil.sequences",
"iflatten_func", "iflatten_func")
class TestNamedTuple:
def setup_method(self, method):
self.point = namedtuple('Point', ('x', 'y', 'z'))
def test_namedtuple(self):
p = self.point(1, 2, 3)
assert p.x == 1
assert p[0] == 1
assert p.y == 2
assert p[1] == 2
assert p.z == 3
assert p[2] == 3
class GetFormatterTest(TestCase):
@issue7567
def test_dumb_terminal(self):
master, _out = _get_pty_pair()
formatter = _with_term('dumb', formatters.get_formatter, master)
self.failUnless(isinstance(formatter, formatters.PlainTextFormatter))
@issue7567
def test_smart_terminal(self):
master, _out = _get_pty_pair()
formatter = _with_term('xterm', formatters.get_formatter, master)
self.failUnless(isinstance(formatter, formatters.TerminfoFormatter))
@issue7567
def test_not_a_tty(self):
stream = TemporaryFile()
formatter = _with_term('xterm', formatters.get_formatter, stream)
self.failUnless(isinstance(formatter, formatters.PlainTextFormatter))
@issue7567
def test_no_fd(self):
stream = StringIO()
formatter = _with_term('xterm', formatters.get_formatter, stream)
self.failUnless(isinstance(formatter, formatters.PlainTextFormatter))
cpy_loaded_Test = mk_cpy_loadable_testcase(
"snakeoil._formatters", "snakeoil.formatters", "StreamClosed",
"StreamClosed")
formatter = _with_term('dumb', formatters.get_formatter, master)
assert isinstance(formatter, formatters.PlainTextFormatter)
@issue7567
def test_vt100_terminal(self):
formatter = _with_term('vt100', formatters.get_formatter, master)
assert isinstance(formatter, formatters.PlainTextFormatter)
@issue7567
def test_smart_terminal(self):
master, _out = _get_pty_pair()
formatter = _with_term('xterm', formatters.get_formatter, master)
assert isinstance(formatter, formatters.TerminfoFormatter)
@issue7567
def test_not_a_tty(self):
stream = TemporaryFile()
formatter = _with_term('xterm', formatters.get_formatter, stream)
assert isinstance(formatter, formatters.PlainTextFormatter)
@issue7567
def test_no_fd(self):
stream = BytesIO()
formatter = _with_term('xterm', formatters.get_formatter, stream)
assert isinstance(formatter, formatters.PlainTextFormatter)
cpy_loaded_Test = mk_cpy_loadable_testcase("snakeoil._formatters",
"snakeoil.formatters",
"StreamClosed", "StreamClosed")
repr(thing)
str(thing)
# The c version returns a constant, the py version raises
try:
hash(thing)
except AttributeError:
pass
def test_r0_removal(self):
obj = self.kls("dev-util/diffball-1.0-r0", versioned=True)
self.assertEqual(obj.fullver, "1.0")
self.assertEqual(obj.revision, None)
self.assertEqual(str(obj), "dev-util/diffball-1.0")
class CPY_CpvTest(native_CpvTest):
if cpv.cpy_builtin:
kls = staticmethod(cpv.cpy_CPV)
else:
skip = "cpython cpv extension not available"
run_cpy_ver_cmp = True
class CPY_Cpv_OptionalArgsTest(CPY_CpvTest):
testing_secondary_args = True
test_cpy_used = mk_cpy_loadable_testcase("pkgcore.ebuild._cpv", "pkgcore.ebuild.cpv", "CPV_base", "CPV")
self.assertNotMatch(self.kls('>=sys-apps/portage-2.1.0_pre3-r5'),
FakePkg('sys-apps/portage-2.1_pre3-r5'))
def test_combined(self):
p = FakePkg('dev-util/diffball-0.7', repo=FakeRepo(repo_id='gentoo'))
self.assertMatch(self.kls('=dev-util/diffball-0.7::gentoo'), p)
self.assertMatch(self.kls('dev-util/diffball::gentoo'), p)
self.assertNotMatch(self.kls('=dev-util/diffball-0.7:1::gentoo'),
FakePkg('dev-util/diffball-0.7', slot='2'))
def test_unversioned(self):
self.assertTrue(self.kls("dev-util/diffball").is_simple)
self.assertFalse(self.kls("dev-util/diffball:2").is_simple)
self.assertFalse(self.kls("dev-util/diffball:2::gentoo").is_simple)
self.assertFalse(self.kls("dev-util/diffball::gentoo").is_simple)
self.assertFalse(self.kls("!=dev-util/diffball-1").is_simple)
self.assertFalse(self.kls(">dev-util/diffball-1.2").is_simple)
self.assertFalse(self.kls("=dev-util/diffball-1").is_simple)
self.assertFalse(self.kls("dev-util/diffball[x]").is_simple)
self.assertFalse(self.kls("dev-util/diffball[x?]").is_simple)
class Test_cpy_atom(Test_native_atom):
kls = staticmethod(atom.atom)
if atom.atom_overrides is atom.native_atom_overrides:
skip = "extension isn't available"
test_cpy_used = mk_cpy_loadable_testcase('pkgcore.ebuild._atom',
"pkgcore.ebuild.atom", "atom_overrides", "overrides")
def test_arg_awareness(self):
data = "f() {\n x \{}\n}\n"
self.assertNotIn('}', ''.join(self.get_output(data, 'f')))
def test_print_vars(self):
def assertVars(data, var_list, assert_func=self.assertEqual):
l = []
self.get_output(data, global_envvar_callback=l.append)
assert_func(sorted(var_list), sorted(l))
assertVars("f(){\nX=dar\n}", [])
assertVars("f(){\nX=dar\n}\nY=a", ['Y'])
assertVars("f(){\nX=dar\n}\nmy command\nY=a\nf=$(dar)", ['Y', 'f'])
assertVars("f(){\nX=dar\n}\nmy command\nY=a\nf=$(dar) foon\n", ['Y'],
self.assertNotEqual)
assertVars("f(){\nX=dar foon\n}\nY=dar\nf2(){Z=dar;}\n", ['Y'])
class CPyFilterEnvTest(NativeFilterEnvTest):
if filter_env.cpy_run is None:
skip = 'cpy filter_env not available.'
else:
filter_env = staticmethod(
partial(filter_env.main_run, _parser=filter_env.cpy_run))
cpy_loaded_Test = mk_cpy_loadable_testcase("pkgcore.ebuild._filter_env",
"pkgcore.ebuild.filter_env", "run",
"run")
if len(vals) > 2:
use = vals[2].split()
if len(vals) > 3:
tristate = vals[3].split()
kwds = {}
if '/' in src:
kls = atom
flags = src.split("[", 1)[-1]
if "?" in flags or "=" in flags:
kwds['transitive_use_atoms'] = True
else:
kls = str
orig = self.gen_depset(src, element_kls=kls, **kwds)
collapsed = orig.evaluate_depset(use,
tristate_filter=tristate)
self.assertEqual(str(collapsed), result, msg=
"expected %r got %r\nraw depset: %r\nuse: %r, tristate: %r" %
(result, str(collapsed), src, use, tristate))
if not ('?' in src or kwds.get("transitive_use_atoms")):
self.assertIdentical(orig, collapsed)
class cpy_DepSetEvaluateTest(native_DepSetEvaluateTest):
kls = staticmethod(conditionals.DepSet)
if not conditionals.DepSet.parse_depset:
skip = "extension not available"
test_cpy_used = mk_cpy_loadable_testcase('pkgcore.ebuild._depset',
"pkgcore.ebuild.conditionals", "parse_depset", "parse_depset")
unique = object()
o = weak_inst(unique)
# make sure it's only strong reffed
self.assertEqual(weak_inst.counter, 1)
self.assertLen(gc.get_referrers(o), 1)
myid = id(o)
del o
o = weak_inst(unique)
self.assertEqual(weak_inst.counter, 2)
self.assertLen(gc.get_referrers(o), 1)
# Hack to make it show up with a different name in trial's output
TestWeakInstMeta.__name__ = WeakInstMeta.__name__ + 'Test'
return TestWeakInstMeta
# "Invalid name"
# pylint: disable-msg=C0103
TestNativeWeakInstMeta = gen_test(caching.native_WeakInstMeta)
if caching.cpy_WeakInstMeta is not None:
CPY_TestWeakInstMeta = gen_test(caching.cpy_WeakInstMeta)
else:
# generate fake test and mark it as skip
CPY_TestWeakInstMeta = gen_test(type)
CPY_TestWeakInstMeta.skip = "cpython extension isn't available"
cpy_loaded_Test = mk_cpy_loadable_testcase("snakeoil._caching",
"snakeoil.caching", "WeakInstMeta", "WeakInstMeta")
class CPY_Test_iflatten_instance(Test_iflatten_instance):
func = staticmethod(lists.iflatten_instance)
if not lists.cpy_builtin:
skip = "cpython extension isn't available"
class CPY_Test_iflatten_func(Test_iflatten_func):
func = staticmethod(lists.iflatten_func)
if not lists.cpy_builtin:
skip = "cpython extension isn't available"
class predicate_split_Test(TestCase):
kls = staticmethod(lists.predicate_split)
def test_simple(self):
false_l, true_l = self.kls(lambda x: x % 2 == 0, xrange(100))
self.assertEqual(false_l, range(1, 100, 2))
self.assertEqual(true_l, range(0, 100, 2))
def test_key(self):
false_l, true_l = self.kls(lambda x: x %2 == 0,
([0, x] for x in xrange(100)),
key=itemgetter(1))
self.assertEqual(false_l, [[0, x] for x in xrange(1, 100, 2)])
self.assertEqual(true_l, [[0, x] for x in range(0, 100, 2)])
cpy_loaded_Test = mk_cpy_loadable_testcase(
"snakeoil._lists", "snakeoil.lists", "iflatten_func", "iflatten_func")
s = set("ab")
self.f(s, ("-a", "b", "-b", "c", "c"),
finalize=False)
self.assertEqual(sorted(s), ["-a", "-b", "c"])
def test_starred(self):
s = set('ab')
self.f(s, ('c', '-*', 'd'))
self.assertEqual(sorted(s), ['d'])
class test_CPY_incremental_expansion(test_native_incremental_expansion):
if misc.incremental_expansion == misc.native_incremental_expansion:
skip = "CPy extension not available"
f = staticmethod(misc.incremental_expansion)
test_cpy_used = mk_cpy_loadable_testcase('pkgcore.ebuild._misc',
"pkgcore.ebuild.misc", "incremental_expansion", "incremental_expansion")
class TestIncrementalsDict(TestCase):
kls = misc.IncrementalsDict
def assertContents(self, mapping1, mapping2):
self.assertEqual(sorted(mapping1.iteritems()), sorted(mapping2.iteritems()))
def test_behaviour(self):
d = self.kls(frozenset("i1 i2".split()), a1="1", i1="1")
expected = {"a1":"1", "i1":"1"}
self.assertContents(d, expected)
d["a1"] = "2"
expected["a1"] = "2"
self.assertContents(d, expected)
class CPY_Test_iflatten_instance(Test_iflatten_instance):
func = staticmethod(lists.iflatten_instance)
if not lists.cpy_builtin:
skip = "cpython extension isn't available"
class CPY_Test_iflatten_func(Test_iflatten_func):
func = staticmethod(lists.iflatten_func)
if not lists.cpy_builtin:
skip = "cpython extension isn't available"
class predicate_split_Test(TestCase):
kls = staticmethod(lists.predicate_split)
def test_simple(self):
false_l, true_l = self.kls(lambda x: x % 2 == 0, xrange(100))
self.assertEqual(false_l, range(1, 100, 2))
self.assertEqual(true_l, range(0, 100, 2))
def test_key(self):
false_l, true_l = self.kls(lambda x: x % 2 == 0,
([0, x] for x in xrange(100)),
key=itemgetter(1))
self.assertEqual(false_l, [[0, x] for x in xrange(1, 100, 2)])
self.assertEqual(true_l, [[0, x] for x in range(0, 100, 2)])
cpy_loaded_Test = mk_cpy_loadable_testcase("snakeoil._lists", "snakeoil.lists",
"iflatten_func", "iflatten_func")
class predicate_split_Test(TestCase):
kls = staticmethod(sequences.predicate_split)
def test_simple(self):
false_l, true_l = self.kls(lambda x: x % 2 == 0, xrange(100))
self.assertEqual(false_l, range(1, 100, 2))
self.assertEqual(true_l, range(0, 100, 2))
def test_key(self):
false_l, true_l = self.kls(lambda x: x % 2 == 0, ([0, x] for x in xrange(100)), key=itemgetter(1))
self.assertEqual(false_l, [[0, x] for x in xrange(1, 100, 2)])
self.assertEqual(true_l, [[0, x] for x in range(0, 100, 2)])
cpy_loaded_Test = mk_cpy_loadable_testcase(
"snakeoil._sequences", "snakeoil.sequences", "iflatten_func", "iflatten_func"
)
class TestNamedTuple(unittest.TestCase):
def test_namedtuple(self):
Point = namedtuple("Point", ("x", "y", "z"))
p = Point(1, 2, 3)
self.assertEqual(p.x, 1)
self.assertEqual(p[0], 1)
self.assertEqual(p.y, 2)
self.assertEqual(p[1], 2)
self.assertEqual(p.z, 3)
self.assertEqual(p[2], 3)
self.assertEqual(p, (1, 2, 3))
self.assertNotMatch(self.kls('>=sys-apps/portage-2.1.0_pre3-r5'),
FakePkg('sys-apps/portage-2.1_pre3-r5'))
def test_combined(self):
p = FakePkg('dev-util/diffball-0.7', repo=FakeRepo(repo_id='gentoo'))
self.assertMatch(self.kls('=dev-util/diffball-0.7::gentoo'), p)
self.assertMatch(self.kls('dev-util/diffball::gentoo'), p)
self.assertNotMatch(self.kls('=dev-util/diffball-0.7:1::gentoo'),
FakePkg('dev-util/diffball-0.7', slot='2'))
def test_unversioned(self):
self.assertTrue(self.kls("dev-util/diffball").is_simple)
self.assertFalse(self.kls("dev-util/diffball:2").is_simple)
self.assertFalse(self.kls("dev-util/diffball:2::gentoo").is_simple)
self.assertFalse(self.kls("dev-util/diffball::gentoo").is_simple)
self.assertFalse(self.kls("!=dev-util/diffball-1").is_simple)
self.assertFalse(self.kls(">dev-util/diffball-1.2").is_simple)
self.assertFalse(self.kls("=dev-util/diffball-1").is_simple)
self.assertFalse(self.kls("dev-util/diffball[x]").is_simple)
self.assertFalse(self.kls("dev-util/diffball[x?]").is_simple)
class Test_cpy_atom(Test_native_atom):
kls = staticmethod(atom.atom)
if atom.atom_overrides is atom.native_atom_overrides:
skip = "extension isn't available"
test_cpy_used = mk_cpy_loadable_testcase('pkgcore.ebuild._atom',
"pkgcore.ebuild.atom", "atom_overrides", "overrides")
weak_inst.reset()
unique = object()
o = weak_inst(unique)
# make sure it's only strong ref-ed
assert weak_inst.counter == 1
_myid = id(o)
del o
o = weak_inst(unique)
assert weak_inst.counter == 2
return TestWeakInstMeta
# "Invalid name"
# pylint: disable=C0103
TestNativeWeakInstMeta = gen_test(caching.native_WeakInstMeta)
if caching.cpy_WeakInstMeta is not None:
Test_CPY_WeakInstMeta = gen_test(caching.cpy_WeakInstMeta)
else:
# generate fake test and skip it
@pytest.mark.skip("cpython extension isn't available")
class Test_CPY_WeakInstMeta(gen_test(type)):
pass
Test_cpy_loaded = mk_cpy_loadable_testcase("snakeoil._caching",
"snakeoil.caching", "WeakInstMeta",
"WeakInstMeta")
self.assertEqual(sorted(s), ["-a", "-b", "c"])
def test_starred(self):
s = set('ab')
self.f(s, ('c', '-*', 'd'))
self.assertEqual(sorted(s), ['d'])
class test_CPY_incremental_expansion(test_native_incremental_expansion):
if misc.incremental_expansion == misc.native_incremental_expansion:
skip = "CPy extension not available"
f = staticmethod(misc.incremental_expansion)
test_cpy_used = mk_cpy_loadable_testcase('pkgcore.ebuild._misc',
"pkgcore.ebuild.misc",
"incremental_expansion",
"incremental_expansion")
class TestIncrementalsDict(TestCase):
kls = misc.IncrementalsDict
def assertContents(self, mapping1, mapping2):
self.assertEqual(sorted(mapping1.iteritems()),
sorted(mapping2.iteritems()))
def test_behaviour(self):
d = self.kls(frozenset("i1 i2".split()), a1="1", i1="1")
expected = {"a1": "1", "i1": "1"}
self.assertContents(d, expected)
d["a1"] = "2"
try:
with Namespace(user=True, mount=True):
mount(self.source, self.target, None, MS_BIND)
assert os.path.exists(bind_file)
with open(bind_file) as f:
# can't unmount the target due to the open file
with pytest.raises(OSError) as cm:
umount(self.target)
assert cm.value.errno == errno.EBUSY
# lazily unmount instead
umount(self.target, MNT_DETACH)
# confirm the file doesn't exist in the bind mount anymore
assert not os.path.exists(bind_file)
# but the file is still accessible to the process
assert f.read() == 'foo'
# trying to reopen causes IOError
with pytest.raises(IOError) as cm:
f = open(bind_file)
assert cm.value.errno == errno.ENOENT
except PermissionError:
pytest.skip('No permission to use user and mount namespace')
Test_cpy_readdir_loaded = mk_cpy_loadable_testcase(
"snakeoil.osutils._readdir", "snakeoil.osutils", "listdir", "listdir")
Test_cpy_posix_loaded = mk_cpy_loadable_testcase(
"snakeoil._posix", "snakeoil.osutils", "normpath", "normpath")
obj = cls2()
self.assertRaises(AttributeError, hash, obj)
obj._dar = 4
self.assertEqual(hash(obj), 4)
class test_cpy_reflective_hash(test_native_reflective_hash):
kls = staticmethod(klass.reflective_hash)
if klass.reflective_hash is klass.native_reflective_hash:
skip = "cpython extension isn't available"
cpy_loaded_Test = mk_cpy_loadable_testcase("snakeoil._klass", "snakeoil.klass",
"reflective_hash",
"reflective_hash")
class TestImmutableInstance(TestCase):
def test_metaclass(self):
def f(scope):
scope["__metaclass__"] = klass.immutable_instance
self.common_test(f)
def test_injection(self):
def f(scope):
klass.inject_immutable_instance(scope)
self.common_test(f)
str(thing)
# The c version returns a constant, the py version raises
try:
hash(thing)
except AttributeError:
pass
def test_r0_removal(self):
obj = self.kls("dev-util/diffball-1.0-r0", versioned=True)
assert obj.fullver == "1.0"
assert obj.revision == 0
assert str(obj) == "dev-util/diffball-1.0"
@pytest.mark.skipif(not cpv.cpy_builtin,
reason="cpython cpv extension not available")
class Test_CPY_Cpv(Test_native_Cpv):
if cpv.cpy_builtin:
kls = staticmethod(cpv.cpy_CPV)
run_cpy_ver_cmp = True
class Test_CPY_Cpv_OptionalArgs(Test_CPY_Cpv):
testing_secondary_args = True
test_cpy_used = mk_cpy_loadable_testcase("pkgcore.ebuild._cpv",
"pkgcore.ebuild.cpv", "CPV_base",
"CPV")
class cls2(object):
__hash__ = self.func('_dar')
obj = cls2()
self.assertRaises(AttributeError, hash, obj)
obj._dar = 4
self.assertEqual(hash(obj), 4)
class test_cpy_reflective_hash(test_native_reflective_hash):
kls = staticmethod(klass.reflective_hash)
if klass.reflective_hash is klass.native_reflective_hash:
skip = "cpython extension isn't available"
cpy_loaded_Test = mk_cpy_loadable_testcase("snakeoil._klass",
"snakeoil.klass", "reflective_hash", "reflective_hash")
class TestImmutableInstance(TestCase):
def test_metaclass(self):
def f(scope):
scope["__metaclass__"] = klass.immutable_instance
self.common_test(f)
def test_injection(self):
def f(scope):
klass.inject_immutable_instance(scope)
tristate = vals[3].split()
kwds = {}
if '/' in src:
kls = atom
flags = src.split("[", 1)[-1]
if "?" in flags or "=" in flags:
kwds['transitive_use_atoms'] = True
else:
kls = str
orig = self.gen_depset(src, element_kls=kls, **kwds)
collapsed = orig.evaluate_depset(use, tristate_filter=tristate)
self.assertEqual(
str(collapsed),
result,
msg="expected %r got %r\nraw depset: %r\nuse: %r, tristate: %r"
% (result, str(collapsed), src, use, tristate))
if not ('?' in src or kwds.get("transitive_use_atoms")):
self.assertIdentical(orig, collapsed)
class cpy_DepSetEvaluateTest(native_DepSetEvaluateTest):
kls = staticmethod(conditionals.DepSet)
if not conditionals.DepSet.parse_depset:
skip = "extension not available"
test_cpy_used = mk_cpy_loadable_testcase('pkgcore.ebuild._depset',
"pkgcore.ebuild.conditionals",
"parse_depset", "parse_depset")
with Namespace(user=True, mount=True):
mount(self.source, self.target, None, MS_BIND)
assert os.path.exists(bind_file)
with open(bind_file) as f:
# can't unmount the target due to the open file
with pytest.raises(OSError) as cm:
umount(self.target)
assert cm.value.errno == errno.EBUSY
# lazily unmount instead
umount(self.target, MNT_DETACH)
# confirm the file doesn't exist in the bind mount anymore
assert not os.path.exists(bind_file)
# but the file is still accessible to the process
assert f.read() == 'foo'
# trying to reopen causes IOError
with pytest.raises(IOError) as cm:
f = open(bind_file)
assert cm.value.errno == errno.ENOENT
except PermissionError:
pytest.skip('No permission to use user and mount namespace')
Test_cpy_readdir_loaded = mk_cpy_loadable_testcase("snakeoil.osutils._readdir",
"snakeoil.osutils",
"listdir", "listdir")
Test_cpy_posix_loaded = mk_cpy_loadable_testcase("snakeoil._posix",
"snakeoil.osutils",
"normpath", "normpath")
"""
self.assertIn('src_install', ''.join(self.get_output(data,
funcs='src_unpack')))
def test_arg_awareness(self):
data = "f() {\n x \\{}\n}\n"
self.assertNotIn('}', ''.join(self.get_output(data, 'f')))
def test_print_vars(self):
def assertVars(data, var_list, assert_func=self.assertEqual):
l = []
self.get_output(data, global_envvar_callback=l.append)
assert_func(sorted(var_list), sorted(l))
assertVars("f(){\nX=dar\n}", [])
assertVars("f(){\nX=dar\n}\nY=a", ['Y'])
assertVars("f(){\nX=dar\n}\nmy command\nY=a\nf=$(dar)", ['Y', 'f'])
assertVars("f(){\nX=dar\n}\nmy command\nY=a\nf=$(dar) foon\n", ['Y'],
self.assertNotEqual)
assertVars("f(){\nX=dar foon\n}\nY=dar\nf2(){Z=dar;}\n", ['Y'])
class CPyFilterEnvTest(NativeFilterEnvTest):
if filter_env.cpy_run is None:
skip = 'cpy filter_env not available.'
else:
filter_env = staticmethod(partial(filter_env.main_run, _parser=filter_env.cpy_run))
cpy_loaded_Test = mk_cpy_loadable_testcase("pkgcore.ebuild._filter_env",
"pkgcore.ebuild.filter_env", "run", "run")
