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