reposyntax: Add support all over the place

12 files changed, 362 insertions, 37 deletions

diff --git a/pym/portage/_sets/files.py b/pym/portage/_sets/files.py
index 995fda67b..8c8aeef4b 100644
--- a/pym/portage/_sets/files.py
+++ b/pym/portage/_sets/files.py
@@ -29,7 +29,7 @@ class StaticFileSet(EditablePackageSet):
 	_repopath_sub = re.compile(r'\$\{repository:(?P<reponame>.+)\}')
 		
 	def __init__(self, filename, greedy=False, dbapi=None):
-		super(StaticFileSet, self).__init__()
+		super(StaticFileSet, self).__init__(allow_repo=True)
 		self._filename = filename
 		self._mtime = None
 		self.description = "Package set loaded from file %s" % self._filename
@@ -60,7 +60,7 @@ class StaticFileSet(EditablePackageSet):
 				setattr(self, key, " ".join(value))
 
 	def _validate(self, atom):
-		return bool(atom[:1] == SETPREFIX or ValidAtomValidator(atom))
+		return bool(atom[:1] == SETPREFIX or ValidAtomValidator(atom, allow_repo=True))
 
 	def write(self):
 		write_atomic(self._filename, "".join("%s\n" % (atom,) \
diff --git a/pym/portage/dbapi/__init__.py b/pym/portage/dbapi/__init__.py
index 3803339d5..69592b680 100644
--- a/pym/portage/dbapi/__init__.py
+++ b/pym/portage/dbapi/__init__.py
@@ -89,11 +89,12 @@ class dbapi(object):
 		"""
 		return NotImplementedError
 
-	def aux_get(self, mycpv, mylist):
+	def aux_get(self, mycpv, mylist, myrepo=None):
 		"""Return the metadata keys in mylist for mycpv
 		Args:
 			mycpv - "sys-apps/foo-1.0"
 			mylist - ["SLOT","DEPEND","HOMEPAGE"]
+			myrepo - The repository name.
 		Returns: 
 			a list of results, in order of keys in mylist, such as:
 			["0",">=sys-libs/bar-1.0","http://www.foo.com"] or [] if mycpv not found'
@@ -123,23 +124,33 @@ class dbapi(object):
 		return list(self._iter_match(mydep,
 			self.cp_list(mydep.cp, use_cache=use_cache)))
 
-	def _iter_match(self, atom, cpv_iter):
+	def _iter_match(self, atom, cpv_iter, myrepo=None):
 		cpv_iter = iter(match_from_list(atom, cpv_iter))
 		if atom.slot:
-			cpv_iter = self._iter_match_slot(atom, cpv_iter)
+			cpv_iter = self._iter_match_slot(atom, cpv_iter, myrepo)
 		if atom.use:
-			cpv_iter = self._iter_match_use(atom, cpv_iter)
+			cpv_iter = self._iter_match_use(atom, cpv_iter, myrepo)
+		if atom.repo:
+			cpv_iter = self._iter_match_repo(atom, cpv_iter, myrepo)
 		return cpv_iter
 
-	def _iter_match_slot(self, atom, cpv_iter):
+	def _iter_match_repo(self, atom, cpv_iter, myrepo=None):
 		for cpv in cpv_iter:
 			try:
-				if self.aux_get(cpv, ["SLOT"])[0] == atom.slot:
+				if self.aux_get(cpv, ["repository"], myrepo=myrepo)[0] == atom.repo:
 					yield cpv
 			except KeyError:
 				continue
 
-	def _iter_match_use(self, atom, cpv_iter):
+	def _iter_match_slot(self, atom, cpv_iter, myrepo=None):
+		for cpv in cpv_iter:
+			try:
+				if self.aux_get(cpv, ["SLOT"], myrepo=myrepo)[0] == atom.slot:
+					yield cpv
+			except KeyError:
+				continue
+
+	def _iter_match_use(self, atom, cpv_iter, myrepo = None):
 		"""
 		1) Check for required IUSE intersection (need implicit IUSE here).
 		2) Check enabled/disabled flag states.
@@ -148,7 +159,7 @@ class dbapi(object):
 		iuse_implicit_match = self.settings._iuse_implicit_match
 		for cpv in cpv_iter:
 			try:
-				iuse, slot, use = self.aux_get(cpv, ["IUSE", "SLOT", "USE"])
+				iuse, slot, use = self.aux_get(cpv, ["IUSE", "SLOT", "USE"], myrepo=myrepo)
 			except KeyError:
 				continue
 			use = use.split()
diff --git a/pym/portage/dbapi/bintree.py b/pym/portage/dbapi/bintree.py
index aec89e016..a5a916b8e 100644
--- a/pym/portage/dbapi/bintree.py
+++ b/pym/portage/dbapi/bintree.py
@@ -88,7 +88,7 @@ class bindbapi(fakedbapi):
 		self._aux_cache.pop(cpv, None)
 		fakedbapi.cpv_remove(self, cpv)
 
-	def aux_get(self, mycpv, wants):
+	def aux_get(self, mycpv, wants, myrepo=None):
 		if self.bintree and not self.bintree.populated:
 			self.bintree.populate()
 		cache_me = False
diff --git a/pym/portage/dbapi/dep_expand.py b/pym/portage/dbapi/dep_expand.py
index ab1605413..58ffae35b 100644
--- a/pym/portage/dbapi/dep_expand.py
+++ b/pym/portage/dbapi/dep_expand.py
@@ -44,4 +44,4 @@ def dep_expand(mydep, mydb=None, use_cache=1, settings=None):
 			mydep = mydep.cp
 	expanded = cpv_expand(mydep, mydb=mydb,
 		use_cache=use_cache, settings=settings)
-	return Atom(orig_dep.replace(mydep, expanded, 1))
+	return Atom(orig_dep.replace(mydep, expanded, 1), allow_repo=True)
diff --git a/pym/portage/dbapi/porttree.py b/pym/portage/dbapi/porttree.py
index 0065ed3b8..d84c459d0 100644
--- a/pym/portage/dbapi/porttree.py
+++ b/pym/portage/dbapi/porttree.py
@@ -357,8 +357,8 @@ class portdbapi(dbapi):
 				return license_path
 		return None
 
-	def findname(self,mycpv):
-		return self.findname2(mycpv)[0]
+	def findname(self,mycpv, mytree = None, myrepo = None):
+		return self.findname2(mycpv, mytree, myrepo)[0]
 
 	def getRepositoryPath(self, repository_id):
 		"""
@@ -390,16 +390,24 @@ class portdbapi(dbapi):
 		"""
 		return [k for k in self.treemap if k]
 
-	def findname2(self, mycpv, mytree=None):
+	def findname2(self, mycpv, mytree=None, myrepo = None):
 		""" 
 		Returns the location of the CPV, and what overlay it was in.
 		Searches overlays first, then PORTDIR; this allows us to return the first
 		matching file.  As opposed to starting in portdir and then doing overlays
 		second, we would have to exhaustively search the overlays until we found
 		the file we wanted.
+		If myrepo is not None it will find packages from this repository(overlay)
 		"""
 		if not mycpv:
 			return (None, 0)
+
+		if myrepo:
+			if myrepo in self.treemap:
+				mytree = self.treemap[myrepo]
+			else:
+				return (None, 0)
+		
 		mysplit = mycpv.split("/")
 		psplit = pkgsplit(mysplit[1])
 		if psplit is None or len(mysplit) != 2:
@@ -524,11 +532,17 @@ class portdbapi(dbapi):
 
 		return (metadata, st, emtime)
 
-	def aux_get(self, mycpv, mylist, mytree=None):
+	def aux_get(self, mycpv, mylist, mytree=None, myrepo=None):
 		"stub code for returning auxilliary db information, such as SLOT, DEPEND, etc."
 		'input: "sys-apps/foo-1.0",["SLOT","DEPEND","HOMEPAGE"]'
 		'return: ["0",">=sys-libs/bar-1.0","http://www.foo.com"] or raise KeyError if error'
 		cache_me = False
+		if myrepo:
+			if myrepo in self.treemap:
+				mytree = self.treemap[myrepo]
+			else:
+				raise KeyError(myrepo)
+				
 		if not mytree:
 			cache_me = True
 		if not mytree and not self._known_keys.intersection(
@@ -657,9 +671,9 @@ class portdbapi(dbapi):
 		return _parse_uri_map(mypkg, {'EAPI':eapi,'SRC_URI':myuris},
 			use=useflags)
 
-	def getfetchsizes(self, mypkg, useflags=None, debug=0):
+	def getfetchsizes(self, mypkg, useflags=None, debug=0, myrepo=None):
 		# returns a filename:size dictionnary of remaining downloads
-		myebuild = self.findname(mypkg)
+		myebuild = self.findname(mypkg, myrepo=myrepo)
 		if myebuild is None:
 			raise AssertionError(_("ebuild not found for '%s'") % mypkg)
 		pkgdir = os.path.dirname(myebuild)
@@ -710,14 +724,22 @@ class portdbapi(dbapi):
 				filesdict[myfile] = int(checksums[myfile]["size"])
 		return filesdict
 
-	def fetch_check(self, mypkg, useflags=None, mysettings=None, all=False):
+	def fetch_check(self, mypkg, useflags=None, mysettings=None, all=False, myrepo=None):
 		if all:
 			useflags = None
 		elif useflags is None:
 			if mysettings:
 				useflags = mysettings["USE"].split()
-		myfiles = self.getFetchMap(mypkg, useflags=useflags)
-		myebuild = self.findname(mypkg)
+		if myrepo:
+			if myrepo in self.treemap:
+				mytree = self.treemap[myrepo]
+			else:
+				return False
+		else:
+			mytree = None
+
+		myfiles = self.getFetchMap(mypkg, useflags=useflags, mytree=mytree)
+		myebuild = self.findname(mypkg, myrepo=myrepo)
 		if myebuild is None:
 			raise AssertionError(_("ebuild not found for '%s'") % mypkg)
 		pkgdir = os.path.dirname(myebuild)
@@ -895,7 +917,7 @@ class portdbapi(dbapi):
 			if mydep == mykey:
 				mylist = self.cp_list(mykey)
 			else:
-				mylist = match_from_list(mydep, self.cp_list(mykey))
+				mylist = match_from_list(mydep, self.cp_list(mykey, myrepo = mydep.repo))
 			myval = ""
 			settings = self.settings
 			local_config = settings.local_config
@@ -953,15 +975,14 @@ class portdbapi(dbapi):
 		elif level == "match-visible":
 			#dep match -- find all visible matches
 			#get all visible packages, then get the matching ones
-
 			myval = list(self._iter_match(mydep,
-				self.xmatch("list-visible", mykey, mydep=mykey, mykey=mykey)))
+				self.xmatch("list-visible", mykey, mydep=mykey, mykey=mykey), myrepo=mydep.repo))
 		elif level == "match-all":
 			#match *all* visible *and* masked packages
 			if mydep == mykey:
 				myval = self.cp_list(mykey)
 			else:
-				myval = list(self._iter_match(mydep, self.cp_list(mykey)))
+				myval = list(self._iter_match(mydep, self.cp_list(mykey), myrepo = mydep.repo))
 		else:
 			raise AssertionError(
 				"Invalid level argument: '%s'" % level)
diff --git a/pym/portage/dbapi/vartree.py b/pym/portage/dbapi/vartree.py
index aff4d86c2..239b0d761 100644
--- a/pym/portage/dbapi/vartree.py
+++ b/pym/portage/dbapi/vartree.py
@@ -35,6 +35,7 @@ from portage.const import CACHE_PATH, CONFIG_MEMORY_FILE, \
 	PORTAGE_PACKAGE_ATOM, PRIVATE_PATH, VDB_PATH
 from portage.const import _ENABLE_DYN_LINK_MAP, _ENABLE_PRESERVE_LIBS
 from portage.dbapi import dbapi
+from portage.dep import _slot_separator
 from portage.exception import CommandNotFound, \
 	InvalidData, InvalidPackageName, \
 	FileNotFound, PermissionDenied, UnsupportedAPIException
@@ -514,7 +515,7 @@ class vardbapi(dbapi):
 		aux_cache["modified"] = set()
 		self._aux_cache_obj = aux_cache
 
-	def aux_get(self, mycpv, wants):
+	def aux_get(self, mycpv, wants, myrepo = None):
 		"""This automatically caches selected keys that are frequently needed
 		by emerge for dependency calculations.  The cached metadata is
 		considered valid if the mtime of the package directory has not changed
diff --git a/pym/portage/glsa.py b/pym/portage/glsa.py
index 116003a5d..a152cd576 100644
--- a/pym/portage/glsa.py
+++ b/pym/portage/glsa.py
@@ -21,6 +21,7 @@ from portage.versions import pkgsplit, catpkgsplit, pkgcmp, best
 from portage.util import grabfile
 from portage.const import CACHE_PATH
 from portage.localization import _
+from portage.dep import _slot_separator
 
 # Note: the space for rgt and rlt is important !!
 # FIXME: use slot deps instead, requires GLSA format versioning
@@ -242,7 +243,7 @@ def makeAtom(pkgname, versionNode):
 		pass
 	else:
 		if slot and slot != "*":
-			rValue += ":" + slot
+			rValue += _slot_separator + slot
 	return str(rValue)
 
 def makeVersion(versionNode):
@@ -264,7 +265,7 @@ def makeVersion(versionNode):
 		pass
 	else:
 		if slot and slot != "*":
-			rValue += ":" + slot
+			rValue += _slot_separator + slot
 	return rValue
 
 def match(atom, dbapi, match_type="default"):
diff --git a/pym/portage/package/ebuild/getmaskingreason.py b/pym/portage/package/ebuild/getmaskingreason.py
index 3511c0dcb..000bb406c 100644
--- a/pym/portage/package/ebuild/getmaskingreason.py
+++ b/pym/portage/package/ebuild/getmaskingreason.py
@@ -6,7 +6,7 @@ __all__ = ['getmaskingreason']
 import portage
 from portage import os
 from portage.const import USER_CONFIG_PATH
-from portage.dep import match_from_list
+from portage.dep import match_from_list, _slot_separator, _repo_separator
 from portage.localization import _
 from portage.util import grablines, normalize_path
 from portage.versions import catpkgsplit
@@ -22,7 +22,7 @@ def getmaskingreason(mycpv, metadata=None, settings=None, portdb=None, return_lo
 	if metadata is None:
 		db_keys = list(portdb._aux_cache_keys)
 		try:
-			metadata = dict(zip(db_keys, portdb.aux_get(mycpv, db_keys)))
+			metadata = dict(zip(db_keys, portdb.aux_get(mycpv, db_keys, myrepo=metadata.get('repository'))))
 		except KeyError:
 			if not portdb.cpv_exists(mycpv):
 				raise
@@ -30,7 +30,10 @@ def getmaskingreason(mycpv, metadata=None, settings=None, portdb=None, return_lo
 		# Can't access SLOT due to corruption.
 		cpv_slot_list = [mycpv]
 	else:
-		cpv_slot_list = ["%s:%s" % (mycpv, metadata["SLOT"])]
+		pkg = "".join((mycpv, _slot_separator, metadata["SLOT"]))
+		if 'repository' in metadata:
+			pkg = "".join((pkg, _repo_separator, metadata['repository']))
+		cpv_slot_list = [pkg]
 	mycp=mysplit[0]+"/"+mysplit[1]
 
 	# XXX- This is a temporary duplicate of code from the config constructor.
diff --git a/pym/portage/package/ebuild/getmaskingstatus.py b/pym/portage/package/ebuild/getmaskingstatus.py
index 1eb6afed2..a7d3c333f 100644
--- a/pym/portage/package/ebuild/getmaskingstatus.py
+++ b/pym/portage/package/ebuild/getmaskingstatus.py
@@ -7,7 +7,7 @@ import sys
 
 import portage
 from portage import eapi_is_supported, _eapi_is_deprecated
-from portage.dep import match_from_list
+from portage.dep import match_from_list, _slot_separator, _repo_separator
 from portage.localization import _
 from portage.package.ebuild.config import config
 from portage.versions import catpkgsplit, cpv_getkey
@@ -32,16 +32,16 @@ class _MaskReason(object):
 		self.message = message
 		self.unmask_hint = unmask_hint
 
-def getmaskingstatus(mycpv, settings=None, portdb=None):
+def getmaskingstatus(mycpv, settings=None, portdb=None, myrepo=None):
 	if settings is None:
 		settings = config(clone=portage.settings)
 	if portdb is None:
 		portdb = portage.portdb
 
 	return [mreason.message for \
-		mreason in _getmaskingstatus(mycpv, settings, portdb)]
+		mreason in _getmaskingstatus(mycpv, settings, portdb,myrepo)]
 
-def _getmaskingstatus(mycpv, settings, portdb):
+def _getmaskingstatus(mycpv, settings, portdb, myrepo=None):
 
 	metadata = None
 	installed = False
@@ -58,7 +58,7 @@ def _getmaskingstatus(mycpv, settings, portdb):
 	if metadata is None:
 		db_keys = list(portdb._aux_cache_keys)
 		try:
-			metadata = dict(zip(db_keys, portdb.aux_get(mycpv, db_keys)))
+			metadata = dict(zip(db_keys, portdb.aux_get(mycpv, db_keys, myrepo=myrepo)))
 		except KeyError:
 			if not portdb.cpv_exists(mycpv):
 				raise
@@ -103,7 +103,10 @@ def _getmaskingstatus(mycpv, settings, portdb):
 	pkgdict = settings._keywords_manager.pkeywordsdict.get(cp)
 	matches = False
 	if pkgdict:
-		cpv_slot_list = ["%s:%s" % (mycpv, metadata["SLOT"])]
+		pkg = "".join((mycpv, _slot_separator, metadata["SLOT"]))
+		if 'repository' in metadata:
+			pkg = "".join((pkg, _repo_separator, metadata['repository']))
+		cpv_slot_list = [pkg]
 		for atom, pkgkeywords in pkgdict.items():
 			if match_from_list(atom, cpv_slot_list):
 				matches = True
diff --git a/pym/portage/tests/dep/test_dep_getrepo.py b/pym/portage/tests/dep/test_dep_getrepo.py
new file mode 100644
index 000000000..214e61f06
--- /dev/null
+++ b/pym/portage/tests/dep/test_dep_getrepo.py
@@ -0,0 +1,30 @@
+# test_dep_getslot.py -- Portage Unit Testing Functionality
+# Copyright 2006 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.dep import dep_getrepo
+
+class DepGetRepo(TestCase):
+	""" A simple testcase for isvalidatom
+	"""
+
+	def testDepGetRepo(self):
+
+		repo_char = "::"
+		repos = ( "a", "repo-name", "repo_name", "repo123", None )
+		cpvs = ["sys-apps/portage"]
+		versions = ["2.1.1","2.1-r1", None]
+		uses = ["[use]", None]
+		for cpv in cpvs:
+			for version in versions:
+				for use in uses:
+					for repo in repos:
+						pkg = cpv
+						if version:
+							pkg = '=' + pkg + '-' + version
+						if repo is not None:
+							pkg = pkg + repo_char + repo
+						if use:
+							pkg = pkg + use
+						self.assertEqual( dep_getrepo( pkg ), repo )
diff --git a/pym/portage/tests/resolver/ResolverPlayground.py b/pym/portage/tests/resolver/ResolverPlayground.py
index be1c29470..8d6441c8c 100644
--- a/pym/portage/tests/resolver/ResolverPlayground.py
+++ b/pym/portage/tests/resolver/ResolverPlayground.py
@@ -373,9 +373,16 @@ class ResolverPlayground(object):
 		f.close()
 
 	def _load_config(self):
+		portdir_overlay = []
+		for repo_name in sorted(self.repo_dirs):
+			path = self.repo_dirs[repo_name]
+			if path != self.portdir:
+				portdir_overlay.append(path)
+
 		env = {
 			"ACCEPT_KEYWORDS": "x86",
 			"PORTDIR": self.portdir,
+			"PORTDIR_OVERLAY": " ".join(portdir_overlay),
 			'PORTAGE_TMPDIR'       : os.path.join(self.eroot, 'var/tmp'),
 		}
 
diff --git a/pym/portage/tests/resolver/test_multirepo.py b/pym/portage/tests/resolver/test_multirepo.py
new file mode 100644
index 000000000..c3a45e904
--- /dev/null
+++ b/pym/portage/tests/resolver/test_multirepo.py
@@ -0,0 +1,248 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.tests.resolver.ResolverPlayground import ResolverPlayground, ResolverPlaygroundTestCase
+
+class MultirepoTestCase(TestCase):
+
+	def testMultirepo(self):
+		ebuilds = {
+			#Simple repo selection
+			"dev-libs/A-1": { },
+			"dev-libs/A-1::repo1": { },
+			"dev-libs/A-2::repo1": { },
+			"dev-libs/A-1::repo2": { },
+
+			#Packges in exactly one repo
+			"dev-libs/B-1": { },
+			"dev-libs/C-1::repo1": { },
+
+			#Package in repository 1 and 2, but 1 must be used
+			"dev-libs/D-1::repo1": { },
+			"dev-libs/D-1::repo2": { },
+
+			"dev-libs/E-1": { },
+			"dev-libs/E-1::repo1": { },
+			"dev-libs/E-1::repo2": { "SLOT": "1" },
+
+			"dev-libs/F-1::repo1": { "SLOT": "1" },
+			"dev-libs/F-1::repo2": { "SLOT": "1" },
+			}
+		
+		sets = {
+			"multirepotest": 
+				( "dev-libs/A::test_repo", )
+		}
+
+		test_cases = (
+			#Simple repo selection
+			ResolverPlaygroundTestCase(
+				["dev-libs/A"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/A-2::repo1"]),
+			ResolverPlaygroundTestCase(
+				["dev-libs/A::test_repo"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/A-1"]),
+			ResolverPlaygroundTestCase(
+				["dev-libs/A::repo2"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/A-1::repo2"]),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/A-1::repo1"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/A-1::repo1"]),
+			ResolverPlaygroundTestCase(
+				["@multirepotest"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/A-1"]),
+
+			#Packges in exactly one repo
+			ResolverPlaygroundTestCase(
+				["dev-libs/B"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/B-1"]),
+			ResolverPlaygroundTestCase(
+				["dev-libs/C"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/C-1::repo1"]),
+
+			#Package in repository 1 and 2, but 1 must be used
+			ResolverPlaygroundTestCase(
+				["dev-libs/D"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/D-1::repo1"]),
+
+			#Atoms with slots
+			ResolverPlaygroundTestCase(
+				["dev-libs/E"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/E-1::repo1"]),
+			ResolverPlaygroundTestCase(
+				["dev-libs/E:1::repo2"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/E-1::repo2"]),
+			#FAIL
+			#~ ResolverPlaygroundTestCase(
+				#~ ["dev-libs/E:1"],
+				#~ success = True,
+				#~ check_repo_names = True,
+				#~ mergelist = ["dev-libs/E-1::repo2"]),
+			ResolverPlaygroundTestCase(
+				["dev-libs/F:1"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/F-1::repo1"]),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/F-1:1"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/F-1::repo1"]),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/F-1:1::repo2"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/F-1::repo2"]),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, sets=sets)
+		try:
+			for test_case in test_cases:
+				playground.run_TestCase(test_case)
+				self.assertEqual(test_case.test_success, True, test_case.fail_msg)
+		finally:
+			playground.cleanup()
+
+
+	def testMultirepoUserConfig(self):
+		ebuilds = {
+			#package.use test
+			"dev-libs/A-1": { "IUSE": "foo" },
+			"dev-libs/A-2::repo1": { "IUSE": "foo" },
+			"dev-libs/A-3::repo2": { },
+			"dev-libs/B-1": { "DEPEND": "dev-libs/A", "EAPI": 2 },
+			"dev-libs/B-2": { "DEPEND": "dev-libs/A[foo]", "EAPI": 2 },
+			"dev-libs/B-3": { "DEPEND": "dev-libs/A[-foo]", "EAPI": 2 },
+
+			#package.keywords test
+			"dev-libs/C-1": { "KEYWORDS": "~x86" },
+			"dev-libs/C-1::repo1": { "KEYWORDS": "~x86" },
+
+			#package.license
+			"dev-libs/D-1": { "LICENSE": "TEST" },
+			"dev-libs/D-1::repo1": { "LICENSE": "TEST" },
+
+			#package.mask
+			"dev-libs/E-1": { },
+			"dev-libs/E-1::repo1": { },
+
+			#package.properties
+			"dev-libs/F-1": { "PROPERTIES": "bar"},
+			"dev-libs/F-1::repo1": { "PROPERTIES": "bar"},
+
+			#package.unmask
+			"dev-libs/G-1": { },
+			"dev-libs/G-1::repo1": { },
+			}
+
+		user_config = {
+			"package.use":
+				(
+					"dev-libs/A::repo1 foo",
+				),
+			"package.keywords":
+				(
+					"=dev-libs/C-1::test_repo",
+				),
+			"package.license":
+				(
+					"=dev-libs/D-1::test_repo TEST",
+				),
+			"package.mask":
+				(
+					"dev-libs/E::repo1",
+					#needed for package.unmask test
+					"dev-libs/G",
+				),
+			"package.properties":
+				(
+					"dev-libs/F::repo1 -bar",
+				),
+			"package.unmask":
+				(
+					"dev-libs/G::test_repo",
+				),
+			}
+
+		test_cases = (
+			#package.use test
+			ResolverPlaygroundTestCase(
+				["=dev-libs/B-1"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/A-3::repo2", "dev-libs/B-1"]),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/B-2"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/A-2::repo1", "dev-libs/B-2"]),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/B-3"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/A-1", "dev-libs/B-3"]),
+
+			#package.keywords test
+			ResolverPlaygroundTestCase(
+				["dev-libs/C"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/C-1"]),
+
+			#package.license test
+			ResolverPlaygroundTestCase(
+				["dev-libs/D"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/D-1"]),
+
+			#package.mask test
+			ResolverPlaygroundTestCase(
+				["dev-libs/E"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/E-1"]),
+
+			#package.properties test
+			ResolverPlaygroundTestCase(
+				["dev-libs/F"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/F-1"]),
+
+			#package.mask test
+			ResolverPlaygroundTestCase(
+				["dev-libs/G"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/G-1"]),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, user_config=user_config)
+		try:
+			for test_case in test_cases:
+				playground.run_TestCase(test_case)
+				self.assertEqual(test_case.test_success, True, test_case.fail_msg)
+		finally:
+			playground.cleanup()