Attachment #365096 for bug #493906

Lines 1310-1317 Link Here

(-)paludis-1.4.2.org/configure.ac (-2 / +2 lines)
1310	AC_MSG_ERROR([Your gcc is too old for Python support]))	1310	AC_MSG_ERROR([Your gcc is too old for Python support]))
1311		1311
1312	AC_MSG_CHECKING(for headers required to compile python extensions)	1312	AC_MSG_CHECKING(for headers required to compile python extensions)
1313	py_prefix=`$PYTHON -c "import sys; print sys.prefix"`	1313	py_prefix=`$PYTHON -c "import sys; print(sys.prefix)"`
1314	py_exec_prefix=`$PYTHON -c "import sys; print sys.exec_prefix"`	1314	py_exec_prefix=`$PYTHON -c "import sys; print(sys.exec_prefix)"`
1315	PYTHON_INCLUDE_DIR="${py_prefix}/include/python${PYTHON_VERSION}"	1315	PYTHON_INCLUDE_DIR="${py_prefix}/include/python${PYTHON_VERSION}"
1316	if test "$py_prefix" != "$py_exec_prefix"; then	1316	if test "$py_prefix" != "$py_exec_prefix"; then
1317	PYTHON_INCLUDE_DIR="$PYTHON_INCLUDE_DIR -I${py_exec_prefix}/include/python${PYTHON_VERSION}"	1317	PYTHON_INCLUDE_DIR="$PYTHON_INCLUDE_DIR -I${py_exec_prefix}/include/python${PYTHON_VERSION}"




class TestCase_01_Choices(unittest.TestCase):
    def setUp(self):
        self.e = EnvironmentFactory.instance.create("")
        self.pid = next(iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])))
        self.choices = self.pid.find_metadata("PALUDIS_CHOICES").parse_value()

    def test_01_choices(self):

        self.assert_(not self.choices.has_matching_contains_every_value_prefix("foo"))

    def test_04_iter(self):
        self.assert_(isinstance(next(iter(self.choices)), Choice))
        found = False
        for f in self.choices:
            if f.raw_name == "USE":

class TestCase_02_Choice(unittest.TestCase):
    def setUp(self):
        self.e = EnvironmentFactory.instance.create("")
        self.pid = next(iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])))
        self.choices = self.pid.find_metadata("PALUDIS_CHOICES").parse_value()
        self.use = None
        self.linguas = None

        self.assertEquals(self.linguas.consider_added_or_changed, True)

    def test_03_use_iter(self):
        self.assert_(isinstance(next(iter(self.use)), ChoiceValue))
        found = False
        for f in self.use:
            if f.name_with_prefix == "testflag":

        self.assert_(found)

    def test_04_linguas_iter(self):
        self.assert_(isinstance(next(iter(self.linguas)), ChoiceValue))
        found = False
        for f in self.linguas:
            if f.name_with_prefix == "linguas_en":

class TestCase_03_ChoiceValue(unittest.TestCase):
    def setUp(self):
        self.e = EnvironmentFactory.instance.create("")
        self.pid = next(iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])))
        self.choices = self.pid.find_metadata("PALUDIS_CHOICES").parse_value()
        self.use_testflag = self.choices.find_by_name_with_prefix("testflag")
        self.linguas_en = self.choices.find_by_name_with_prefix("linguas_en")

Lines 79-86 Link Here

(-)paludis-1.4.2.org/python/dep_spec_TEST.py (-3 / +3 lines)
79	vrc = self.pds.version_requirements	79	vrc = self.pds.version_requirements
80		80
81	self.assertEquals(len(list(vrc)), 1)	81	self.assertEquals(len(list(vrc)), 1)
82	self.assertEquals(iter(vrc).next().version_spec, VersionSpec("1"))	82	self.assertEquals(next(iter(vrc)).version_spec, VersionSpec("1"))
83	self.assertEquals(iter(vrc).next().version_operator.value, VersionOperator(">=").value)	83	self.assertEquals(next(iter(vrc)).version_operator.value, VersionOperator(">=").value)
84		84
85	def test_08_version_requirements_mode(self):	85	def test_08_version_requirements_mode(self):
86	self.get_depspecs()	86	self.get_depspecs()
Lines 88-94 Link Here
88		88
89	### def test_09_additional_requirements(self):	89	### def test_09_additional_requirements(self):
90	### spec = parse_user_package_dep_spec("foo/monkey[foo]", UserPackageDepSpecOptions())	90	### spec = parse_user_package_dep_spec("foo/monkey[foo]", UserPackageDepSpecOptions())
91	### ur = iter(spec.additional_requirements).next()	91	### ur = next(iter(spec.additional_requirements))
92	### self.assert_(isinstance(ur, EnabledUseRequirement))	92	### self.assert_(isinstance(ur, EnabledUseRequirement))
93		93
94	def test_11_name(self):	94	def test_11_name(self):

Lines 68-74 Link Here

(-)paludis-1.4.2.org/python/exception.hh (-1 / +12 lines)
68	_e(PyErr_NewException(const_cast<char*>(_longname.c_str()), base, NULL))	68	_e(PyErr_NewException(const_cast<char*>(_longname.c_str()), base, NULL))
69	{	69	{
70	PyModule_AddObject(boost::python::detail::current_scope, const_cast<char*>(_name.c_str()), _e);	70	PyModule_AddObject(boost::python::detail::current_scope, const_cast<char*>(_name.c_str()), _e);
71	PyObject * doc_string = PyString_FromString(doc.c_str());	71	PyObject * doc_string =
		72	#if PY_MAJOR_VERSION < 3
		73	PyString_FromString(doc.c_str());
		74	# else
		75	PyUnicode_FromString(doc.c_str());
		76	# endif
72	PyObject_SetAttrString(_e, "__doc__", doc_string);	77	PyObject_SetAttrString(_e, "__doc__", doc_string);
73	boost::python::register_exception_translator<Ex_>(	78	boost::python::register_exception_translator<Ex_>(
74	std::bind(std::mem_fn(&RegisteredException<Ex_>::translator), this, std::placeholders::_1));	79	std::bind(std::mem_fn(&RegisteredException<Ex_>::translator), this, std::placeholders::_1));
Lines 78-86 Link Here
78	void	83	void
79	RegisteredException<Ex_>::translator(const Ex_ & x) const	84	RegisteredException<Ex_>::translator(const Ex_ & x) const
80	{	85	{
		86	#if PY_MAJOR_VERSION < 3
81	PyObject * backtrace = PyString_FromString(x.backtrace("\n").c_str());	87	PyObject * backtrace = PyString_FromString(x.backtrace("\n").c_str());
82	PyObject * message = PyString_FromString(x.message().c_str());	88	PyObject * message = PyString_FromString(x.message().c_str());
83	PyObject * what = PyString_FromString(x.what());	89	PyObject * what = PyString_FromString(x.what());
		90	#else
		91	PyObject * backtrace = PyUnicode_FromString(x.backtrace("\n").c_str());
		92	PyObject * message = PyUnicode_FromString(x.message().c_str());
		93	PyObject * what = PyUnicode_FromString(x.what());
		94	#endif
84	PyObject_SetAttrString(_e, "backtrace", backtrace);	95	PyObject_SetAttrString(_e, "backtrace", backtrace);
85	PyObject_SetAttrString(_e, "message", message);	96	PyObject_SetAttrString(_e, "message", message);
86	PyObject_SetAttrString(_e, "what", what);	97	PyObject_SetAttrString(_e, "what", what);




        {
            static void add(Set<To_> & c, PyObject * ptr)
            {
                c.insert(To_(boost::python::extract<std::string>(ptr)));
                c.insert(To_(std::string(str)));
            }
        };


        {
            static void add(Sequence<To_> & c, PyObject * ptr)
            {
                c.push_back(To_(boost::python::extract<std::string>(ptr)));
                c.push_back(To_(std::string(str)));
            }
        };


                        V_ * ptr = boost::python::extract<V_ *>(o);
                        s->push_back(*ptr);
                    }
                    else if (
                        IsConvertible<std::string, V_>::value
#if PY_MAJOR_VERSION < 3
                     && PyString_Check(o.ptr())
#else
                     && PyUnicode_Check(o.ptr())
#endif
                      )
                    {
                        ConditionalAdd<V_, std::string, Sequence<V_>,
                            IsConvertible<std::string, V_>::value>::add(*s, o.ptr());

                        V_ * ptr = boost::python::extract<V_ *>(o);
                        s->insert(*ptr);
                    }
                    else if (
                        IsConvertible<std::string, V_>::value
#if PY_MAJOR_VERSION < 3
                     && PyString_Check(o.ptr())
#else
                     && PyUnicode_Check(o.ptr())
#endif
                      )
                    {
                        ConditionalAdd<V_, std::string, Set<V_>,
                                IsConvertible<std::string, V_>::value>::add(*s, o.ptr());




    def test_01_user_mask(self):
        q = Selection.RequireExactlyOne(Generator.Matches(
            parse_user_package_dep_spec("=masked/user-1.0", self.e, []), []))
        pid = next(iter(self.e[q]))
        m = next(iter(pid.masks))

        self.assert_(isinstance(m, Mask))
        self.assert_(isinstance(m, UserMask))

    def test_02_unaccepted_mask(self):
        q = Selection.RequireExactlyOne(Generator.Matches(
            parse_user_package_dep_spec("=masked/unaccepted-1.0", self.e, []), []))
        pid = next(iter(self.e[q]))
        m = next(iter(pid.masks))

        self.assert_(isinstance(m, Mask))
        self.assert_(isinstance(m, UnacceptedMask))

    def test_03_repository_mask(self):
        q = Selection.RequireExactlyOne(Generator.Matches(
            parse_user_package_dep_spec("=masked/repo-1.0", self.e, []), []))
        pid = next(iter(self.e[q]))
        m = next(iter(pid.masks))

        self.assert_(isinstance(m, Mask))
        self.assert_(isinstance(m, RepositoryMask))

    def test_04_unsupported_mask(self):
        q = Selection.RequireExactlyOne(Generator.Matches(
            parse_user_package_dep_spec("=masked/unsupported-1.0", self.e, []), []))
        pid = next(iter(self.e[q]))
        m = next(iter(pid.masks))

        self.assert_(isinstance(m, Mask))
        self.assert_(isinstance(m, UnsupportedMask))

Lines 35-42 Link Here

(-)paludis-1.4.2.org/python/metadata_key_TEST.py (-3 / +3 lines)
35	class TestCase_01_MetadataKeys(unittest.TestCase):	35	class TestCase_01_MetadataKeys(unittest.TestCase):
36	def setUp(self):	36	def setUp(self):
37	self.e = EnvironmentFactory.instance.create("")	37	self.e = EnvironmentFactory.instance.create("")
38	self.pid = iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])).next()	38	self.pid = next(iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])))
39	self.ipid = iter(self.e.fetch_repository("installed").package_ids("cat-one/pkg-one", [])).next()	39	self.ipid = next(iter(self.e.fetch_repository("installed").package_ids("cat-one/pkg-one", [])))
40		40
41	def test_02_installed_time(self):	41	def test_02_installed_time(self):
42	self.assertEquals(self.pid.find_metadata("INSTALLED_TIME"), None)	42	self.assertEquals(self.pid.find_metadata("INSTALLED_TIME"), None)
Lines 70-76 Link Here
70		70
71	def parse_value(self):	71	def parse_value(self):
72	e = EnvironmentFactory.instance.create("")	72	e = EnvironmentFactory.instance.create("")
73	pid = iter(e.fetch_repository("testrepo").package_ids("foo/bar", [])).next()	73	pid = next(iter(e.fetch_repository("testrepo").package_ids("foo/bar", [])))
74	return pid	74	return pid
75		75
76	def raw_name(self):	76	def raw_name(self):

Lines 188-194 Link Here

(-)paludis-1.4.2.org/python/name.cc (+9 lines)
188	"[ro] PackageNamePart"	188	"[ro] PackageNamePart"
189	)	189	)
190		190
		191	#if PY_MAJOR_VERSION < 3
191	.def("__cmp__", &py_cmp<QualifiedPackageName>)	192	.def("__cmp__", &py_cmp<QualifiedPackageName>)
		193	# else
		194	.def(bp::self == bp::self)
		195	.def(bp::self != bp::self)
		196	.def(bp::self < bp::self)
		197	.def(bp::self <= bp::self)
		198	.def(bp::self > bp::self)
		199	.def(bp::self >= bp::self)
		200	# endif
192		201
193	.def(bp::self_ns::str(bp::self))	202	.def(bp::self_ns::str(bp::self))
194	;	203	;




class TestCase_01_PackageID(unittest.TestCase):
    def setUp(self):
        self.e = EnvironmentFactory.instance.create("")
        self.pid = next(iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])))
        self.ipid = next(iter(self.e.fetch_repository("installed").package_ids("cat-one/pkg-one", [])))
        self.mpid = next(iter(self.e.fetch_repository("testrepo").package_ids("cat/masked", [])))

    def test_01_get(self):
        pass

        self.assert_(self.mpid.masked)

    def test_13_masks(self):
        mask = next(iter(self.mpid.masks))
        self.assert_(isinstance(mask, UnacceptedMask))

    def test_18_build_dependencies_key(self):


    def test_28_from_repositories_key(self):
        self.assertEquals(self.pid.from_repositories_key(), None)
        self.assertEquals(next(iter(self.ipid.from_repositories_key().parse_value())), "origin_test")

    def test_30_fs_location_key(self):
        self.assert_(isinstance(self.ipid.fs_location_key(), MetadataFSPathKey))

Lines 92-98 Link Here

(-)paludis-1.4.2.org/python/paludis_python.hh (-1 / +13 lines)
92	doc += "\n\t" + e_name_up;	92	doc += "\n\t" + e_name_up;
93	}	93	}
94	PyTypeObject * pto = reinterpret_cast<PyTypeObject *>(enum_.ptr());	94	PyTypeObject * pto = reinterpret_cast<PyTypeObject *>(enum_.ptr());
95	PyDict_SetItemString(pto->tp_dict, "__doc__", PyString_FromString(doc.c_str()));	95	PyDict_SetItemString(
		96	pto->tp_dict
		97	, "__doc__"
		98	#if PY_MAJOR_VERSION < 3
		99	, PyString_FromString(doc.c_str())
		100	#else
		101	, PyUnicode_FromString(doc.c_str())
		102	#endif
		103	);
96	}	104	}
97		105
98	// Compare	106	// Compare
Lines 128-134 Link Here
128	static PyObject *	136	static PyObject *
129	convert(const T_ & x)	137	convert(const T_ & x)
130	{	138	{
		139	#if PY_MAJOR_VERSION < 3
131	return PyString_FromString(stringify<T_>(x).c_str());	140	return PyString_FromString(stringify<T_>(x).c_str());
		141	#else
		142	return PyUnicode_FromString(stringify<T_>(x).c_str());
		143	#endif
132	}	144	}
133	};	145	};
134		146

Lines 95-101 Link Here

(-)paludis-1.4.2.org/python/version_spec.cc (+9 lines)
95	"Revision part only (or \"r0\")."	95	"Revision part only (or \"r0\")."
96	)	96	)
97		97
		98	#if PY_MAJOR_VERSION < 3
98	.def("__cmp__", &VersionSpec::compare)	99	.def("__cmp__", &VersionSpec::compare)
		100	#else
		101	.def(bp::self == bp::self)
		102	.def(bp::self != bp::self)
		103	.def(bp::self < bp::self)
		104	.def(bp::self <= bp::self)
		105	.def(bp::self > bp::self)
		106	.def(bp::self >= bp::self)
		107	#endif
99		108
100	.def(bp::self_ns::str(bp::self))	109	.def(bp::self_ns::str(bp::self))
101	;	110	;




                            boost::python::init<const typename WrappedValueTraits<Tag_>::UnderlyingType &>(("__init__("+init_arg+")").c_str())
                            )
                {
                    namespace bp = boost::python;
                    this->def(bp::self_ns::str(bp::self))
#if PY_MAJOR_VERSION < 3
                      .def("__cmp__", &paludis::python::py_cmp<WrappedValue<Tag_> >)
# else
                      .def(bp::self == bp::self)
                      .def(bp::self != bp::self)
                      .def(bp::self <  bp::self)
                      .def(bp::self <= bp::self)
                      .def(bp::self >  bp::self)
                      .def(bp::self >= bp::self)
# endif
                      ;
                    bp::implicitly_convertible<typename WrappedValueTraits<Tag_>::UnderlyingType,
                            WrappedValue<Tag_> >();
                }
        };

Return to bug 493906

Lines 34-40 Link Here

(-)paludis-1.4.2.org/python/choices_TEST.py (-6 / +6 lines)
34	class TestCase_01_Choices(unittest.TestCase):	34	class TestCase_01_Choices(unittest.TestCase):
35	def setUp(self):	35	def setUp(self):
36	self.e = EnvironmentFactory.instance.create("")	36	self.e = EnvironmentFactory.instance.create("")
37	self.pid = iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])).next()	37	self.pid = next(iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])))
38	self.choices = self.pid.find_metadata("PALUDIS_CHOICES").parse_value()	38	self.choices = self.pid.find_metadata("PALUDIS_CHOICES").parse_value()
39		39
40	def test_01_choices(self):	40	def test_01_choices(self):
Lines 50-56 Link Here
50	self.assert_(not self.choices.has_matching_contains_every_value_prefix("foo"))	50	self.assert_(not self.choices.has_matching_contains_every_value_prefix("foo"))
51		51
52	def test_04_iter(self):	52	def test_04_iter(self):
53	self.assert_(isinstance(iter(self.choices).next(), Choice))	53	self.assert_(isinstance(next(iter(self.choices)), Choice))
54	found = False	54	found = False
55	for f in self.choices:	55	for f in self.choices:
56	if f.raw_name == "USE":	56	if f.raw_name == "USE":
Lines 60-66 Link Here
60	class TestCase_02_Choice(unittest.TestCase):	60	class TestCase_02_Choice(unittest.TestCase):
61	def setUp(self):	61	def setUp(self):
62	self.e = EnvironmentFactory.instance.create("")	62	self.e = EnvironmentFactory.instance.create("")
63	self.pid = iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])).next()	63	self.pid = next(iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])))
64	self.choices = self.pid.find_metadata("PALUDIS_CHOICES").parse_value()	64	self.choices = self.pid.find_metadata("PALUDIS_CHOICES").parse_value()
65	self.use = None	65	self.use = None
66	self.linguas = None	66	self.linguas = None
Lines 91-97 Link Here
91	self.assertEquals(self.linguas.consider_added_or_changed, True)	91	self.assertEquals(self.linguas.consider_added_or_changed, True)
92		92
93	def test_03_use_iter(self):	93	def test_03_use_iter(self):
94	self.assert_(isinstance(iter(self.use).next(), ChoiceValue))	94	self.assert_(isinstance(next(iter(self.use)), ChoiceValue))
95	found = False	95	found = False
96	for f in self.use:	96	for f in self.use:
97	if f.name_with_prefix == "testflag":	97	if f.name_with_prefix == "testflag":
Lines 99-105 Link Here
99	self.assert_(found)	99	self.assert_(found)
100		100
101	def test_04_linguas_iter(self):	101	def test_04_linguas_iter(self):
102	self.assert_(isinstance(iter(self.linguas).next(), ChoiceValue))	102	self.assert_(isinstance(next(iter(self.linguas)), ChoiceValue))
103	found = False	103	found = False
104	for f in self.linguas:	104	for f in self.linguas:
105	if f.name_with_prefix == "linguas_en":	105	if f.name_with_prefix == "linguas_en":
Lines 109-115 Link Here
109	class TestCase_03_ChoiceValue(unittest.TestCase):	109	class TestCase_03_ChoiceValue(unittest.TestCase):
110	def setUp(self):	110	def setUp(self):
111	self.e = EnvironmentFactory.instance.create("")	111	self.e = EnvironmentFactory.instance.create("")
112	self.pid = iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])).next()	112	self.pid = next(iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])))
113	self.choices = self.pid.find_metadata("PALUDIS_CHOICES").parse_value()	113	self.choices = self.pid.find_metadata("PALUDIS_CHOICES").parse_value()
114	self.use_testflag = self.choices.find_by_name_with_prefix("testflag")	114	self.use_testflag = self.choices.find_by_name_with_prefix("testflag")
115	self.linguas_en = self.choices.find_by_name_with_prefix("linguas_en")	115	self.linguas_en = self.choices.find_by_name_with_prefix("linguas_en")

Lines 63-70 Link Here

(-)paludis-1.4.2.org/python/iterable.hh (-6 / +18 lines)
63	{	63	{
64	static void add(Set<To_> & c, PyObject * ptr)	64	static void add(Set<To_> & c, PyObject * ptr)
65	{	65	{
66	const char * str = PyString_AsString(ptr);	66	c.insert(To_(boost::python::extract<std::string>(ptr)));
67	c.insert(To_(std::string(str)));
68	}	67	}
69	};	68	};
70		69
Lines 73-80 Link Here
73	{	72	{
74	static void add(Sequence<To_> & c, PyObject * ptr)	73	static void add(Sequence<To_> & c, PyObject * ptr)
75	{	74	{
76	const char * str = PyString_AsString(ptr);	75	c.push_back(To_(boost::python::extract<std::string>(ptr)));
77	c.push_back(To_(std::string(str)));
78	}	76	}
79	};	77	};
80		78
Lines 130-136 Link Here
130	V_ * ptr = boost::python::extract<V_ *>(o);	128	V_ * ptr = boost::python::extract<V_ *>(o);
131	s->push_back(*ptr);	129	s->push_back(*ptr);
132	}	130	}
133	else if (IsConvertible<std::string, V_>::value && PyString_Check(o.ptr()))	131	else if (
		132	IsConvertible<std::string, V_>::value
		133	#if PY_MAJOR_VERSION < 3
		134	&& PyString_Check(o.ptr())
		135	#else
		136	&& PyUnicode_Check(o.ptr())
		137	#endif
		138	)
134	{	139	{
135	ConditionalAdd<V_, std::string, Sequence<V_>,	140	ConditionalAdd<V_, std::string, Sequence<V_>,
136	IsConvertible<std::string, V_>::value>::add(*s, o.ptr());	141	IsConvertible<std::string, V_>::value>::add(*s, o.ptr());
Lines 200-206 Link Here
200	V_ * ptr = boost::python::extract<V_ *>(o);	205	V_ * ptr = boost::python::extract<V_ *>(o);
201	s->insert(*ptr);	206	s->insert(*ptr);
202	}	207	}
203	else if (IsConvertible<std::string, V_>::value && PyString_Check(o.ptr()))	208	else if (
		209	IsConvertible<std::string, V_>::value
		210	#if PY_MAJOR_VERSION < 3
		211	&& PyString_Check(o.ptr())
		212	#else
		213	&& PyUnicode_Check(o.ptr())
		214	#endif
		215	)
204	{	216	{
205	ConditionalAdd<V_, std::string, Set<V_>,	217	ConditionalAdd<V_, std::string, Set<V_>,
206	IsConvertible<std::string, V_>::value>::add(*s, o.ptr());	218	IsConvertible<std::string, V_>::value>::add(*s, o.ptr());

Lines 36-43 Link Here

(-)paludis-1.4.2.org/python/mask_TEST.py (-8 / +8 lines)
36	def test_01_user_mask(self):	36	def test_01_user_mask(self):
37	q = Selection.RequireExactlyOne(Generator.Matches(	37	q = Selection.RequireExactlyOne(Generator.Matches(
38	parse_user_package_dep_spec("=masked/user-1.0", self.e, []), []))	38	parse_user_package_dep_spec("=masked/user-1.0", self.e, []), []))
39	pid = iter(self.e[q]).next()	39	pid = next(iter(self.e[q]))
40	m = iter(pid.masks).next()	40	m = next(iter(pid.masks))
41		41
42	self.assert_(isinstance(m, Mask))	42	self.assert_(isinstance(m, Mask))
43	self.assert_(isinstance(m, UserMask))	43	self.assert_(isinstance(m, UserMask))
Lines 48-55 Link Here
48	def test_02_unaccepted_mask(self):	48	def test_02_unaccepted_mask(self):
49	q = Selection.RequireExactlyOne(Generator.Matches(	49	q = Selection.RequireExactlyOne(Generator.Matches(
50	parse_user_package_dep_spec("=masked/unaccepted-1.0", self.e, []), []))	50	parse_user_package_dep_spec("=masked/unaccepted-1.0", self.e, []), []))
51	pid = iter(self.e[q]).next()	51	pid = next(iter(self.e[q]))
52	m = iter(pid.masks).next()	52	m = next(iter(pid.masks))
53		53
54	self.assert_(isinstance(m, Mask))	54	self.assert_(isinstance(m, Mask))
55	self.assert_(isinstance(m, UnacceptedMask))	55	self.assert_(isinstance(m, UnacceptedMask))
Lines 61-68 Link Here
61	def test_03_repository_mask(self):	61	def test_03_repository_mask(self):
62	q = Selection.RequireExactlyOne(Generator.Matches(	62	q = Selection.RequireExactlyOne(Generator.Matches(
63	parse_user_package_dep_spec("=masked/repo-1.0", self.e, []), []))	63	parse_user_package_dep_spec("=masked/repo-1.0", self.e, []), []))
64	pid = iter(self.e[q]).next()	64	pid = next(iter(self.e[q]))
65	m = iter(pid.masks).next()	65	m = next(iter(pid.masks))
66		66
67	self.assert_(isinstance(m, Mask))	67	self.assert_(isinstance(m, Mask))
68	self.assert_(isinstance(m, RepositoryMask))	68	self.assert_(isinstance(m, RepositoryMask))
Lines 76-83 Link Here
76	def test_04_unsupported_mask(self):	76	def test_04_unsupported_mask(self):
77	q = Selection.RequireExactlyOne(Generator.Matches(	77	q = Selection.RequireExactlyOne(Generator.Matches(
78	parse_user_package_dep_spec("=masked/unsupported-1.0", self.e, []), []))	78	parse_user_package_dep_spec("=masked/unsupported-1.0", self.e, []), []))
79	pid = iter(self.e[q]).next()	79	pid = next(iter(self.e[q]))
80	m = iter(pid.masks).next()	80	m = next(iter(pid.masks))
81		81
82	self.assert_(isinstance(m, Mask))	82	self.assert_(isinstance(m, Mask))
83	self.assert_(isinstance(m, UnsupportedMask))	83	self.assert_(isinstance(m, UnsupportedMask))

Lines 33-41 Link Here

(-)paludis-1.4.2.org/python/package_id_TEST.py (-5 / +5 lines)
33	class TestCase_01_PackageID(unittest.TestCase):	33	class TestCase_01_PackageID(unittest.TestCase):
34	def setUp(self):	34	def setUp(self):
35	self.e = EnvironmentFactory.instance.create("")	35	self.e = EnvironmentFactory.instance.create("")
36	self.pid = iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])).next()	36	self.pid = next(iter(self.e.fetch_repository("testrepo").package_ids("foo/bar", [])))
37	self.ipid = iter(self.e.fetch_repository("installed").package_ids("cat-one/pkg-one", [])).next()	37	self.ipid = next(iter(self.e.fetch_repository("installed").package_ids("cat-one/pkg-one", [])))
38	self.mpid = iter(self.e.fetch_repository("testrepo").package_ids("cat/masked", [])).next()	38	self.mpid = next(iter(self.e.fetch_repository("testrepo").package_ids("cat/masked", [])))
39		39
40	def test_01_get(self):	40	def test_01_get(self):
41	pass	41	pass
Lines 102-108 Link Here
102	self.assert_(self.mpid.masked)	102	self.assert_(self.mpid.masked)
103		103
104	def test_13_masks(self):	104	def test_13_masks(self):
105	mask = iter(self.mpid.masks).next()	105	mask = next(iter(self.mpid.masks))
106	self.assert_(isinstance(mask, UnacceptedMask))	106	self.assert_(isinstance(mask, UnacceptedMask))
107		107
108	def test_18_build_dependencies_key(self):	108	def test_18_build_dependencies_key(self):
Lines 139-145 Link Here
139		139
140	def test_28_from_repositories_key(self):	140	def test_28_from_repositories_key(self):
141	self.assertEquals(self.pid.from_repositories_key(), None)	141	self.assertEquals(self.pid.from_repositories_key(), None)
142	self.assertEquals(iter(self.ipid.from_repositories_key().parse_value()).next(), "origin_test")	142	self.assertEquals(next(iter(self.ipid.from_repositories_key().parse_value())), "origin_test")
143		143
144	def test_30_fs_location_key(self):	144	def test_30_fs_location_key(self):
145	self.assert_(isinstance(self.ipid.fs_location_key(), MetadataFSPathKey))	145	self.assert_(isinstance(self.ipid.fs_location_key(), MetadataFSPathKey))

Lines 43-52 Link Here

(-)paludis-1.4.2.org/python/wrapped_value.hh (-4 / +14 lines)
43	boost::python::init<const typename WrappedValueTraits<Tag_>::UnderlyingType &>(("__init__("+init_arg+")").c_str())	43	boost::python::init<const typename WrappedValueTraits<Tag_>::UnderlyingType &>(("__init__("+init_arg+")").c_str())
44	)	44	)
45	{	45	{
46	this->def(boost::python::self_ns::str(boost::python::self));	46	namespace bp = boost::python;
47	this->def("__cmp__",	47	this->def(bp::self_ns::str(bp::self))
48	&paludis::python::py_cmp<WrappedValue<Tag_> >);	48	#if PY_MAJOR_VERSION < 3
49	boost::python::implicitly_convertible<typename WrappedValueTraits<Tag_>::UnderlyingType,	49	.def("__cmp__", &paludis::python::py_cmp<WrappedValue<Tag_> >)
		50	# else
		51	.def(bp::self == bp::self)
		52	.def(bp::self != bp::self)
		53	.def(bp::self < bp::self)
		54	.def(bp::self <= bp::self)
		55	.def(bp::self > bp::self)
		56	.def(bp::self >= bp::self)
		57	# endif
		58	;
		59	bp::implicitly_convertible<typename WrappedValueTraits<Tag_>::UnderlyingType,
50	WrappedValue<Tag_> >();	60	WrappedValue<Tag_> >();
51	}	61	}
52	};	62	};