add a patched version of portage

119 files changed, 7919 insertions, 0 deletions

diff --git a/portage_with_autodep/pym/portage/tests/__init__.py b/portage_with_autodep/pym/portage/tests/__init__.py
new file mode 100644
index 0000000..a647aa2
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/__init__.py
@@ -0,0 +1,244 @@
+# tests/__init__.py -- Portage Unit Test functionality
+# Copyright 2006-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import sys
+import time
+import unittest
+
+try:
+	from unittest.runner import _TextTestResult # new in python-2.7
+except ImportError:
+	from unittest import _TextTestResult
+
+from portage import os
+from portage import _encodings
+from portage import _unicode_decode
+
+def main():
+
+	TEST_FILE = b'__test__'
+	svn_dirname = b'.svn'
+	suite = unittest.TestSuite()
+	basedir = os.path.dirname(os.path.realpath(__file__))
+	testDirs = []
+
+	if len(sys.argv) > 1:
+		suite.addTests(getTestFromCommandLine(sys.argv[1:], basedir))
+		return TextTestRunner(verbosity=2).run(suite)
+
+  # the os.walk help mentions relative paths as being quirky
+	# I was tired of adding dirs to the list, so now we add __test__
+	# to each dir we want tested.
+	for root, dirs, files in os.walk(basedir):
+		if svn_dirname in dirs:
+			dirs.remove(svn_dirname)
+		try:
+			root = _unicode_decode(root,
+				encoding=_encodings['fs'], errors='strict')
+		except UnicodeDecodeError:
+			continue
+
+		if TEST_FILE in files:
+			testDirs.append(root)
+
+	for mydir in testDirs:
+		suite.addTests(getTests(os.path.join(basedir, mydir), basedir) )
+	return TextTestRunner(verbosity=2).run(suite)
+
+def my_import(name):
+	mod = __import__(name)
+	components = name.split('.')
+	for comp in components[1:]:
+		mod = getattr(mod, comp)
+	return mod
+
+def getTestFromCommandLine(args, base_path):
+	ret = []
+	for arg in args:
+		realpath = os.path.realpath(arg)
+		path = os.path.dirname(realpath)
+		f = realpath[len(path)+1:]
+
+		if not f.startswith("test") or not f.endswith(".py"):
+			raise Exception("Invalid argument: '%s'" % arg)
+
+		mymodule = f[:-3]
+
+		parent_path = path[len(base_path)+1:]
+		parent_module = ".".join(("portage", "tests", parent_path))
+		parent_module = parent_module.replace('/', '.')
+		result = []
+
+		# Make the trailing / a . for module importing
+		modname = ".".join((parent_module, mymodule))
+		mod = my_import(modname)
+		ret.append(unittest.TestLoader().loadTestsFromModule(mod))
+	return ret
+
+def getTests(path, base_path):
+	"""
+
+	path is the path to a given subdir ( 'portage/' for example)
+	This does a simple filter on files in that dir to give us modules
+	to import
+
+	"""
+	files = os.listdir(path)
+	files = [ f[:-3] for f in files if f.startswith("test") and f.endswith(".py") ]
+	parent_path = path[len(base_path)+1:]
+	parent_module = ".".join(("portage", "tests", parent_path))
+	parent_module = parent_module.replace('/', '.')
+	result = []
+	for mymodule in files:
+		# Make the trailing / a . for module importing
+		modname = ".".join((parent_module, mymodule))
+		mod = my_import(modname)
+		result.append(unittest.TestLoader().loadTestsFromModule(mod))
+	return result
+
+class TextTestResult(_TextTestResult):
+	"""
+	We need a subclass of unittest._TextTestResult to handle tests with TODO
+
+	This just adds an addTodo method that can be used to add tests
+	that are marked TODO; these can be displayed later
+	by the test runner.
+	"""
+
+	def __init__(self, stream, descriptions, verbosity):
+		super(TextTestResult, self).__init__(stream, descriptions, verbosity)
+		self.todoed = []
+
+	def addTodo(self, test, info):
+		self.todoed.append((test,info))
+		if self.showAll:
+			self.stream.writeln("TODO")
+		elif self.dots:
+			self.stream.write(".")
+
+	def printErrors(self):
+		if self.dots or self.showAll:
+			self.stream.writeln()
+			self.printErrorList('ERROR', self.errors)
+			self.printErrorList('FAIL', self.failures)
+			self.printErrorList('TODO', self.todoed)
+
+class TestCase(unittest.TestCase):
+	"""
+	We need a way to mark a unit test as "ok to fail"
+	This way someone can add a broken test and mark it as failed
+	and then fix the code later.  This may not be a great approach
+	(broken code!!??!11oneone) but it does happen at times.
+	"""
+	
+	def __init__(self, methodName='runTest'):
+		# This method exists because unittest.py in python 2.4 stores
+		# the methodName as __testMethodName while 2.5 uses
+		# _testMethodName.
+		self._testMethodName = methodName
+		unittest.TestCase.__init__(self, methodName)
+		self.todo = False
+		
+	def defaultTestResult(self):
+		return TextTestResult()
+
+	def run(self, result=None):
+		if result is None: result = self.defaultTestResult()
+		result.startTest(self)
+		testMethod = getattr(self, self._testMethodName)
+		try:
+			try:
+				self.setUp()
+			except SystemExit:
+				raise
+			except KeyboardInterrupt:
+				raise
+			except:
+				result.addError(self, sys.exc_info())
+				return
+			ok = False
+			try:
+				testMethod()
+				ok = True
+			except self.failureException:
+				if self.todo:
+					result.addTodo(self,"%s: TODO" % testMethod)
+				else:
+					result.addFailure(self, sys.exc_info())
+			except (KeyboardInterrupt, SystemExit):
+				raise
+			except:
+				result.addError(self, sys.exc_info())
+			try:
+				self.tearDown()
+			except SystemExit:
+				raise
+			except KeyboardInterrupt:
+				raise
+			except:
+				result.addError(self, sys.exc_info())
+				ok = False
+			if ok: result.addSuccess(self)
+		finally:
+			result.stopTest(self)
+
+	def assertRaisesMsg(self, msg, excClass, callableObj, *args, **kwargs):
+		"""Fail unless an exception of class excClass is thrown
+		   by callableObj when invoked with arguments args and keyword
+		   arguments kwargs. If a different type of exception is
+		   thrown, it will not be caught, and the test case will be
+		   deemed to have suffered an error, exactly as for an
+		   unexpected exception.
+		"""
+		try:
+		    callableObj(*args, **kwargs)
+		except excClass:
+		    return
+		else:
+		    if hasattr(excClass,'__name__'): excName = excClass.__name__
+		    else: excName = str(excClass)
+		    raise self.failureException("%s not raised: %s" % (excName, msg))
+			
+class TextTestRunner(unittest.TextTestRunner):
+	"""
+	We subclass unittest.TextTestRunner to output SKIP for tests that fail but are skippable
+	"""
+	
+	def _makeResult(self):
+	        return TextTestResult(self.stream, self.descriptions, self.verbosity)
+
+	def run(self, test):
+		"""
+		Run the given test case or test suite.
+		"""
+		result = self._makeResult()
+		startTime = time.time()
+		test(result)
+		stopTime = time.time()
+		timeTaken = stopTime - startTime
+		result.printErrors()
+		self.stream.writeln(result.separator2)
+		run = result.testsRun
+		self.stream.writeln("Ran %d test%s in %.3fs" %
+							(run, run != 1 and "s" or "", timeTaken))
+		self.stream.writeln()
+		if not result.wasSuccessful():
+			self.stream.write("FAILED (")
+			failed = len(result.failures)
+			errored = len(result.errors)
+			if failed:
+				self.stream.write("failures=%d" % failed)
+			if errored:
+				if failed: self.stream.write(", ")
+				self.stream.write("errors=%d" % errored)
+			self.stream.writeln(")")
+		else:
+			self.stream.writeln("OK")
+		return result
+	
+test_cps = ['sys-apps/portage','virtual/portage']
+test_versions = ['1.0', '1.0-r1','2.3_p4','1.0_alpha57']
+test_slots = [ None, '1','gentoo-sources-2.6.17','spankywashere']
+test_usedeps = ['foo','-bar', ('foo','bar'),
+	('foo','-bar'), ('foo?', '!bar?') ]
diff --git a/portage_with_autodep/pym/portage/tests/bin/__init__.py b/portage_with_autodep/pym/portage/tests/bin/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/bin/__init__.py
diff --git a/portage_with_autodep/pym/portage/tests/bin/__test__ b/portage_with_autodep/pym/portage/tests/bin/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/bin/__test__
diff --git a/portage_with_autodep/pym/portage/tests/bin/setup_env.py b/portage_with_autodep/pym/portage/tests/bin/setup_env.py
new file mode 100644
index 0000000..e07643d
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/bin/setup_env.py
@@ -0,0 +1,85 @@
+# setup_env.py -- Make sure bin subdir has sane env for testing
+# Copyright 2007-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import tempfile
+
+from portage import os
+from portage import shutil
+from portage.tests import TestCase
+from portage.process import spawn
+
+basepath = os.path.join(os.path.dirname(os.path.dirname(
+	os.path.abspath(__file__))),
+	"..", "..", "..")
+bindir = os.path.join(basepath, "bin")
+pymdir = os.path.join(basepath, "pym")
+basedir = None
+env = None
+
+def binTestsCleanup():
+	global basedir
+	if basedir is None:
+		return
+	if os.access(basedir, os.W_OK):
+		shutil.rmtree(basedir)
+		basedir = None
+
+def binTestsInit():
+	binTestsCleanup()
+	global basedir, env
+	basedir = tempfile.mkdtemp()
+	env = os.environ.copy()
+	env["D"] = os.path.join(basedir, "image")
+	env["T"] = os.path.join(basedir, "temp")
+	env["S"] = os.path.join(basedir, "workdir")
+	env["PF"] = "portage-tests-0.09-r1"
+	env["PATH"] = bindir + ":" + env["PATH"]
+	env["PORTAGE_BIN_PATH"] = bindir
+	env["PORTAGE_PYM_PATH"] = pymdir
+	os.mkdir(env["D"])
+	os.mkdir(env["T"])
+	os.mkdir(env["S"])
+
+class BinTestCase(TestCase):
+	def init(self):
+		binTestsInit()
+	def cleanup(self):
+		binTestsCleanup()
+
+def _exists_in_D(path):
+	# Note: do not use os.path.join() here, we assume D to end in /
+	return os.access(env["D"] + path, os.W_OK)
+def exists_in_D(path):
+	if not _exists_in_D(path):
+		raise TestCase.failureException
+def xexists_in_D(path):
+	if _exists_in_D(path):
+		raise TestCase.failureException
+
+def portage_func(func, args, exit_status=0):
+	# we don't care about the output of the programs,
+	# just their exit value and the state of $D
+	global env
+	f = open('/dev/null', 'wb')
+	fd_pipes = {0:0,1:f.fileno(),2:f.fileno()}
+	def pre_exec():
+		os.chdir(env["S"])
+	spawn([func] + args.split(), env=env,
+		fd_pipes=fd_pipes, pre_exec=pre_exec)
+	f.close()
+
+def create_portage_wrapper(bin):
+	def derived_func(*args):
+		newargs = list(args)
+		newargs.insert(0, bin)
+		return portage_func(*newargs)
+	return derived_func
+
+for bin in os.listdir(os.path.join(bindir, "ebuild-helpers")):
+	if bin.startswith("do") or \
+	   bin.startswith("new") or \
+	   bin.startswith("prep") or \
+	   bin in ["ecompress","ecompressdir","fowners","fperms"]:
+		globals()[bin] = create_portage_wrapper(
+			os.path.join(bindir, "ebuild-helpers", bin))
diff --git a/portage_with_autodep/pym/portage/tests/bin/test_dobin.py b/portage_with_autodep/pym/portage/tests/bin/test_dobin.py
new file mode 100644
index 0000000..6f50d7a
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/bin/test_dobin.py
@@ -0,0 +1,16 @@
+# test_dobin.py -- Portage Unit Testing Functionality
+# Copyright 2007-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests.bin.setup_env import BinTestCase, dobin, xexists_in_D
+
+class DoBin(BinTestCase):
+	def testDoBin(self):
+		self.init()
+		try:
+			dobin("does-not-exist", 1)
+			xexists_in_D("does-not-exist")
+			xexists_in_D("/bin/does-not-exist")
+			xexists_in_D("/usr/bin/does-not-exist")
+		finally:
+			self.cleanup()
diff --git a/portage_with_autodep/pym/portage/tests/bin/test_dodir.py b/portage_with_autodep/pym/portage/tests/bin/test_dodir.py
new file mode 100644
index 0000000..f4eb9b2
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/bin/test_dodir.py
@@ -0,0 +1,16 @@
+# test_dodir.py -- Portage Unit Testing Functionality
+# Copyright 2007-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests.bin.setup_env import BinTestCase, dodir, exists_in_D
+
+class DoDir(BinTestCase):
+	def testDoDir(self):
+		self.init()
+		try:
+			dodir("usr /usr")
+			exists_in_D("/usr")
+			dodir("/var/lib/moocow")
+			exists_in_D("/var/lib/moocow")
+		finally:
+			self.cleanup()
diff --git a/portage_with_autodep/pym/portage/tests/dbapi/__init__.py b/portage_with_autodep/pym/portage/tests/dbapi/__init__.py
new file mode 100644
index 0000000..532918b
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dbapi/__init__.py
@@ -0,0 +1,2 @@
+# Copyright 2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
diff --git a/portage_with_autodep/pym/portage/tests/dbapi/__test__ b/portage_with_autodep/pym/portage/tests/dbapi/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dbapi/__test__
diff --git a/portage_with_autodep/pym/portage/tests/dbapi/test_fakedbapi.py b/portage_with_autodep/pym/portage/tests/dbapi/test_fakedbapi.py
new file mode 100644
index 0000000..a2c5f77
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dbapi/test_fakedbapi.py
@@ -0,0 +1,58 @@
+# Copyright 2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import shutil
+import tempfile
+
+from portage import os
+from portage.dbapi.virtual import fakedbapi
+from portage.package.ebuild.config import config
+from portage.tests import TestCase
+
+class TestFakedbapi(TestCase):
+
+	def testFakedbapi(self):
+		packages = (
+			("sys-apps/portage-2.1.10", {
+				"EAPI"         : "2",
+				"IUSE"         : "ipc doc",
+				"repository"   : "gentoo",
+				"SLOT"         : "0",
+				"USE"          : "ipc missing-iuse",
+			}),
+			("virtual/package-manager-0", {
+				"EAPI"         : "0",
+				"repository"   : "gentoo",
+				"SLOT"         : "0",
+			}),
+		)
+
+		match_tests = (
+			("sys-apps/portage:0[ipc]",             ["sys-apps/portage-2.1.10"]),
+			("sys-apps/portage:0[-ipc]",            []),
+			("sys-apps/portage:0[doc]",             []),
+			("sys-apps/portage:0[-doc]",            ["sys-apps/portage-2.1.10"]),
+			("sys-apps/portage:0",                  ["sys-apps/portage-2.1.10"]),
+			("sys-apps/portage:0[missing-iuse]",    []),
+			("sys-apps/portage:0[-missing-iuse]",   []),
+			("sys-apps/portage:0::gentoo[ipc]",     ["sys-apps/portage-2.1.10"]),
+			("sys-apps/portage:0::multilib[ipc]",   []),
+			("virtual/package-manager",             ["virtual/package-manager-0"]),
+		)
+
+		tempdir = tempfile.mkdtemp()
+		try:
+			portdir = os.path.join(tempdir, "usr/portage")
+			os.makedirs(portdir)
+			env = {
+				"PORTDIR": portdir,
+			}
+			fakedb = fakedbapi(settings=config(config_profile_path="",
+				env=env, _eprefix=tempdir))
+			for cpv, metadata in packages:
+				fakedb.cpv_inject(cpv, metadata=metadata)
+
+			for atom, expected_result in match_tests:
+				self.assertEqual( fakedb.match(atom), expected_result )
+		finally:
+			shutil.rmtree(tempdir)
diff --git a/portage_with_autodep/pym/portage/tests/dep/__init__.py b/portage_with_autodep/pym/portage/tests/dep/__init__.py
new file mode 100644
index 0000000..9c3f524
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/__init__.py
@@ -0,0 +1,3 @@
+# tests/portage.dep/__init__.py -- Portage Unit Test functionality
+# Copyright 2006 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
diff --git a/portage_with_autodep/pym/portage/tests/dep/__test__ b/portage_with_autodep/pym/portage/tests/dep/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/__test__
diff --git a/portage_with_autodep/pym/portage/tests/dep/testAtom.py b/portage_with_autodep/pym/portage/tests/dep/testAtom.py
new file mode 100644
index 0000000..092cacf
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/testAtom.py
@@ -0,0 +1,315 @@
+# Copyright 2006, 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.dep import Atom
+from portage.exception import InvalidAtom
+
+class TestAtom(TestCase):
+
+	def testAtom(self):
+
+		tests = (
+			( "=sys-apps/portage-2.1-r1:0[doc,a=,!b=,c?,!d?,-e]",
+				('=',  'sys-apps/portage', '2.1-r1', '0', '[doc,a=,!b=,c?,!d?,-e]', None), False, False ),
+			( "=sys-apps/portage-2.1-r1*:0[doc]",
+				('=*',  'sys-apps/portage', '2.1-r1', '0', '[doc]', None), False, False ),
+			( "sys-apps/portage:0[doc]",
+				(None,  'sys-apps/portage', None, '0', '[doc]', None), False, False ),
+			( "sys-apps/portage:0[doc]",
+				(None,  'sys-apps/portage', None, '0', '[doc]', None), False, False ),
+			( "*/*",
+				(None,  '*/*', None, None, None, None), True, False ),
+			( "sys-apps/*",
+				(None,  'sys-apps/*', None, None, None, None), True, False ),
+			( "*/portage",
+				(None,  '*/portage', None, None, None, None), True, False ),
+			( "s*s-*/portage:1",
+				(None,  's*s-*/portage', None, '1', None, None), True, False ),
+			( "*/po*ge:2",
+				(None,  '*/po*ge', None, '2', None, None), True, False ),
+			( "!dev-libs/A",
+				(None,  'dev-libs/A', None, None, None, None), True, True ),
+			( "!!dev-libs/A",
+				(None,  'dev-libs/A', None, None, None, None), True, True ),
+			( "!!dev-libs/A",
+				(None,  'dev-libs/A', None, None, None, None), True, True ),
+			( "dev-libs/A[foo(+)]",
+				(None,  'dev-libs/A', None, None, "[foo(+)]", None), True, True ),
+			( "dev-libs/A[a(+),b(-)=,!c(+)=,d(-)?,!e(+)?,-f(-)]",
+				(None,  'dev-libs/A', None, None, "[a(+),b(-)=,!c(+)=,d(-)?,!e(+)?,-f(-)]", None), True, True ),
+			( "dev-libs/A:2[a(+),b(-)=,!c(+)=,d(-)?,!e(+)?,-f(-)]",
+				(None,  'dev-libs/A', None, "2", "[a(+),b(-)=,!c(+)=,d(-)?,!e(+)?,-f(-)]", None), True, True ),
+
+			( "=sys-apps/portage-2.1-r1:0::repo_name[doc,a=,!b=,c?,!d?,-e]",
+				('=',  'sys-apps/portage', '2.1-r1', '0', '[doc,a=,!b=,c?,!d?,-e]', 'repo_name'), False, True ),
+			( "=sys-apps/portage-2.1-r1*:0::repo_name[doc]",
+				('=*',  'sys-apps/portage', '2.1-r1', '0', '[doc]', 'repo_name'), False, True ),
+			( "sys-apps/portage:0::repo_name[doc]",
+				(None,  'sys-apps/portage', None, '0', '[doc]', 'repo_name'), False, True ),
+
+			( "*/*::repo_name",
+				(None,  '*/*', None, None, None, 'repo_name'), True, True ),
+			( "sys-apps/*::repo_name",
+				(None,  'sys-apps/*', None, None, None, 'repo_name'), True, True ),
+			( "*/portage::repo_name",
+				(None,  '*/portage', None, None, None, 'repo_name'), True, True ),
+			( "s*s-*/portage:1::repo_name",
+				(None,  's*s-*/portage', None, '1', None, 'repo_name'), True, True ),
+		)
+		
+		tests_xfail = (
+			( Atom("sys-apps/portage"), False, False ),
+			( "cat/pkg[a!]", False, False ),
+			( "cat/pkg[!a]", False, False ),
+			( "cat/pkg[!a!]", False, False ),
+			( "cat/pkg[!a-]", False, False ),
+			( "cat/pkg[-a=]", False, False ),
+			( "cat/pkg[-a?]", False, False ),
+			( "cat/pkg[-a!]", False, False ),
+			( "cat/pkg[=a]", False, False ),
+			( "cat/pkg[=a=]", False, False ),
+			( "cat/pkg[=a?]", False, False ),
+			( "cat/pkg[=a!]", False, False ),
+			( "cat/pkg[=a-]", False, False ),
+			( "cat/pkg[?a]", False, False ),
+			( "cat/pkg[?a=]", False, False ),
+			( "cat/pkg[?a?]", False, False ),
+			( "cat/pkg[?a!]", False, False ),
+			( "cat/pkg[?a-]", False, False ),
+			( "sys-apps/portage[doc]:0", False, False ),
+			( "*/*", False, False ),
+			( "sys-apps/*", False, False ),
+			( "*/portage", False, False ),
+			( "*/**", True, False ),
+			( "*/portage[use]", True, False ),
+			( "cat/pkg[a()]", False, False ),
+			( "cat/pkg[a(]", False, False ),
+			( "cat/pkg[a)]", False, False ),
+			( "cat/pkg[a(,b]", False, False ),
+			( "cat/pkg[a),b]", False, False ),
+			( "cat/pkg[a(*)]", False, False ),
+			( "cat/pkg[a(*)]", True, False ),
+			( "cat/pkg[a(+-)]", False, False ),
+			( "cat/pkg[a()]", False, False ),
+			( "cat/pkg[(+)a]", False, False ),
+			( "cat/pkg[a=(+)]", False, False ),
+			( "cat/pkg[!(+)a=]", False, False ),
+			( "cat/pkg[!a=(+)]", False, False ),
+			( "cat/pkg[a?(+)]", False, False ),
+			( "cat/pkg[!a?(+)]", False, False ),
+			( "cat/pkg[!(+)a?]", False, False ),
+			( "cat/pkg[-(+)a]", False, False ),
+			( "cat/pkg[a(+),-a]", False, False ),
+			( "cat/pkg[a(-),-a]", False, False ),
+			( "cat/pkg[-a,a(+)]", False, False ),
+			( "cat/pkg[-a,a(-)]", False, False ),
+			( "cat/pkg[-a(+),a(-)]", False, False ),
+			( "cat/pkg[-a(-),a(+)]", False, False ),
+			( "sys-apps/portage[doc]::repo_name", False, False ),
+			( "sys-apps/portage:0[doc]::repo_name", False, False ),
+			( "sys-apps/portage[doc]:0::repo_name", False, False ),
+			( "=sys-apps/portage-2.1-r1:0::repo_name[doc,a=,!b=,c?,!d?,-e]", False, False ),
+			( "=sys-apps/portage-2.1-r1*:0::repo_name[doc]", False, False ),
+			( "sys-apps/portage:0::repo_name[doc]", False, False ),
+			( "*/*::repo_name", True, False ),
+		)
+
+		for atom, parts, allow_wildcard, allow_repo in tests:
+			a = Atom(atom, allow_wildcard=allow_wildcard, allow_repo=allow_repo)
+			op, cp, ver, slot, use, repo = parts
+			self.assertEqual( op, a.operator,
+				msg="Atom('%s').operator = %s == '%s'" % ( atom, a.operator, op ) )
+			self.assertEqual( cp, a.cp,
+				msg="Atom('%s').cp = %s == '%s'" % ( atom, a.cp, cp ) )
+			if ver is not None:
+				cpv = "%s-%s" % (cp, ver)
+			else:
+				cpv = cp
+			self.assertEqual( cpv, a.cpv,
+				msg="Atom('%s').cpv = %s == '%s'" % ( atom, a.cpv, cpv ) )
+			self.assertEqual( slot, a.slot,
+				msg="Atom('%s').slot = %s == '%s'" % ( atom, a.slot, slot ) )
+			self.assertEqual( repo, a.repo,
+				msg="Atom('%s').repo == %s == '%s'" % ( atom, a.repo, repo ) )
+
+			if a.use:
+				returned_use = str(a.use)
+			else:
+				returned_use = None
+			self.assertEqual( use, returned_use,
+				msg="Atom('%s').use = %s == '%s'" % ( atom, returned_use, use ) )
+
+		for atom, allow_wildcard, allow_repo in tests_xfail:
+			self.assertRaisesMsg(atom, (InvalidAtom, TypeError), Atom, atom, \
+				allow_wildcard=allow_wildcard, allow_repo=allow_repo)
+
+	def test_intersects(self):
+		test_cases = (
+			("dev-libs/A", "dev-libs/A", True),
+			("dev-libs/A", "dev-libs/B", False),
+			("dev-libs/A", "sci-libs/A", False),
+			("dev-libs/A[foo]", "sci-libs/A[bar]", False),
+			("dev-libs/A[foo(+)]", "sci-libs/A[foo(-)]", False),
+			("=dev-libs/A-1", "=dev-libs/A-1-r1", False),
+			("~dev-libs/A-1", "=dev-libs/A-1", False),
+			("=dev-libs/A-1:1", "=dev-libs/A-1", True),
+			("=dev-libs/A-1:1", "=dev-libs/A-1:1", True),
+			("=dev-libs/A-1:1", "=dev-libs/A-1:2", False),
+		)
+
+		for atom, other, expected_result in test_cases:
+			self.assertEqual(Atom(atom).intersects(Atom(other)), expected_result, \
+				"%s and %s should intersect: %s" % (atom, other, expected_result))
+
+	def test_violated_conditionals(self):
+		test_cases = (
+			("dev-libs/A", ["foo"], ["foo"], None, "dev-libs/A"),
+			("dev-libs/A[foo]", [], ["foo"], None, "dev-libs/A[foo]"),
+			("dev-libs/A[foo]", ["foo"], ["foo"], None, "dev-libs/A"),
+			("dev-libs/A[foo]", [], ["foo"], [], "dev-libs/A[foo]"),
+			("dev-libs/A[foo]", ["foo"], ["foo"], [], "dev-libs/A"),
+
+			("dev-libs/A:0[foo]", ["foo"], ["foo"], [], "dev-libs/A:0"),
+
+			("dev-libs/A[foo,-bar]", [], ["foo", "bar"], None, "dev-libs/A[foo]"),
+			("dev-libs/A[-foo,bar]", [], ["foo", "bar"], None, "dev-libs/A[bar]"),
+
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", [], ["a", "b", "c", "d", "e", "f"], [], "dev-libs/A[a,!c=]"),
+
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["a"], ["a", "b", "c", "d", "e", "f"], [], "dev-libs/A[!c=]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["b"], ["a", "b", "c", "d", "e", "f"], [], "dev-libs/A[a,b=,!c=]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["c"], ["a", "b", "c", "d", "e", "f"], [], "dev-libs/A[a]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["d"], ["a", "b", "c", "d", "e", "f"], [], "dev-libs/A[a,!c=]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["e"], ["a", "b", "c", "d", "e", "f"], [], "dev-libs/A[a,!c=,!e?]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["f"], ["a", "b", "c", "d", "e", "f"], [], "dev-libs/A[a,!c=,-f]"),
+
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["a"], ["a", "b", "c", "d", "e", "f"], ["a"], "dev-libs/A[!c=]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["b"], ["a", "b", "c", "d", "e", "f"], ["b"], "dev-libs/A[a,!c=]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["c"], ["a", "b", "c", "d", "e", "f"], ["c"], "dev-libs/A[a,!c=]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["d"], ["a", "b", "c", "d", "e", "f"], ["d"], "dev-libs/A[a,!c=]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["e"], ["a", "b", "c", "d", "e", "f"], ["e"], "dev-libs/A[a,!c=]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["f"], ["a", "b", "c", "d", "e", "f"], ["f"], "dev-libs/A[a,!c=,-f]"),
+
+			("dev-libs/A[a(+),b(-)=,!c(+)=,d(-)?,!e(+)?,-f(-)]", ["a"], ["a", "b", "c", "d", "e", "f"], ["a"], "dev-libs/A[!c(+)=]"),
+			("dev-libs/A[a(-),b(+)=,!c(-)=,d(+)?,!e(-)?,-f(+)]", ["b"], ["a", "b", "c", "d", "e", "f"], ["b"], "dev-libs/A[a(-),!c(-)=]"),
+			("dev-libs/A[a(+),b(-)=,!c(+)=,d(-)?,!e(+)?,-f(-)]", ["c"], ["a", "b", "c", "d", "e", "f"], ["c"], "dev-libs/A[a(+),!c(+)=]"),
+			("dev-libs/A[a(-),b(+)=,!c(-)=,d(+)?,!e(-)?,-f(+)]", ["d"], ["a", "b", "c", "d", "e", "f"], ["d"], "dev-libs/A[a(-),!c(-)=]"),
+			("dev-libs/A[a(+),b(-)=,!c(+)=,d(-)?,!e(+)?,-f(-)]", ["e"], ["a", "b", "c", "d", "e", "f"], ["e"], "dev-libs/A[a(+),!c(+)=]"),
+			("dev-libs/A[a(-),b(+)=,!c(-)=,d(+)?,!e(-)?,-f(+)]", ["f"], ["a", "b", "c", "d", "e", "f"], ["f"], "dev-libs/A[a(-),!c(-)=,-f(+)]"),
+
+			("dev-libs/A[a(+),b(+)=,!c(+)=,d(-)?,!e(+)?,-f(-)]", ["a"], ["a"], ["a"], "dev-libs/A[b(+)=,!e(+)?]"),
+			("dev-libs/A[a(-),b(+)=,!c(-)=,d(+)?,!e(-)?,-f(+)]", ["b"], ["b"], ["b"], "dev-libs/A[a(-),!c(-)=,-f(+)]"),
+			("dev-libs/A[a(+),b(-)=,!c(+)=,d(-)?,!e(+)?,-f(-)]", ["c"], ["c"], ["c"], "dev-libs/A[!c(+)=,!e(+)?]"),
+			("dev-libs/A[a(-),b(+)=,!c(-)=,d(+)?,!e(-)?,-f(+)]", ["d"], ["d"], ["d"], "dev-libs/A[a(-),b(+)=,!c(-)=,-f(+)]"),
+			("dev-libs/A[a(+),b(-)=,!c(+)=,d(-)?,!e(+)?,-f(-)]", ["e"], ["e"], ["e"], "dev-libs/A"),
+			("dev-libs/A[a(-),b(+)=,!c(-)=,d(+)?,!e(-)?,-f(+)]", ["f"], ["f"], ["f"], "dev-libs/A[a(-),b(+)=,!c(-)=,-f(+)]"),
+
+			#Some more test cases to trigger all remaining code paths
+			("dev-libs/B[x?]", [], ["x"], ["x"], "dev-libs/B[x?]"),
+			("dev-libs/B[x(+)?]", [], [], ["x"], "dev-libs/B"),
+			("dev-libs/B[x(-)?]", [], [], ["x"], "dev-libs/B[x(-)?]"),
+
+			("dev-libs/C[x=]", [], ["x"], ["x"], "dev-libs/C[x=]"),
+			("dev-libs/C[x(+)=]", [], [], ["x"], "dev-libs/C"),
+			("dev-libs/C[x(-)=]", [], [], ["x"], "dev-libs/C[x(-)=]"),
+
+			("dev-libs/D[!x=]", [], ["x"], ["x"], "dev-libs/D"),
+			("dev-libs/D[!x(+)=]", [], [], ["x"], "dev-libs/D[!x(+)=]"),
+			("dev-libs/D[!x(-)=]", [], [], ["x"], "dev-libs/D"),
+
+			#Missing IUSE test cases
+			("dev-libs/B[x]", [], [], [], "dev-libs/B[x]"),
+			("dev-libs/B[-x]", [], [], [], "dev-libs/B[-x]"),
+			("dev-libs/B[x?]", [], [], [], "dev-libs/B[x?]"),
+			("dev-libs/B[x=]", [], [], [], "dev-libs/B[x=]"),
+			("dev-libs/B[!x=]", [], [], ["x"], "dev-libs/B[!x=]"),
+			("dev-libs/B[!x?]", [], [], ["x"], "dev-libs/B[!x?]"),
+		)
+		
+		test_cases_xfail = (
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", [], ["a", "b", "c", "d", "e", "f"], None),
+		)
+
+		class use_flag_validator(object):
+			def __init__(self, iuse):
+				self.iuse = iuse
+
+			def is_valid_flag(self, flag):
+				return flag in iuse
+
+		for atom, other_use, iuse, parent_use, expected_violated_atom in test_cases:
+			a = Atom(atom)
+			validator = use_flag_validator(iuse)
+			violated_atom = a.violated_conditionals(other_use, validator.is_valid_flag, parent_use)
+			if parent_use is None:
+				fail_msg = "Atom: %s, other_use: %s, iuse: %s, parent_use: %s, got: %s, expected: %s" % \
+					(atom, " ".join(other_use), " ".join(iuse), "None", str(violated_atom), expected_violated_atom)
+			else:
+				fail_msg = "Atom: %s, other_use: %s, iuse: %s, parent_use: %s, got: %s, expected: %s" % \
+					(atom, " ".join(other_use), " ".join(iuse), " ".join(parent_use), str(violated_atom), expected_violated_atom)
+			self.assertEqual(str(violated_atom), expected_violated_atom, fail_msg)
+
+		for atom, other_use, iuse, parent_use in test_cases_xfail:
+			a = Atom(atom)
+			validator = use_flag_validator(iuse)
+			self.assertRaisesMsg(atom, InvalidAtom, \
+				a.violated_conditionals, other_use, validator.is_valid_flag, parent_use)
+
+	def test_evaluate_conditionals(self):
+		test_cases = (
+			("dev-libs/A[foo]", [], "dev-libs/A[foo]"),
+			("dev-libs/A[foo]", ["foo"], "dev-libs/A[foo]"),
+
+			("dev-libs/A:0[foo=]", ["foo"], "dev-libs/A:0[foo]"),
+
+			("dev-libs/A[foo,-bar]", [], "dev-libs/A[foo,-bar]"),
+			("dev-libs/A[-foo,bar]", [], "dev-libs/A[-foo,bar]"),
+
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", [], "dev-libs/A[a,-b,c,-e,-f]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["a"], "dev-libs/A[a,-b,c,-e,-f]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["b"], "dev-libs/A[a,b,c,-e,-f]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["c"], "dev-libs/A[a,-b,-c,-e,-f]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["d"], "dev-libs/A[a,-b,c,d,-e,-f]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["e"], "dev-libs/A[a,-b,c,-f]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["f"], "dev-libs/A[a,-b,c,-e,-f]"),
+			("dev-libs/A[a(-),b(+)=,!c(-)=,d(+)?,!e(-)?,-f(+)]", ["d"], "dev-libs/A[a(-),-b(+),c(-),d(+),-e(-),-f(+)]"),
+			("dev-libs/A[a(+),b(-)=,!c(+)=,d(-)?,!e(+)?,-f(-)]", ["f"], "dev-libs/A[a(+),-b(-),c(+),-e(+),-f(-)]"),
+		)
+
+		for atom, use, expected_atom in test_cases:
+			a = Atom(atom)
+			b = a.evaluate_conditionals(use)
+			self.assertEqual(str(b), expected_atom)
+			self.assertEqual(str(b.unevaluated_atom), atom)
+
+	def test__eval_qa_conditionals(self):
+		test_cases = (
+			("dev-libs/A[foo]", [], [], "dev-libs/A[foo]"),
+			("dev-libs/A[foo]", ["foo"], [], "dev-libs/A[foo]"),
+			("dev-libs/A[foo]", [], ["foo"], "dev-libs/A[foo]"),
+
+			("dev-libs/A:0[foo]", [], [], "dev-libs/A:0[foo]"),
+			("dev-libs/A:0[foo]", ["foo"], [], "dev-libs/A:0[foo]"),
+			("dev-libs/A:0[foo]", [], ["foo"], "dev-libs/A:0[foo]"),
+			("dev-libs/A:0[foo=]", [], ["foo"], "dev-libs/A:0[foo]"),
+
+			("dev-libs/A[foo,-bar]", ["foo"], ["bar"], "dev-libs/A[foo,-bar]"),
+			("dev-libs/A[-foo,bar]", ["foo", "bar"], [], "dev-libs/A[-foo,bar]"),
+
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["a", "b", "c"], [], "dev-libs/A[a,-b,c,d,-e,-f]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", [], ["a", "b", "c"], "dev-libs/A[a,b,-c,d,-e,-f]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", ["d", "e", "f"], [], "dev-libs/A[a,b,-b,c,-c,-e,-f]"),
+			("dev-libs/A[a,b=,!c=,d?,!e?,-f]", [], ["d", "e", "f"], "dev-libs/A[a,b,-b,c,-c,d,-f]"),
+			
+			("dev-libs/A[a(-),b(+)=,!c(-)=,d(+)?,!e(-)?,-f(+)]", \
+				["a", "b", "c", "d", "e", "f"], [], "dev-libs/A[a(-),-b(+),c(-),-e(-),-f(+)]"),
+			("dev-libs/A[a(+),b(-)=,!c(+)=,d(-)?,!e(+)?,-f(-)]", \
+				[], ["a", "b", "c", "d", "e", "f"], "dev-libs/A[a(+),b(-),-c(+),d(-),-f(-)]"),
+		)
+
+		for atom, use_mask, use_force, expected_atom in test_cases:
+			a = Atom(atom)
+			b = a._eval_qa_conditionals(use_mask, use_force)
+			self.assertEqual(str(b), expected_atom)
+			self.assertEqual(str(b.unevaluated_atom), atom)
diff --git a/portage_with_autodep/pym/portage/tests/dep/testCheckRequiredUse.py b/portage_with_autodep/pym/portage/tests/dep/testCheckRequiredUse.py
new file mode 100644
index 0000000..54791e0
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/testCheckRequiredUse.py
@@ -0,0 +1,219 @@
+# Copyright 2010-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.dep import check_required_use
+from portage.exception import InvalidDependString
+
+class TestCheckRequiredUse(TestCase):
+
+	def testCheckRequiredUse(self):
+		test_cases = (
+			( "|| ( a b )", [], ["a", "b"], False),
+			( "|| ( a b )", ["a"], ["a", "b"], True),
+			( "|| ( a b )", ["b"], ["a", "b"], True),
+			( "|| ( a b )", ["a", "b"], ["a", "b"], True),
+
+			( "^^ ( a b )", [], ["a", "b"], False),
+			( "^^ ( a b )", ["a"], ["a", "b"], True),
+			( "^^ ( a b )", ["b"], ["a", "b"], True),
+			( "^^ ( a b )", ["a", "b"], ["a", "b"], False),
+
+			( "^^ ( || ( a b ) c )", [], ["a", "b", "c"], False),
+			( "^^ ( || ( a b ) c )", ["a"], ["a", "b", "c"], True),
+
+			( "^^ ( || ( ( a b ) ) ( c ) )", [], ["a", "b", "c"], False),
+			( "( ^^ ( ( || ( ( a ) ( b ) ) ) ( ( c ) ) ) )", ["a"], ["a", "b", "c"], True),
+
+			( "a || ( b c )", ["a"], ["a", "b", "c"], False),
+			( "|| ( b c ) a", ["a"], ["a", "b", "c"], False),
+
+			( "|| ( a b c )", ["a"], ["a", "b", "c"], True),
+			( "|| ( a b c )", ["b"], ["a", "b", "c"], True),
+			( "|| ( a b c )", ["c"], ["a", "b", "c"], True),
+
+			( "^^ ( a b c )", ["a"], ["a", "b", "c"], True),
+			( "^^ ( a b c )", ["b"], ["a", "b", "c"], True),
+			( "^^ ( a b c )", ["c"], ["a", "b", "c"], True),
+			( "^^ ( a b c )", ["a", "b"], ["a", "b", "c"], False),
+			( "^^ ( a b c )", ["b", "c"], ["a", "b", "c"], False),
+			( "^^ ( a b c )", ["a", "c"], ["a", "b", "c"], False),
+			( "^^ ( a b c )", ["a", "b", "c"], ["a", "b", "c"], False),
+
+			( "a? ( ^^ ( b c ) )", [], ["a", "b", "c"], True),
+			( "a? ( ^^ ( b c ) )", ["a"], ["a", "b", "c"], False),
+			( "a? ( ^^ ( b c ) )", ["b"], ["a", "b", "c"], True),
+			( "a? ( ^^ ( b c ) )", ["c"], ["a", "b", "c"], True),
+			( "a? ( ^^ ( b c ) )", ["a", "b"], ["a", "b", "c"], True),
+			( "a? ( ^^ ( b c ) )", ["a", "b", "c"], ["a", "b", "c"], False),
+
+			( "^^ ( a? ( !b ) !c? ( d ) )", [], ["a", "b", "c", "d"], False),
+			( "^^ ( a? ( !b ) !c? ( d ) )", ["a"], ["a", "b", "c", "d"], True),
+			( "^^ ( a? ( !b ) !c? ( d ) )", ["c"], ["a", "b", "c", "d"], True),
+			( "^^ ( a? ( !b ) !c? ( d ) )", ["a", "c"], ["a", "b", "c", "d"], True),
+			( "^^ ( a? ( !b ) !c? ( d ) )", ["a", "b", "c"], ["a", "b", "c", "d"], False),
+			( "^^ ( a? ( !b ) !c? ( d ) )", ["a", "b", "d"], ["a", "b", "c", "d"], True),
+			( "^^ ( a? ( !b ) !c? ( d ) )", ["a", "b", "d"], ["a", "b", "c", "d"], True),
+			( "^^ ( a? ( !b ) !c? ( d ) )", ["a", "d"], ["a", "b", "c", "d"], False),
+
+			( "|| ( ^^ ( a b ) ^^ ( b c ) )", [], ["a", "b", "c"], False),
+			( "|| ( ^^ ( a b ) ^^ ( b c ) )", ["a"], ["a", "b", "c"], True),
+			( "|| ( ^^ ( a b ) ^^ ( b c ) )", ["b"], ["a", "b", "c"], True),
+			( "|| ( ^^ ( a b ) ^^ ( b c ) )", ["c"], ["a", "b", "c"], True),
+			( "|| ( ^^ ( a b ) ^^ ( b c ) )", ["a", "b"], ["a", "b", "c"], True),
+			( "|| ( ^^ ( a b ) ^^ ( b c ) )", ["a", "c"], ["a", "b", "c"], True),
+			( "|| ( ^^ ( a b ) ^^ ( b c ) )", ["b", "c"], ["a", "b", "c"], True),
+			( "|| ( ^^ ( a b ) ^^ ( b c ) )", ["a", "b", "c"], ["a", "b", "c"], False),
+
+			( "^^ ( || ( a b ) ^^ ( b c ) )", [], ["a", "b", "c"], False),
+			( "^^ ( || ( a b ) ^^ ( b c ) )", ["a"], ["a", "b", "c"], True),
+			( "^^ ( || ( a b ) ^^ ( b c ) )", ["b"], ["a", "b", "c"], False),
+			( "^^ ( || ( a b ) ^^ ( b c ) )", ["c"], ["a", "b", "c"], True),
+			( "^^ ( || ( a b ) ^^ ( b c ) )", ["a", "b"], ["a", "b", "c"], False),
+			( "^^ ( || ( a b ) ^^ ( b c ) )", ["a", "c"], ["a", "b", "c"], False),
+			( "^^ ( || ( a b ) ^^ ( b c ) )", ["b", "c"], ["a", "b", "c"], True),
+			( "^^ ( || ( a b ) ^^ ( b c ) )", ["a", "b", "c"], ["a", "b", "c"], True),
+
+			( "|| ( ( a b ) c )", ["a", "b", "c"], ["a", "b", "c"], True),
+			( "|| ( ( a b ) c )", ["b", "c"], ["a", "b", "c"], True),
+			( "|| ( ( a b ) c )", ["a", "c"], ["a", "b", "c"], True),
+			( "|| ( ( a b ) c )", ["a", "b"], ["a", "b", "c"], True),
+			( "|| ( ( a b ) c )", ["a"], ["a", "b", "c"], False),
+			( "|| ( ( a b ) c )", ["b"], ["a", "b", "c"], False),
+			( "|| ( ( a b ) c )", ["c"], ["a", "b", "c"], True),
+			( "|| ( ( a b ) c )", [], ["a", "b", "c"], False),
+
+			( "^^ ( ( a b ) c )", ["a", "b", "c"], ["a", "b", "c"], False),
+			( "^^ ( ( a b ) c )", ["b", "c"], ["a", "b", "c"], True),
+			( "^^ ( ( a b ) c )", ["a", "c"], ["a", "b", "c"], True),
+			( "^^ ( ( a b ) c )", ["a", "b"], ["a", "b", "c"], True),
+			( "^^ ( ( a b ) c )", ["a"], ["a", "b", "c"], False),
+			( "^^ ( ( a b ) c )", ["b"], ["a", "b", "c"], False),
+			( "^^ ( ( a b ) c )", ["c"], ["a", "b", "c"], True),
+			( "^^ ( ( a b ) c )", [], ["a", "b", "c"], False),
+		)
+
+		test_cases_xfail = (
+			( "^^ ( || ( a b ) ^^ ( b c ) )", [], ["a", "b"]),
+			( "^^ ( || ( a b ) ^^ ( b c )", [], ["a", "b", "c"]),
+			( "^^( || ( a b ) ^^ ( b c ) )", [], ["a", "b", "c"]),
+			( "^^ || ( a b ) ^^ ( b c )", [], ["a", "b", "c"]),
+			( "^^ ( ( || ) ( a b ) ^^ ( b c ) )", [], ["a", "b", "c"]),
+			( "^^ ( || ( a b ) ) ^^ ( b c ) )", [], ["a", "b", "c"]),
+		)
+
+		for required_use, use, iuse, expected in test_cases:
+			self.assertEqual(bool(check_required_use(required_use, use, iuse.__contains__)), \
+				expected, required_use + ", USE = " + " ".join(use))
+
+		for required_use, use, iuse in test_cases_xfail:
+			self.assertRaisesMsg(required_use + ", USE = " + " ".join(use), \
+				InvalidDependString, check_required_use, required_use, use, iuse.__contains__)
+
+	def testCheckRequiredUseFilterSatisfied(self):
+		"""
+		Test filtering of satisfied parts of REQUIRED_USE,
+		in order to reduce noise for bug #353234.
+		"""
+		test_cases = (
+			(
+				"bindist? ( !amr !faac !win32codecs ) cdio? ( !cdparanoia !cddb ) dvdnav? ( dvd )",
+				("cdio", "cdparanoia"),
+				"cdio? ( !cdparanoia )"
+			),
+			(
+				"|| ( !amr !faac !win32codecs ) cdio? ( !cdparanoia !cddb ) ^^ ( foo bar )",
+				["cdio", "cdparanoia", "foo"],
+				"cdio? ( !cdparanoia )"
+			),
+			(
+				"^^ ( || ( a b ) c )",
+				("a", "b", "c"),
+				"^^ ( || ( a b ) c )"
+			),
+			(
+				"^^ ( || ( ( a b ) ) ( c ) )",
+				("a", "b", "c"),
+				"^^ ( ( a b ) c )"
+			),
+			(
+				"a? ( ( c e ) ( b d ) )",
+				("a", "c", "e"),
+				"a? ( b d )"
+			),
+			(
+				"a? ( ( c e ) ( b d ) )",
+				("a", "b", "c", "e"),
+				"a? ( d )"
+			),
+			(
+				"a? ( ( c e ) ( c e b c d e c ) )",
+				("a", "c", "e"),
+				"a? ( b d )"
+			),
+			(
+				"^^ ( || ( a b ) ^^ ( b c ) )",
+				("a", "b"),
+				"^^ ( || ( a b ) ^^ ( b c ) )"
+			),
+			(
+				"^^ ( || ( a b ) ^^ ( b c ) )",
+				["a", "c"],
+				"^^ ( || ( a b ) ^^ ( b c ) )"
+			),
+			(
+				"^^ ( || ( a b ) ^^ ( b c ) )",
+				["b", "c"],
+				""
+			),
+			(
+				"^^ ( || ( a b ) ^^ ( b c ) )",
+				["a", "b", "c"],
+				""
+			),
+			(
+				"^^ ( ( a b c ) ( b c d ) )",
+				["a", "b", "c"],
+				""
+			),
+			(
+				"^^ ( ( a b c ) ( b c d ) )",
+				["a", "b", "c", "d"],
+				"^^ ( ( a b c ) ( b c d ) )"
+			),
+			(
+				"^^ ( ( a b c ) ( b c !d ) )",
+				["a", "b", "c"],
+				"^^ ( ( a b c ) ( b c !d ) )"
+			),
+			(
+				"^^ ( ( a b c ) ( b c !d ) )",
+				["a", "b", "c", "d"],
+				""
+			),
+			(
+				"( ( ( a ) ) ( ( ( b c ) ) ) )",
+				[""],
+				"a b c"
+			),
+			(
+				"|| ( ( ( ( a ) ) ( ( ( b c ) ) ) ) )",
+				[""],
+				"a b c"
+			),
+			(
+				"|| ( ( a ( ( ) ( ) ) ( ( ) ) ( b ( ) c ) ) )",
+				[""],
+				"a b c"
+			),
+			(
+				"|| ( ( a b c ) ) || ( ( d e f ) )",
+				[""],
+				"a b c d e f"
+			),
+		)
+		for required_use, use, expected in test_cases:
+			result = check_required_use(required_use, use, lambda k: True).tounicode()
+			self.assertEqual(result, expected,
+				"REQUIRED_USE = '%s', USE = '%s', '%s' != '%s'" % \
+				(required_use, " ".join(use), result, expected))
diff --git a/portage_with_autodep/pym/portage/tests/dep/testExtendedAtomDict.py b/portage_with_autodep/pym/portage/tests/dep/testExtendedAtomDict.py
new file mode 100644
index 0000000..69d092e
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/testExtendedAtomDict.py
@@ -0,0 +1,18 @@
+# test_isvalidatom.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 ExtendedAtomDict
+
+class TestExtendedAtomDict(TestCase):
+
+	def testExtendedAtomDict(self):
+		d = ExtendedAtomDict(dict)
+		d["*/*"] = { "test1": "x" }
+		d["dev-libs/*"] = { "test2": "y" }
+		d.setdefault("sys-apps/portage", {})["test3"] = "z"
+		self.assertEqual(d.get("dev-libs/A"), { "test1": "x", "test2": "y" })
+		self.assertEqual(d.get("sys-apps/portage"), { "test1": "x", "test3": "z" })
+		self.assertEqual(d["dev-libs/*"], { "test2": "y" })
+		self.assertEqual(d["sys-apps/portage"], {'test1': 'x', 'test3': 'z'})
diff --git a/portage_with_autodep/pym/portage/tests/dep/testExtractAffectingUSE.py b/portage_with_autodep/pym/portage/tests/dep/testExtractAffectingUSE.py
new file mode 100644
index 0000000..026a552
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/testExtractAffectingUSE.py
@@ -0,0 +1,75 @@
+# Copyright 2010-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.dep import extract_affecting_use
+from portage.exception import InvalidDependString
+
+class TestExtractAffectingUSE(TestCase):
+
+	def testExtractAffectingUSE(self):
+		test_cases = (
+			("a? ( A ) !b? ( B ) !c? ( C ) d? ( D )", "A", ("a",)),
+			("a? ( A ) !b? ( B ) !c? ( C ) d? ( D )", "B", ("b",)),
+			("a? ( A ) !b? ( B ) !c? ( C ) d? ( D )", "C", ("c",)),
+			("a? ( A ) !b? ( B ) !c? ( C ) d? ( D )", "D", ("d",)),
+			
+			("a? ( b? ( AB ) )", "AB", ("a", "b")),
+			("a? ( b? ( c? ( ABC ) ) )", "ABC", ("a", "b", "c")),
+
+			("a? ( A b? ( c? ( ABC ) AB ) )", "A", ("a",)),
+			("a? ( A b? ( c? ( ABC ) AB ) )", "AB", ("a", "b")),
+			("a? ( A b? ( c? ( ABC ) AB ) )", "ABC", ("a", "b", "c")),
+			("a? ( A b? ( c? ( ABC ) AB ) ) X", "X", []),
+			("X a? ( A b? ( c? ( ABC ) AB ) )", "X", []),
+
+			("ab? ( || ( A B ) )", "A", ("ab",)),
+			("!ab? ( || ( A B ) )", "B", ("ab",)),
+			("ab? ( || ( A || ( b? ( || ( B C ) ) ) ) )", "A", ("ab",)),
+			("ab? ( || ( A || ( b? ( || ( B C ) ) ) ) )", "B", ("ab", "b")),
+			("ab? ( || ( A || ( b? ( || ( B C ) ) ) ) )", "C", ("ab", "b")),
+
+			("( ab? ( || ( ( A ) || ( b? ( ( ( || ( B ( C ) ) ) ) ) ) ) ) )", "A", ("ab",)),
+			("( ab? ( || ( ( A ) || ( b? ( ( ( || ( B ( C ) ) ) ) ) ) ) ) )", "B", ("ab", "b")),
+			("( ab? ( || ( ( A ) || ( b? ( ( ( || ( B ( C ) ) ) ) ) ) ) ) )", "C", ("ab", "b")),
+
+			("a? ( A )", "B", []),
+
+			("a? ( || ( A B ) )", "B", ["a"]),
+
+			# test USE dep defaults for bug #363073
+			("a? ( >=dev-lang/php-5.2[pcre(+)] )", ">=dev-lang/php-5.2[pcre(+)]", ["a"]),
+		)
+
+		test_cases_xfail = (
+			("? ( A )", "A"),
+			("!? ( A )", "A"),
+			("( A", "A"),
+			("A )", "A"),
+			
+			("||( A B )", "A"),
+			("|| (A B )", "A"),
+			("|| ( A B)", "A"),
+			("|| ( A B", "A"),
+			("|| A B )", "A"),
+			("|| A B", "A"),
+			("|| ( A B ) )", "A"),
+			("|| || B C", "A"),
+			("|| ( A B || )", "A"),
+			("a? A", "A"),
+			("( || ( || || ( A ) foo? ( B ) ) )", "A"),
+			("( || ( || bar? ( A ) foo? ( B ) ) )", "A"),
+		)
+
+		for dep, atom, expected in test_cases:
+			expected = set(expected)
+			result = extract_affecting_use(dep, atom, eapi="0")
+			fail_msg = "dep: " + dep + ", atom: " + atom + ", got: " + \
+				" ".join(sorted(result)) + ", expected: " + " ".join(sorted(expected))
+			self.assertEqual(result, expected, fail_msg)
+
+		for dep, atom in test_cases_xfail:
+			fail_msg = "dep: " + dep + ", atom: " + atom + ", got: " + \
+				" ".join(sorted(result)) + ", expected: " + " ".join(sorted(expected))
+			self.assertRaisesMsg(fail_msg, \
+				InvalidDependString, extract_affecting_use, dep, atom, eapi="0")
diff --git a/portage_with_autodep/pym/portage/tests/dep/testStandalone.py b/portage_with_autodep/pym/portage/tests/dep/testStandalone.py
new file mode 100644
index 0000000..e9f01df
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/testStandalone.py
@@ -0,0 +1,36 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.dep import cpvequal
+from portage.exception import PortageException
+
+class TestStandalone(TestCase):
+	""" Test some small functions portage.dep
+	"""
+
+	def testCPVequal(self):
+
+		test_cases = (
+			( "sys-apps/portage-2.1","sys-apps/portage-2.1", True ),
+			( "sys-apps/portage-2.1","sys-apps/portage-2.0", False ),
+			( "sys-apps/portage-2.1","sys-apps/portage-2.1-r1", False ),
+			( "sys-apps/portage-2.1-r1","sys-apps/portage-2.1", False ),
+			( "sys-apps/portage-2.1_alpha3","sys-apps/portage-2.1", False ),
+			( "sys-apps/portage-2.1_alpha3_p6","sys-apps/portage-2.1_alpha3", False ),
+			( "sys-apps/portage-2.1_alpha3","sys-apps/portage-2.1", False ),
+			( "sys-apps/portage-2.1","sys-apps/X-2.1", False ),
+			( "sys-apps/portage-2.1","portage-2.1", False ),
+		)
+		
+		test_cases_xfail = (
+			( "sys-apps/portage","sys-apps/portage" ),
+			( "sys-apps/portage-2.1-6","sys-apps/portage-2.1-6" ),
+		)
+
+		for cpv1, cpv2, expected_result in test_cases:
+			self.assertEqual(cpvequal(cpv1, cpv2), expected_result)
+
+		for cpv1, cpv2 in test_cases_xfail:
+			self.assertRaisesMsg("cpvequal("+cpv1+", "+cpv2+")", \
+				PortageException, cpvequal, cpv1, cpv2)
diff --git a/portage_with_autodep/pym/portage/tests/dep/test_best_match_to_list.py b/portage_with_autodep/pym/portage/tests/dep/test_best_match_to_list.py
new file mode 100644
index 0000000..d050adc
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/test_best_match_to_list.py
@@ -0,0 +1,43 @@
+# test_best_match_to_list.py -- Portage Unit Testing Functionality
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.dep import Atom, best_match_to_list
+
+class Test_best_match_to_list(TestCase):
+
+	def best_match_to_list_wrapper(self, mypkg, mylist):
+		"""
+		This function uses best_match_to_list to create sorted
+		list of matching atoms.
+		"""
+		ret = []
+		while mylist:
+			m = best_match_to_list(mypkg, mylist)
+			if m is not None:
+				ret.append(m)
+				mylist.remove(m)
+			else:
+				break
+
+		return ret
+
+	def testBest_match_to_list(self):
+		tests = [
+					("dev-libs/A-1", [Atom("dev-libs/A"), Atom("=dev-libs/A-1")], \
+						[Atom("=dev-libs/A-1"), Atom("dev-libs/A")]),
+					("dev-libs/A-1", [Atom("dev-libs/B"), Atom("=dev-libs/A-1:0")], \
+						[Atom("=dev-libs/A-1:0")]),
+					("dev-libs/A-1", [Atom("dev-libs/*", allow_wildcard=True), Atom("=dev-libs/A-1:0")], \
+						[Atom("=dev-libs/A-1:0"), Atom("dev-libs/*", allow_wildcard=True)]),
+					("dev-libs/A-1:0", [Atom("dev-*/*", allow_wildcard=True), Atom("dev-*/*:0", allow_wildcard=True),\
+						Atom("dev-libs/A"), Atom("<=dev-libs/A-2"), Atom("dev-libs/A:0"), \
+						Atom("=dev-libs/A-1*"), Atom("~dev-libs/A-1"), Atom("=dev-libs/A-1")], \
+						[Atom("=dev-libs/A-1"), Atom("~dev-libs/A-1"), Atom("=dev-libs/A-1*"), \
+						Atom("dev-libs/A:0"), Atom("<=dev-libs/A-2"), Atom("dev-libs/A"), \
+						Atom("dev-*/*:0", allow_wildcard=True), Atom("dev-*/*", allow_wildcard=True)])
+				]
+
+		for pkg, atom_list, result in tests:
+			self.assertEqual( self.best_match_to_list_wrapper( pkg, atom_list ), result )
diff --git a/portage_with_autodep/pym/portage/tests/dep/test_dep_getcpv.py b/portage_with_autodep/pym/portage/tests/dep/test_dep_getcpv.py
new file mode 100644
index 0000000..8a0a8aa
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/test_dep_getcpv.py
@@ -0,0 +1,35 @@
+# test_dep_getcpv.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_getcpv
+
+class DepGetCPV(TestCase):
+	""" A simple testcase for isvalidatom
+	"""
+
+	def testDepGetCPV(self):
+		
+		prefix_ops = ["<", ">", "=", "~", "<=", 
+			      ">=", "!=", "!<", "!>", "!~"]
+
+		bad_prefix_ops = [ ">~", "<~", "~>", "~<" ]
+		postfix_ops = [ ("=", "*"), ]
+
+		cpvs = ["sys-apps/portage-2.1", "sys-apps/portage-2.1",
+				"sys-apps/portage-2.1"]
+		slots = [None, ":foo", ":2"]
+		for cpv in cpvs:
+			for slot in slots:
+				for prefix in prefix_ops:
+					mycpv = prefix + cpv
+					if slot:
+						mycpv += slot
+					self.assertEqual( dep_getcpv( mycpv ), cpv )
+
+				for prefix, postfix in postfix_ops:
+					mycpv = prefix + cpv + postfix
+					if slot:
+						mycpv += slot
+					self.assertEqual( dep_getcpv( mycpv ), cpv )
diff --git a/portage_with_autodep/pym/portage/tests/dep/test_dep_getrepo.py b/portage_with_autodep/pym/portage/tests/dep/test_dep_getrepo.py
new file mode 100644
index 0000000..78ead8c
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/test_dep_getrepo.py
@@ -0,0 +1,29 @@
+# Copyright 2010 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/portage_with_autodep/pym/portage/tests/dep/test_dep_getslot.py b/portage_with_autodep/pym/portage/tests/dep/test_dep_getslot.py
new file mode 100644
index 0000000..206cecc
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/test_dep_getslot.py
@@ -0,0 +1,28 @@
+# 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_getslot
+
+class DepGetSlot(TestCase):
+	""" A simple testcase for isvalidatom
+	"""
+
+	def testDepGetSlot(self):
+
+		slot_char = ":"
+		slots = ( "a", "1.2", "1", "IloveVapier", None )
+		cpvs = ["sys-apps/portage"]
+		versions = ["2.1.1","2.1-r1"]
+		for cpv in cpvs:
+			for version in versions:
+				for slot in slots:
+					mycpv = cpv
+					if version:
+						mycpv = '=' + mycpv + '-' + version
+					if slot is not None:
+						self.assertEqual( dep_getslot( 
+							mycpv + slot_char + slot ), slot )
+					else:
+						self.assertEqual( dep_getslot( mycpv ), slot )
diff --git a/portage_with_autodep/pym/portage/tests/dep/test_dep_getusedeps.py b/portage_with_autodep/pym/portage/tests/dep/test_dep_getusedeps.py
new file mode 100644
index 0000000..d2494f7
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/test_dep_getusedeps.py
@@ -0,0 +1,35 @@
+# test_dep_getusedeps.py -- Portage Unit Testing Functionality
+# Copyright 2007-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.dep import dep_getusedeps
+
+from portage.tests import test_cps, test_slots, test_versions, test_usedeps
+
+class DepGetUseDeps(TestCase):
+	""" A simple testcase for dep_getusedeps
+	"""
+
+	def testDepGetUseDeps(self):
+
+		for mycpv in test_cps:
+			for version in test_versions:
+				for slot in test_slots:
+					for use in test_usedeps:
+						cpv = mycpv[:]
+						if version:
+							cpv += version
+						if slot:
+							cpv += ":" + slot
+						if isinstance(use, tuple):
+							cpv += "[%s]" % (",".join(use),)
+							self.assertEqual( dep_getusedeps(
+								cpv ), use )
+						else:
+							if len(use):
+								self.assertEqual( dep_getusedeps(
+									cpv + "[" + use + "]" ), (use,) )
+							else:
+								self.assertEqual( dep_getusedeps(
+									cpv + "[" + use + "]" ), () )
diff --git a/portage_with_autodep/pym/portage/tests/dep/test_get_operator.py b/portage_with_autodep/pym/portage/tests/dep/test_get_operator.py
new file mode 100644
index 0000000..4f9848f
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/test_get_operator.py
@@ -0,0 +1,33 @@
+# test_get_operator.py -- Portage Unit Testing Functionality
+# Copyright 2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.dep import get_operator
+
+class GetOperator(TestCase):
+
+	def testGetOperator(self):
+
+		# get_operator does not validate operators
+		tests = [ ( "~", "~" ), ( "=", "=" ), ( ">", ">" ),
+			  ( ">=", ">=" ), ( "<=", "<=" ),
+		]
+
+		test_cpvs = ["sys-apps/portage-2.1"]
+		slots = [ None,"1","linux-2.5.6" ]
+		for cpv in test_cpvs:
+			for test in tests:
+				for slot in slots:
+					atom = cpv[:]
+					if slot:
+						atom += ":" + slot
+					result = get_operator( test[0] + atom )
+					self.assertEqual( result, test[1],
+						msg="get_operator(%s) != %s" % (test[0] + atom, test[1]) )
+
+		result = get_operator( "sys-apps/portage" )
+		self.assertEqual( result, None )
+
+		result = get_operator( "=sys-apps/portage-2.1*" )
+		self.assertEqual( result , "=*" )
diff --git a/portage_with_autodep/pym/portage/tests/dep/test_get_required_use_flags.py b/portage_with_autodep/pym/portage/tests/dep/test_get_required_use_flags.py
new file mode 100644
index 0000000..06f8110
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/test_get_required_use_flags.py
@@ -0,0 +1,42 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.dep import get_required_use_flags
+from portage.exception import InvalidDependString
+
+class TestCheckRequiredUse(TestCase):
+
+	def testCheckRequiredUse(self):
+		test_cases = (
+			("a b c", ["a", "b", "c"]),
+
+			("|| ( a b c )", ["a", "b", "c"]),
+			("^^ ( a b c )", ["a", "b", "c"]),
+
+			("|| ( a b ^^ ( d e f ) )", ["a", "b", "d", "e", "f"]),
+			("^^ ( a b || ( d e f ) )", ["a", "b", "d", "e", "f"]),
+
+			("( ^^ ( a ( b ) ( || ( ( d e ) ( f ) ) ) ) )", ["a", "b", "d", "e", "f"]),
+
+			("a? ( ^^ ( b c ) )", ["a", "b", "c"]),
+			("a? ( ^^ ( !b !d? ( c ) ) )", ["a", "b", "c", "d"]),
+		)
+
+		test_cases_xfail = (
+			("^^ ( || ( a b ) ^^ ( b c )"),
+			("^^( || ( a b ) ^^ ( b c ) )"),
+			("^^ || ( a b ) ^^ ( b c )"),
+			("^^ ( ( || ) ( a b ) ^^ ( b c ) )"),
+			("^^ ( || ( a b ) ) ^^ ( b c ) )"),
+		)
+
+		for required_use, expected in test_cases:
+			result = get_required_use_flags(required_use)
+			expected = set(expected)
+			self.assertEqual(result, expected, \
+				"REQUIRED_USE: '%s', expected: '%s', got: '%s'" % (required_use, expected, result))
+
+		for required_use in test_cases_xfail:
+			self.assertRaisesMsg("REQUIRED_USE: '%s'" % (required_use,), \
+				InvalidDependString, get_required_use_flags, required_use)
diff --git a/portage_with_autodep/pym/portage/tests/dep/test_isjustname.py b/portage_with_autodep/pym/portage/tests/dep/test_isjustname.py
new file mode 100644
index 0000000..c16fb54
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/test_isjustname.py
@@ -0,0 +1,24 @@
+# test_isjustname.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 isjustname
+
+class IsJustName(TestCase):
+
+	def testIsJustName(self):
+
+		cats = ( "", "sys-apps/", "foo/", "virtual/" )
+		pkgs = ( "portage", "paludis", "pkgcore", "notARealPkg" )
+		vers = ( "", "-2.0-r3", "-1.0_pre2", "-3.1b" )
+
+		for pkg in pkgs:
+			for cat in cats:
+				for ver in vers:
+					if len(ver):
+						self.assertFalse( isjustname( cat + pkg + ver ),
+						msg="isjustname(%s) is True!" % (cat + pkg + ver) )
+					else:
+						self.assertTrue( isjustname( cat + pkg + ver ),
+						msg="isjustname(%s) is False!" % (cat + pkg + ver) )
diff --git a/portage_with_autodep/pym/portage/tests/dep/test_isvalidatom.py b/portage_with_autodep/pym/portage/tests/dep/test_isvalidatom.py
new file mode 100644
index 0000000..173ab0d
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/test_isvalidatom.py
@@ -0,0 +1,146 @@
+# Copyright 2006-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.dep import isvalidatom
+
+class IsValidAtomTestCase(object):
+	def __init__(self, atom, expected, allow_wildcard=False, allow_repo=False):
+		self.atom = atom
+		self.expected = expected
+		self.allow_wildcard = allow_wildcard
+		self.allow_repo = allow_repo
+
+class IsValidAtom(TestCase):
+
+	def testIsValidAtom(self):
+
+		test_cases = (
+			IsValidAtomTestCase("sys-apps/portage", True),
+			IsValidAtomTestCase("=sys-apps/portage-2.1", True),
+			IsValidAtomTestCase("=sys-apps/portage-2.1*", True),
+			IsValidAtomTestCase(">=sys-apps/portage-2.1", True),
+			IsValidAtomTestCase("<=sys-apps/portage-2.1", True),
+			IsValidAtomTestCase(">sys-apps/portage-2.1", True),
+			IsValidAtomTestCase("<sys-apps/portage-2.1", True),
+			IsValidAtomTestCase("~sys-apps/portage-2.1", True),
+			IsValidAtomTestCase("sys-apps/portage:foo", True),
+			IsValidAtomTestCase("sys-apps/portage-2.1:foo", False),
+			IsValidAtomTestCase( "sys-apps/portage-2.1:", False),
+			IsValidAtomTestCase("sys-apps/portage-2.1:", False),
+			IsValidAtomTestCase("sys-apps/portage-2.1:[foo]", False),
+			IsValidAtomTestCase("sys-apps/portage", True),
+			IsValidAtomTestCase("sys-apps/portage", True),
+			IsValidAtomTestCase("sys-apps/portage", True),
+			IsValidAtomTestCase("sys-apps/portage", True),
+			IsValidAtomTestCase("sys-apps/portage", True),
+			IsValidAtomTestCase("sys-apps/portage", True),
+			IsValidAtomTestCase("sys-apps/portage", True),
+
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[bar?,!baz?,!doc=,build=]", True),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[doc?]", True),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[!doc?]", True),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[doc=]", True),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[!doc=]", True),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[!doc]", False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[!-doc]", False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[!-doc=]", False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[!-doc?]", False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[-doc?]", False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[-doc=]", False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[-doc!=]", False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[-doc=]", False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[bar][-baz][doc?][!build?]", False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[bar,-baz,doc?,!build?]", True),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[bar,-baz,doc?,!build?,]", False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[,bar,-baz,doc?,!build?]", False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[bar,-baz][doc?,!build?]", False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo[bar][doc,build]", False),
+			IsValidAtomTestCase(">~cate-gory/foo-1.0", False),
+			IsValidAtomTestCase(">~category/foo-1.0", False),
+			IsValidAtomTestCase("<~category/foo-1.0", False),
+			IsValidAtomTestCase("###cat/foo-1.0", False),
+			IsValidAtomTestCase("~sys-apps/portage", False),
+			IsValidAtomTestCase("portage", False),
+			IsValidAtomTestCase("=portage", False),
+			IsValidAtomTestCase(">=portage-2.1", False),
+			IsValidAtomTestCase("~portage-2.1", False),
+			IsValidAtomTestCase("=portage-2.1*", False),
+			IsValidAtomTestCase("null/portage", True),
+			IsValidAtomTestCase("null/portage*:0", False),
+			IsValidAtomTestCase(">=null/portage-2.1", True),
+			IsValidAtomTestCase(">=null/portage", False),
+			IsValidAtomTestCase(">null/portage", False),
+			IsValidAtomTestCase("=null/portage*", False),
+			IsValidAtomTestCase("=null/portage", False),
+			IsValidAtomTestCase("~null/portage", False),
+			IsValidAtomTestCase("<=null/portage", False),
+			IsValidAtomTestCase("<null/portage", False),
+			IsValidAtomTestCase("~null/portage-2.1", True),
+			IsValidAtomTestCase("=null/portage-2.1*", True),
+			IsValidAtomTestCase("null/portage-2.1*", False),
+			IsValidAtomTestCase("app-doc/php-docs-20071125", False),
+			IsValidAtomTestCase("app-doc/php-docs-20071125-r2", False),
+			IsValidAtomTestCase("=foo/bar-1-r1-1-r1", False),
+			IsValidAtomTestCase("foo/-z-1", False),
+
+			# These are invalid because pkg name must not end in hyphen
+			# followed by numbers
+			IsValidAtomTestCase("=foo/bar-1-r1-1-r1", False),
+			IsValidAtomTestCase("=foo/bar-123-1", False),
+			IsValidAtomTestCase("=foo/bar-123-1*", False),
+			IsValidAtomTestCase("foo/bar-123", False),
+			IsValidAtomTestCase("=foo/bar-123-1-r1", False),
+			IsValidAtomTestCase("=foo/bar-123-1-r1*", False),
+			IsValidAtomTestCase("foo/bar-123-r1", False),
+			IsValidAtomTestCase("foo/bar-1", False),
+
+			IsValidAtomTestCase("=foo/bar--baz-1-r1", True),
+			IsValidAtomTestCase("=foo/bar-baz--1-r1", True),
+			IsValidAtomTestCase("=foo/bar-baz---1-r1", True),
+			IsValidAtomTestCase("=foo/bar-baz---1", True),
+			IsValidAtomTestCase("=foo/bar-baz-1--r1", False),
+			IsValidAtomTestCase("games-strategy/ufo2000", True),
+			IsValidAtomTestCase("~games-strategy/ufo2000-0.1", True),
+			IsValidAtomTestCase("=media-libs/x264-20060810", True),
+			IsValidAtomTestCase("foo/b", True),
+			IsValidAtomTestCase("app-text/7plus", True),
+			IsValidAtomTestCase("foo/666", True),
+			IsValidAtomTestCase("=dev-libs/poppler-qt3-0.11*", True),
+
+			 #Testing atoms with repositories
+			IsValidAtomTestCase("sys-apps/portage::repo_123-name", True, allow_repo=True),
+			IsValidAtomTestCase("=sys-apps/portage-2.1::repo", True, allow_repo=True),
+			IsValidAtomTestCase("=sys-apps/portage-2.1*::repo", True, allow_repo=True),
+			IsValidAtomTestCase("sys-apps/portage:foo::repo", True, allow_repo=True),
+			IsValidAtomTestCase("sys-apps/portage-2.1:foo::repo", False, allow_repo=True),
+			IsValidAtomTestCase("sys-apps/portage-2.1:::repo", False, allow_repo=True),
+			IsValidAtomTestCase("sys-apps/portage-2.1:::repo[foo]", False, allow_repo=True),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo::repo[bar?,!baz?,!doc=,build=]", True, allow_repo=True),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo::repo[doc?]", True, allow_repo=True),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo::repo[!doc]", False, allow_repo=True),
+			IsValidAtomTestCase("###cat/foo-1.0::repo", False, allow_repo=True),
+			IsValidAtomTestCase("~sys-apps/portage::repo", False, allow_repo=True),
+			IsValidAtomTestCase("portage::repo", False, allow_repo=True),
+			IsValidAtomTestCase("=portage::repo", False, allow_repo=True),
+			IsValidAtomTestCase("null/portage::repo", True, allow_repo=True),
+			IsValidAtomTestCase("app-doc/php-docs-20071125::repo", False, allow_repo=True),
+			IsValidAtomTestCase("=foo/bar-1-r1-1-r1::repo", False, allow_repo=True),
+
+			IsValidAtomTestCase("sys-apps/portage::repo_123-name", False, allow_repo=False),
+			IsValidAtomTestCase("=sys-apps/portage-2.1::repo", False, allow_repo=False),
+			IsValidAtomTestCase("=sys-apps/portage-2.1*::repo", False, allow_repo=False),
+			IsValidAtomTestCase("sys-apps/portage:foo::repo", False, allow_repo=False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo::repo[bar?,!baz?,!doc=,build=]", False, allow_repo=False),
+			IsValidAtomTestCase("=sys-apps/portage-2.2*:foo::repo[doc?]", False, allow_repo=False),
+			IsValidAtomTestCase("null/portage::repo", False, allow_repo=False),
+		)
+
+		for test_case in test_cases:
+			if test_case.expected:
+				atom_type = "valid"
+			else:
+				atom_type = "invalid"
+			self.assertEqual( bool(isvalidatom(test_case.atom, allow_wildcard=test_case.allow_wildcard, \
+				allow_repo=test_case.allow_repo)), test_case.expected,
+				msg="isvalidatom(%s) != %s" % ( test_case.atom, test_case.expected ) )
diff --git a/portage_with_autodep/pym/portage/tests/dep/test_match_from_list.py b/portage_with_autodep/pym/portage/tests/dep/test_match_from_list.py
new file mode 100644
index 0000000..afba414
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/test_match_from_list.py
@@ -0,0 +1,108 @@
+# Copyright 2006, 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import sys
+from portage.tests import TestCase
+from portage.dep import Atom, match_from_list, _repo_separator
+from portage.versions import catpkgsplit
+
+if sys.hexversion >= 0x3000000:
+	basestring = str
+
+class Package(object):
+	"""
+	Provides a minimal subset of attributes of _emerge.Package.Package
+	"""
+	def __init__(self, atom):
+		atom = Atom(atom, allow_repo=True)
+		self.cp = atom.cp
+		self.cpv = atom.cpv
+		self.cpv_split = catpkgsplit(self.cpv)
+		self.slot = atom.slot
+		self.repo = atom.repo
+		if atom.use:
+			self.use = self._use_class(atom.use.enabled)
+			self.iuse = self._iuse_class(atom.use.required)
+		else:
+			self.use = self._use_class([])
+			self.iuse = self._iuse_class([])
+
+	class _use_class(object):
+		def __init__(self, use):
+			self.enabled = frozenset(use)
+
+	class _iuse_class(object):
+		def __init__(self, iuse):
+			self.all = frozenset(iuse)
+
+		def is_valid_flag(self, flags):
+			if isinstance(flags, basestring):
+				flags = [flags]
+			for flag in flags:
+				if not flag in self.all:
+					return False
+			return True
+
+class Test_match_from_list(TestCase):
+
+	def testMatch_from_list(self):
+		tests = (
+			("=sys-apps/portage-45*", [], [] ),
+			("=sys-apps/portage-45*", ["sys-apps/portage-045"], ["sys-apps/portage-045"] ),
+			("!=sys-apps/portage-45*", ["sys-apps/portage-045"], ["sys-apps/portage-045"] ),
+			("!!=sys-apps/portage-45*", ["sys-apps/portage-045"], ["sys-apps/portage-045"] ),
+			("=sys-apps/portage-045", ["sys-apps/portage-045"], ["sys-apps/portage-045"] ),
+			("=sys-apps/portage-045", ["sys-apps/portage-046"], [] ),
+			("~sys-apps/portage-045", ["sys-apps/portage-045-r1"], ["sys-apps/portage-045-r1"] ),
+			("~sys-apps/portage-045", ["sys-apps/portage-046-r1"], [] ),
+			("<=sys-apps/portage-045", ["sys-apps/portage-045"], ["sys-apps/portage-045"] ),
+			("<=sys-apps/portage-045", ["sys-apps/portage-046"], [] ),
+			("<sys-apps/portage-046", ["sys-apps/portage-045"], ["sys-apps/portage-045"] ),
+			("<sys-apps/portage-046", ["sys-apps/portage-046"], [] ),
+			(">=sys-apps/portage-045", ["sys-apps/portage-045"], ["sys-apps/portage-045"] ),
+			(">=sys-apps/portage-047", ["sys-apps/portage-046-r1"], [] ),
+			(">sys-apps/portage-044", ["sys-apps/portage-045"], ["sys-apps/portage-045"] ),
+			(">sys-apps/portage-047", ["sys-apps/portage-046-r1"], [] ),
+			("sys-apps/portage:0", [Package("=sys-apps/portage-045:0")], ["sys-apps/portage-045"] ),
+			("sys-apps/portage:0", [Package("=sys-apps/portage-045:1")], [] ),
+			("=sys-fs/udev-1*", ["sys-fs/udev-123"], ["sys-fs/udev-123"]),
+			("=sys-fs/udev-4*", ["sys-fs/udev-456"], ["sys-fs/udev-456"] ),
+			("*/*", ["sys-fs/udev-456"], ["sys-fs/udev-456"] ),
+			("sys-fs/*", ["sys-fs/udev-456"], ["sys-fs/udev-456"] ),
+			("*/udev", ["sys-fs/udev-456"], ["sys-fs/udev-456"] ),
+			("=sys-apps/portage-2*", ["sys-apps/portage-2.1"], ["sys-apps/portage-2.1"] ),
+			("=sys-apps/portage-2.1*", ["sys-apps/portage-2.1.2"], ["sys-apps/portage-2.1.2"] ),
+			("dev-libs/*", ["sys-apps/portage-2.1.2"], [] ),
+			("*/tar", ["sys-apps/portage-2.1.2"], [] ),
+			("*/*", ["dev-libs/A-1", "dev-libs/B-1"], ["dev-libs/A-1", "dev-libs/B-1"] ),
+			("dev-libs/*", ["dev-libs/A-1", "sci-libs/B-1"], ["dev-libs/A-1"] ),
+
+			("dev-libs/A[foo]", [Package("=dev-libs/A-1[foo]"), Package("=dev-libs/A-2[-foo]")], ["dev-libs/A-1"] ),
+			("dev-libs/A[-foo]", [Package("=dev-libs/A-1[foo]"), Package("=dev-libs/A-2[-foo]")], ["dev-libs/A-2"] ),
+			("dev-libs/A[-foo]", [Package("=dev-libs/A-1[foo]"), Package("=dev-libs/A-2")], [] ),
+			("dev-libs/A[foo,bar]", [Package("=dev-libs/A-1[foo]"), Package("=dev-libs/A-2[-foo]")], [] ),
+			("dev-libs/A[foo,bar]", [Package("=dev-libs/A-1[foo]"), Package("=dev-libs/A-2[-foo,bar]")], [] ),
+			("dev-libs/A[foo,bar]", [Package("=dev-libs/A-1[foo]"), Package("=dev-libs/A-2[foo,bar]")], ["dev-libs/A-2"] ),
+			("dev-libs/A[foo,bar(+)]", [Package("=dev-libs/A-1[-foo]"), Package("=dev-libs/A-2[foo]")], ["dev-libs/A-2"] ),
+			("dev-libs/A[foo,bar(-)]", [Package("=dev-libs/A-1[-foo]"), Package("=dev-libs/A-2[foo]")], [] ),
+			("dev-libs/A[foo,-bar(-)]", [Package("=dev-libs/A-1[-foo,bar]"), Package("=dev-libs/A-2[foo]")], ["dev-libs/A-2"] ),
+
+			("dev-libs/A::repo1", [Package("=dev-libs/A-1::repo1"), Package("=dev-libs/A-1::repo2")], ["dev-libs/A-1::repo1"] ),
+			("dev-libs/A::repo2", [Package("=dev-libs/A-1::repo1"), Package("=dev-libs/A-1::repo2")], ["dev-libs/A-1::repo2"] ),
+			("dev-libs/A::repo2[foo]", [Package("=dev-libs/A-1::repo1[foo]"), Package("=dev-libs/A-1::repo2[-foo]")], [] ),
+			("dev-libs/A::repo2[foo]", [Package("=dev-libs/A-1::repo1[-foo]"), Package("=dev-libs/A-1::repo2[foo]")], ["dev-libs/A-1::repo2"] ),
+			("dev-libs/A:1::repo2[foo]", [Package("=dev-libs/A-1:1::repo1"), Package("=dev-libs/A-1:2::repo2")], [] ),
+			("dev-libs/A:1::repo2[foo]", [Package("=dev-libs/A-1:2::repo1"), Package("=dev-libs/A-1:1::repo2[foo]")], ["dev-libs/A-1::repo2"] ),
+		)
+
+		for atom, cpv_list, expected_result in tests:
+			result = []
+			for pkg in match_from_list( atom, cpv_list ):
+				if isinstance(pkg, Package):
+					if pkg.repo:
+						result.append(pkg.cpv + _repo_separator + pkg.repo)
+					else:
+						result.append(pkg.cpv)
+				else:
+					result.append(pkg)
+			self.assertEqual( result, expected_result )
diff --git a/portage_with_autodep/pym/portage/tests/dep/test_paren_reduce.py b/portage_with_autodep/pym/portage/tests/dep/test_paren_reduce.py
new file mode 100644
index 0000000..9a147a0
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/test_paren_reduce.py
@@ -0,0 +1,66 @@
+# Copyright 2010-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.dep import paren_reduce
+from portage.exception import InvalidDependString
+
+class TestParenReduce(TestCase):
+
+	def testParenReduce(self):
+
+		test_cases = (
+			( "A", ["A"]),
+			( "( A )", ["A"]),
+			( "|| ( A B )", [ "||", ["A", "B"] ]),
+			( "|| ( A || ( B C ) )", [ "||", ["A", "||", ["B", "C"]]]),
+			( "|| ( A || ( B C D ) )", [ "||", ["A", "||", ["B", "C", "D"]] ]),
+			( "|| ( A || ( B || ( C D ) E ) )", [ "||", ["A", "||", ["B", "||", ["C", "D"], "E"]] ]),
+			( "a? ( A )", ["a?", ["A"]]),
+			
+			( "( || ( ( ( A ) B ) ) )", ["A", "B"]),
+			( "( || ( || ( ( A ) B ) ) )", [ "||", ["A", "B"] ]),
+			( "|| ( A )", ["A"]),
+			( "( || ( || ( || ( A ) foo? ( B ) ) ) )", [ "||", ["A", "foo?", ["B"] ]]),
+			( "( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )", [ "||", ["bar?", ["A"], "foo?", ["B"] ]]),
+			( "A || ( ) foo? ( ) B", ["A", "B"]),
+
+			( "|| ( A ) || ( B )", ["A", "B"]),
+			( "foo? ( A ) foo? ( B )", ["foo?", ["A"], "foo?", ["B"]]),
+
+			( "|| ( ( A B ) C )", [ "||", [ ["A", "B"], "C"] ]),
+			( "|| ( ( A B ) ( C ) )", [ "||", [ ["A", "B"], "C"] ]),
+			# test USE dep defaults for bug #354003
+			( ">=dev-lang/php-5.2[pcre(+)]", [ ">=dev-lang/php-5.2[pcre(+)]" ]),
+		)
+		
+		test_cases_xfail = (
+			"( A",
+			"A )",
+
+			"||( A B )",
+			"|| (A B )",
+			"|| ( A B)",
+			"|| ( A B",
+			"|| A B )",
+
+			"|| A B",
+			"|| ( A B ) )",
+			"|| || B C",
+			
+			"|| ( A B || )",
+			
+			"a? A",
+			
+			( "( || ( || || ( A ) foo? ( B ) ) )"),
+			( "( || ( || bar? ( A ) foo? ( B ) ) )"),
+		)
+
+		for dep_str, expected_result in test_cases:
+			self.assertEqual(paren_reduce(dep_str), expected_result,
+				"input: '%s' result: %s != %s" % (dep_str,
+				paren_reduce(dep_str), expected_result))
+
+		for dep_str in test_cases_xfail:
+			self.assertRaisesMsg(dep_str,
+				InvalidDependString, paren_reduce, dep_str)
diff --git a/portage_with_autodep/pym/portage/tests/dep/test_use_reduce.py b/portage_with_autodep/pym/portage/tests/dep/test_use_reduce.py
new file mode 100644
index 0000000..1618430
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/dep/test_use_reduce.py
@@ -0,0 +1,627 @@
+# Copyright 2009-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.exception import InvalidDependString
+from portage.dep import Atom, use_reduce
+
+class UseReduceTestCase(object):
+	def __init__(self, deparray, uselist=[], masklist=[], \
+		matchall=0, excludeall=[], is_src_uri=False, \
+		eapi="0", opconvert=False, flat=False, expected_result=None, \
+			is_valid_flag=None, token_class=None):
+		self.deparray = deparray
+		self.uselist = uselist
+		self.masklist = masklist
+		self.matchall = matchall
+		self.excludeall = excludeall
+		self.is_src_uri = is_src_uri
+		self.eapi = eapi
+		self.opconvert = opconvert
+		self.flat = flat
+		self.is_valid_flag = is_valid_flag
+		self.token_class = token_class
+		self.expected_result = expected_result
+
+	def run(self):
+		try:
+			return use_reduce(self.deparray, self.uselist, self.masklist, \
+				self.matchall, self.excludeall, self.is_src_uri, self.eapi, \
+				self.opconvert, self.flat, self.is_valid_flag, self.token_class)
+		except InvalidDependString as e:
+			raise InvalidDependString("%s: %s" % (e, self.deparray))
+
+class UseReduce(TestCase):
+
+	def always_true(self, ununsed_parameter):
+		return True
+
+	def always_false(self, ununsed_parameter):
+		return False
+
+	def testUseReduce(self):
+
+		EAPI_WITH_SRC_URI_ARROWS = "2"
+		EAPI_WITHOUT_SRC_URI_ARROWS = "0"
+
+		test_cases = (
+			UseReduceTestCase(
+				"a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
+				uselist = ["a", "b", "c", "d"],
+				expected_result = ["A", "B"]
+				),
+			UseReduceTestCase(
+				"a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
+				uselist = ["a", "b", "c"],
+				expected_result = ["A", "B", "D"]
+				),
+			UseReduceTestCase(
+				"a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
+				uselist = ["b", "c"],
+				expected_result = ["B", "D"]
+				),
+
+			UseReduceTestCase(
+				"a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
+				matchall = True,
+				expected_result = ["A", "B", "C", "D"]
+				),
+			UseReduceTestCase(
+				"a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
+				masklist = ["a", "c"],
+				expected_result = ["C", "D"]
+				),
+			UseReduceTestCase(
+				"a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
+				matchall = True,
+				masklist = ["a", "c"],
+				expected_result = ["B", "C", "D"]
+				),
+			UseReduceTestCase(
+				"a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
+				uselist = ["a", "b"],
+				masklist = ["a", "c"],
+				expected_result = ["B", "C", "D"]
+				),
+			UseReduceTestCase(
+				"a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
+				excludeall = ["a", "c"],
+				expected_result = ["D"]
+				),
+			UseReduceTestCase(
+				"a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
+				uselist = ["b"],
+				excludeall = ["a", "c"],
+				expected_result = ["B", "D"]
+				),
+			UseReduceTestCase(
+				"a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
+				matchall = True,
+				excludeall = ["a", "c"],
+				expected_result = ["A", "B", "D"]
+				),
+			UseReduceTestCase(
+				"a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
+				matchall = True,
+				excludeall = ["a", "c"],
+				masklist = ["b"],
+				expected_result = ["A", "D"]
+				),
+
+			
+			UseReduceTestCase(
+				"a? ( b? ( AB ) )",
+				uselist = ["a", "b"],
+				expected_result = ["AB"]
+				),
+			UseReduceTestCase(
+				"a? ( b? ( AB ) C )",
+				uselist = ["a"],
+				expected_result = ["C"]
+				),
+			UseReduceTestCase(
+				"a? ( b? ( || ( AB CD ) ) )",
+				uselist = ["a", "b"],
+				expected_result = ["||", ["AB", "CD"]]
+				),
+			UseReduceTestCase(
+				"|| ( || ( a? ( A ) b? ( B ) ) )",
+				uselist = ["a", "b"],
+				expected_result = ["||", ["A", "B"]]
+				),
+			UseReduceTestCase(
+				"|| ( || ( a? ( A ) b? ( B ) ) )",
+				uselist = ["a"],
+				expected_result = ["A"]
+				),
+			UseReduceTestCase(
+				"|| ( || ( a? ( A ) b? ( B ) ) )",
+				uselist = [],
+				expected_result = []
+				),
+			UseReduceTestCase(
+				"|| ( || ( a? ( || ( A c? ( C ) ) ) b? ( B ) ) )",
+				uselist = [],
+				expected_result = []
+				),
+			UseReduceTestCase(
+				"|| ( || ( a? ( || ( A c? ( C ) ) ) b? ( B ) ) )",
+				uselist = ["a"],
+				expected_result = ["A"]
+				),
+			UseReduceTestCase(
+				"|| ( || ( a? ( || ( A c? ( C ) ) ) b? ( B ) ) )",
+				uselist = ["b"],
+				expected_result = ["B"]
+				),
+			UseReduceTestCase(
+				"|| ( || ( a? ( || ( A c? ( C ) ) ) b? ( B ) ) )",
+				uselist = ["c"],
+				expected_result = []
+				),
+			UseReduceTestCase(
+				"|| ( || ( a? ( || ( A c? ( C ) ) ) b? ( B ) ) )",
+				uselist = ["a", "c"],
+				expected_result = ["||", [ "A", "C"]]
+				),
+			
+			#paren_reduce tests
+			UseReduceTestCase(
+				"A",
+				expected_result = ["A"]),
+			UseReduceTestCase(
+				"( A )",
+				expected_result = ["A"]),
+			UseReduceTestCase(
+				"|| ( A B )",
+				expected_result = [ "||", ["A", "B"] ]),
+			UseReduceTestCase(
+				"|| ( ( A B ) C )",
+				expected_result = [ "||", [ ["A", "B"], "C"] ]),
+			UseReduceTestCase(
+				"|| ( ( A B ) ( C ) )",
+				expected_result = [ "||", [ ["A", "B"], "C"] ]),
+			UseReduceTestCase(
+				"|| ( A || ( B C ) )",
+				expected_result = [ "||", ["A", "B", "C"]]),
+			UseReduceTestCase(
+				"|| ( A || ( B C D ) )",
+				expected_result = [ "||", ["A", "B", "C", "D"] ]),
+			UseReduceTestCase(
+				"|| ( A || ( B || ( C D ) E ) )",
+				expected_result = [ "||", ["A", "B", "C", "D", "E"] ]),
+			UseReduceTestCase(
+				"( || ( ( ( A ) B ) ) )",
+				expected_result = ["A", "B"] ),
+			UseReduceTestCase(
+				"( || ( || ( ( A ) B ) ) )",
+				expected_result = [ "||", ["A", "B"] ]),
+			UseReduceTestCase(
+				"( || ( || ( ( A ) B ) ) )",
+				expected_result = [ "||", ["A", "B"] ]),
+			UseReduceTestCase(
+				"|| ( A )",
+				expected_result = ["A"]),
+			UseReduceTestCase(
+				"( || ( || ( || ( A ) foo? ( B ) ) ) )",
+				expected_result = ["A"]),
+			UseReduceTestCase(
+				"( || ( || ( || ( A ) foo? ( B ) ) ) )",
+				uselist = ["foo"],
+				expected_result = [ "||", ["A", "B"] ]),
+			UseReduceTestCase(
+				"( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )",
+				expected_result = []),
+			UseReduceTestCase(
+				"( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )",
+				uselist = ["foo", "bar"],
+				expected_result = [ "||", [ "A", "B" ] ]),
+			UseReduceTestCase(
+				"A || ( bar? ( C ) ) foo? ( bar? ( C ) ) B",
+				expected_result = ["A", "B"]),
+			UseReduceTestCase(
+				"|| ( A ) || ( B )",
+				expected_result = ["A", "B"]),
+			UseReduceTestCase(
+				"foo? ( A ) foo? ( B )",
+				expected_result = []),
+			UseReduceTestCase(
+				"foo? ( A ) foo? ( B )",
+				uselist = ["foo"],
+				expected_result = ["A", "B"]),
+			UseReduceTestCase(
+				"|| ( A B ) C",
+				expected_result = ['||', ['A', 'B'], 'C']),
+			UseReduceTestCase(
+				"A || ( B C )",
+				expected_result = ['A', '||', ['B', 'C']]),
+
+			#SRC_URI stuff
+			UseReduceTestCase(
+				"http://foo/bar -> blah.tbz2",
+				is_src_uri = True,
+				eapi = EAPI_WITH_SRC_URI_ARROWS,
+				expected_result = ["http://foo/bar", "->", "blah.tbz2"]),
+			UseReduceTestCase(
+				"foo? ( http://foo/bar -> blah.tbz2 )",
+				uselist = [],
+				is_src_uri = True,
+				eapi = EAPI_WITH_SRC_URI_ARROWS,
+				expected_result = []),
+			UseReduceTestCase(
+				"foo? ( http://foo/bar -> blah.tbz2 )",
+				uselist = ["foo"],
+				is_src_uri = True,
+				eapi = EAPI_WITH_SRC_URI_ARROWS,
+				expected_result = ["http://foo/bar", "->", "blah.tbz2"]),
+			UseReduceTestCase(
+				"http://foo/bar -> bar.tbz2 foo? ( ftp://foo/a )",
+				uselist = [],
+				is_src_uri = True,
+				eapi = EAPI_WITH_SRC_URI_ARROWS,
+				expected_result = ["http://foo/bar", "->", "bar.tbz2"]),
+			UseReduceTestCase(
+				"http://foo/bar -> bar.tbz2 foo? ( ftp://foo/a )",
+				uselist = ["foo"],
+				is_src_uri = True,
+				eapi = EAPI_WITH_SRC_URI_ARROWS,
+				expected_result = ["http://foo/bar", "->", "bar.tbz2", "ftp://foo/a"]),
+			UseReduceTestCase(
+				"http://foo.com/foo http://foo/bar -> blah.tbz2",
+				uselist = ["foo"],
+				is_src_uri = True,
+				eapi = EAPI_WITH_SRC_URI_ARROWS,
+				expected_result = ["http://foo.com/foo", "http://foo/bar", "->", "blah.tbz2"]),
+
+			#opconvert tests
+			UseReduceTestCase(
+				"A",
+				opconvert = True,
+				expected_result = ["A"]),
+			UseReduceTestCase(
+				"( A )",
+				opconvert = True,
+				expected_result = ["A"]),
+			UseReduceTestCase(
+				"|| ( A B )",
+				opconvert = True,
+				expected_result = [['||', 'A', 'B']]),
+			UseReduceTestCase(
+				"|| ( ( A B ) C )",
+				opconvert = True,
+				expected_result = [['||', ['A', 'B'], 'C']]),
+			UseReduceTestCase(
+				"|| ( A || ( B C ) )",
+				opconvert = True,
+				expected_result = [['||', 'A', 'B', 'C']]),
+			UseReduceTestCase(
+				"|| ( A || ( B C D ) )",
+				opconvert = True,
+				expected_result = [['||', 'A', 'B', 'C', 'D']]),
+			UseReduceTestCase(
+				"|| ( A || ( B || ( C D ) E ) )",
+				expected_result = [ "||", ["A", "B", "C", "D", "E"] ]),
+			UseReduceTestCase(
+				"( || ( ( ( A ) B ) ) )",
+				opconvert = True,
+				expected_result = [ "A", "B" ] ),
+			UseReduceTestCase(
+				"( || ( || ( ( A ) B ) ) )",
+				opconvert = True,
+				expected_result = [['||', 'A', 'B']]),
+			UseReduceTestCase(
+				"|| ( A B ) C",
+				opconvert = True,
+				expected_result = [['||', 'A', 'B'], 'C']),
+			UseReduceTestCase(
+				"A || ( B C )",
+				opconvert = True,
+				expected_result = ['A', ['||', 'B', 'C']]),
+			UseReduceTestCase(
+				"A foo? ( || ( B || ( bar? ( || ( C D E ) ) !bar? ( F ) ) ) ) G",
+				uselist = ["foo", "bar"],
+				opconvert = True,
+				expected_result = ['A', ['||', 'B', 'C', 'D', 'E'], 'G']),
+			UseReduceTestCase(
+				"A foo? ( || ( B || ( bar? ( || ( C D E ) ) !bar? ( F ) ) ) ) G",
+				uselist = ["foo", "bar"],
+				opconvert = False,
+				expected_result = ['A', '||', ['B', 'C', 'D', 'E'], 'G']),
+
+			UseReduceTestCase(
+				"|| ( A )",
+				opconvert = True,
+				expected_result = ["A"]),
+			UseReduceTestCase(
+				"( || ( || ( || ( A ) foo? ( B ) ) ) )",
+				expected_result = ["A"]),
+			UseReduceTestCase(
+				"( || ( || ( || ( A ) foo? ( B ) ) ) )",
+				uselist = ["foo"],
+				opconvert = True,
+				expected_result = [['||', 'A', 'B']]),
+			UseReduceTestCase(
+				"( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )",
+				opconvert = True,
+				expected_result = []),
+			UseReduceTestCase(
+				"( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )",
+				uselist = ["foo", "bar"],
+				opconvert = True,
+				expected_result = [['||', 'A', 'B']]),
+			UseReduceTestCase(
+				"A || ( bar? ( C ) ) foo? ( bar? ( C ) ) B",
+				opconvert = True,
+				expected_result = ["A", "B"]),
+			UseReduceTestCase(
+				"|| ( A ) || ( B )",
+				opconvert = True,
+				expected_result = ["A", "B"]),
+			UseReduceTestCase(
+				"foo? ( A ) foo? ( B )",
+				opconvert = True,
+				expected_result = []),
+			UseReduceTestCase(
+				"foo? ( A ) foo? ( B )",
+				uselist = ["foo"],
+				opconvert = True,
+				expected_result = ["A", "B"]),
+			UseReduceTestCase(
+				"|| ( foo? ( || ( A B ) ) )",
+				uselist = ["foo"],
+				opconvert = True,
+				expected_result = [['||', 'A', 'B']]),
+
+			UseReduceTestCase(
+				"|| ( ( A B ) foo? ( || ( C D ) ) )",
+				uselist = ["foo"],
+				opconvert = True,
+				expected_result = [['||', ['A', 'B'], 'C', 'D']]),
+
+			UseReduceTestCase(
+				"|| ( ( A B ) foo? ( || ( C D ) ) )",
+				uselist = ["foo"],
+				opconvert = False,
+				expected_result = ['||', [['A', 'B'], 'C', 'D']]),
+
+			UseReduceTestCase(
+				"|| ( ( A B ) || ( C D ) )",
+				expected_result = ['||', [['A', 'B'], 'C', 'D']]),
+
+			UseReduceTestCase(
+				"|| ( ( A B ) || ( C D || ( E ( F G ) || ( H ) ) ) )",
+				expected_result = ['||', [['A', 'B'], 'C', 'D', 'E', ['F', 'G'], 'H']]),
+
+			UseReduceTestCase(
+				"|| ( ( A B ) || ( C D || ( E ( F G ) || ( H ) ) ) )",
+				opconvert = True,
+				expected_result = [['||', ['A', 'B'], 'C', 'D', 'E', ['F', 'G'], 'H']]),
+
+			UseReduceTestCase(
+				"|| ( foo? ( A B ) )",
+				uselist = ["foo"],
+				expected_result = ['A', 'B']),
+
+			UseReduceTestCase(
+				"|| ( || ( foo? ( A B ) ) )",
+				uselist = ["foo"],
+				expected_result = ['A', 'B']),
+
+			UseReduceTestCase(
+				"|| ( || ( || ( a? ( b? ( c? ( || ( || ( || ( d? ( e? ( f? ( A B ) ) ) ) ) ) ) ) ) ) ) )",
+				uselist = ["a", "b", "c", "d", "e", "f"],
+				expected_result = ['A', 'B']),
+
+			UseReduceTestCase(
+				"|| ( || ( ( || ( a? ( ( b? ( c? ( || ( || ( || ( ( d? ( e? ( f? ( A B ) ) ) ) ) ) ) ) ) ) ) ) ) ) )",
+				uselist = ["a", "b", "c", "d", "e", "f"],
+				expected_result = ['A', 'B']),
+
+			UseReduceTestCase(
+				"|| ( ( A ( || ( B ) ) ) )",
+				expected_result = ['A', 'B']),
+
+			UseReduceTestCase(
+				"|| ( ( A B ) || ( foo? ( bar? ( ( C D || ( baz? ( E ) ( F G ) || ( H ) ) ) ) ) ) )",
+				uselist = ["foo", "bar", "baz"],
+				expected_result = ['||', [['A', 'B'], ['C', 'D', '||', ['E', ['F', 'G'], 'H']]]]),
+
+			UseReduceTestCase(
+				"|| ( ( A B ) || ( foo? ( bar? ( ( C D || ( baz? ( E ) ( F G ) || ( H ) ) ) ) ) ) )",
+				uselist = ["foo", "bar", "baz"],
+				opconvert = True,
+				expected_result = [['||', ['A', 'B'], ['C', 'D', ['||', 'E', ['F', 'G'], 'H']]]]),
+
+			UseReduceTestCase(
+				"|| ( foo? ( A B ) )",
+				uselist = ["foo"],
+				opconvert=True,
+				expected_result = ['A', 'B']),
+
+			UseReduceTestCase(
+				"|| ( || ( foo? ( A B ) ) )",
+				uselist = ["foo"],
+				opconvert=True,
+				expected_result = ['A', 'B']),
+
+			UseReduceTestCase(
+				"|| ( || ( || ( a? ( b? ( c? ( || ( || ( || ( d? ( e? ( f? ( A B ) ) ) ) ) ) ) ) ) ) ) )",
+				uselist = ["a", "b", "c", "d", "e", "f"],
+				opconvert=True,
+				expected_result = ['A', 'B']),
+
+			#flat test
+			UseReduceTestCase(
+				"A",
+				flat = True,
+				expected_result = ["A"]),
+			UseReduceTestCase(
+				"( A )",
+				flat = True,
+				expected_result = ["A"]),
+			UseReduceTestCase(
+				"|| ( A B )",
+				flat = True,
+				expected_result = [ "||", "A", "B" ] ),
+			UseReduceTestCase(
+				"|| ( A || ( B C ) )",
+				flat = True,
+				expected_result = [ "||", "A", "||", "B", "C" ]),
+			UseReduceTestCase(
+				"|| ( A || ( B C D ) )",
+				flat = True,
+				expected_result = [ "||", "A", "||", "B", "C", "D" ]),
+			UseReduceTestCase(
+				"|| ( A || ( B || ( C D ) E ) )",
+				flat = True,
+				expected_result = [ "||", "A", "||", "B", "||", "C", "D", "E" ]),
+			UseReduceTestCase(
+				"( || ( ( ( A ) B ) ) )",
+				flat = True,
+				expected_result = [ "||", "A", "B"] ),
+			UseReduceTestCase(
+				"( || ( || ( ( A ) B ) ) )",
+				flat = True,
+				expected_result = [ "||", "||", "A", "B" ]),
+			UseReduceTestCase(
+				"( || ( || ( ( A ) B ) ) )",
+				flat = True,
+				expected_result = [ "||", "||", "A", "B" ]),
+			UseReduceTestCase(
+				"|| ( A )",
+				flat = True,
+				expected_result = ["||", "A"]),
+			UseReduceTestCase(
+				"( || ( || ( || ( A ) foo? ( B ) ) ) )",
+				expected_result = ["A"]),
+			UseReduceTestCase(
+				"( || ( || ( || ( A ) foo? ( B ) ) ) )",
+				uselist = ["foo"],
+				flat = True,
+				expected_result = [ "||", "||","||", "A", "B" ]),
+			UseReduceTestCase(
+				"( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )",
+				flat = True,
+				expected_result = ["||", "||","||"]),
+			UseReduceTestCase(
+				"( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )",
+				uselist = ["foo", "bar"],
+				flat = True,
+				expected_result = [ "||", "||", "A", "||", "B" ]),
+			UseReduceTestCase(
+				"A || ( bar? ( C ) ) foo? ( bar? ( C ) ) B",
+				flat = True,
+				expected_result = ["A", "||", "B"]),
+			UseReduceTestCase(
+				"|| ( A ) || ( B )",
+				flat = True,
+				expected_result = ["||", "A", "||", "B"]),
+			UseReduceTestCase(
+				"foo? ( A ) foo? ( B )",
+				flat = True,
+				expected_result = []),
+			UseReduceTestCase(
+				"foo? ( A ) foo? ( B )",
+				uselist = ["foo"],
+				flat = True,
+				expected_result = ["A", "B"]),
+
+			#use flag validation
+			UseReduceTestCase(
+				"foo? ( A )",
+				uselist = ["foo"],
+				is_valid_flag = self.always_true,
+				expected_result = ["A"]),
+			UseReduceTestCase(
+				"foo? ( A )",
+				is_valid_flag = self.always_true,
+				expected_result = []),
+
+			#token_class
+			UseReduceTestCase(
+				"foo? ( dev-libs/A )",
+				uselist = ["foo"],
+				token_class=Atom,
+				expected_result = ["dev-libs/A"]),
+			UseReduceTestCase(
+				"foo? ( dev-libs/A )",
+				token_class=Atom,
+				expected_result = []),
+		)
+		
+		test_cases_xfail = (
+			UseReduceTestCase("? ( A )"),
+			UseReduceTestCase("!? ( A )"),
+			UseReduceTestCase("( A"),
+			UseReduceTestCase("A )"),
+			UseReduceTestCase("||( A B )"),
+			UseReduceTestCase("|| (A B )"),
+			UseReduceTestCase("|| ( A B)"),
+			UseReduceTestCase("|| ( A B"),
+			UseReduceTestCase("|| A B )"),
+			UseReduceTestCase("|| A B"),
+			UseReduceTestCase("|| ( A B ) )"),
+			UseReduceTestCase("|| || B C"),
+			UseReduceTestCase("|| ( A B || )"),
+			UseReduceTestCase("a? A"),
+			UseReduceTestCase("( || ( || || ( A ) foo? ( B ) ) )"),
+			UseReduceTestCase("( || ( || bar? ( A ) foo? ( B ) ) )"),
+			UseReduceTestCase("foo?"),
+			UseReduceTestCase("foo? || ( A )"),
+			UseReduceTestCase("|| ( )"),
+			UseReduceTestCase("foo? ( )"),
+
+			#SRC_URI stuff
+			UseReduceTestCase("http://foo/bar -> blah.tbz2", is_src_uri = True, eapi = EAPI_WITHOUT_SRC_URI_ARROWS),
+			UseReduceTestCase("|| ( http://foo/bar -> blah.tbz2 )", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
+			UseReduceTestCase("http://foo/bar -> foo? ( ftp://foo/a )", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
+			UseReduceTestCase("http://foo/bar blah.tbz2 ->", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
+			UseReduceTestCase("-> http://foo/bar blah.tbz2 )", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
+			UseReduceTestCase("http://foo/bar ->", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
+			UseReduceTestCase("http://foo/bar -> foo? ( http://foo.com/foo )", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
+			UseReduceTestCase("foo? ( http://foo/bar -> ) blah.tbz2", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
+			UseReduceTestCase("http://foo/bar -> foo/blah.tbz2", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
+			UseReduceTestCase("http://foo/bar -> -> bar.tbz2 foo? ( ftp://foo/a )", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
+			
+			UseReduceTestCase("http://foo/bar -> bar.tbz2 foo? ( ftp://foo/a )", is_src_uri = False, eapi = EAPI_WITH_SRC_URI_ARROWS),
+
+			UseReduceTestCase(
+				"A",
+				opconvert = True,
+				flat = True),
+
+			#use flag validation
+			UseReduceTestCase("1.0? ( A )"),
+			UseReduceTestCase("!1.0? ( A )"),
+			UseReduceTestCase("!? ( A )"),
+			UseReduceTestCase("!?? ( A )"),
+			UseReduceTestCase(
+				"foo? ( A )",
+				is_valid_flag = self.always_false,
+				),
+			UseReduceTestCase(
+				"foo? ( A )",
+				uselist = ["foo"],
+				is_valid_flag = self.always_false,
+				),
+
+			#token_class
+			UseReduceTestCase(
+				"foo? ( A )",
+				uselist = ["foo"],
+				token_class=Atom),
+			UseReduceTestCase(
+				"A(B",
+				token_class=Atom),
+		)
+
+		for test_case in test_cases:
+			# If it fails then show the input, since lots of our
+			# test cases have the same output but different input,
+			# making it difficult deduce which test has failed.
+			self.assertEqual(test_case.run(), test_case.expected_result,
+				"input: '%s' result: %s != %s" % (test_case.deparray,
+				test_case.run(), test_case.expected_result))
+
+		for test_case in test_cases_xfail:
+			self.assertRaisesMsg(test_case.deparray, (InvalidDependString, ValueError), test_case.run)
diff --git a/portage_with_autodep/pym/portage/tests/ebuild/__init__.py b/portage_with_autodep/pym/portage/tests/ebuild/__init__.py
new file mode 100644
index 0000000..e2d487e
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/ebuild/__init__.py
@@ -0,0 +1,2 @@
+# Copyright 1998-2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
diff --git a/portage_with_autodep/pym/portage/tests/ebuild/__test__ b/portage_with_autodep/pym/portage/tests/ebuild/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/ebuild/__test__
diff --git a/portage_with_autodep/pym/portage/tests/ebuild/test_array_fromfile_eof.py b/portage_with_autodep/pym/portage/tests/ebuild/test_array_fromfile_eof.py
new file mode 100644
index 0000000..d8277f2
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/ebuild/test_array_fromfile_eof.py
@@ -0,0 +1,43 @@
+# Copyright 2009 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import array
+import tempfile
+
+from portage import _unicode_decode
+from portage import _unicode_encode
+from portage.tests import TestCase
+
+class ArrayFromfileEofTestCase(TestCase):
+
+	def testArrayFromfileEof(self):
+		# This tests if the following python issue is fixed
+		# in the currently running version of python:
+		#   http://bugs.python.org/issue5334
+
+		input_data = "an arbitrary string"
+		input_bytes = _unicode_encode(input_data,
+			encoding='utf_8', errors='strict')
+		f = tempfile.TemporaryFile()
+		f.write(input_bytes)
+
+		f.seek(0)
+		data = []
+		eof = False
+		while not eof:
+			a = array.array('B')
+			try:
+				a.fromfile(f, len(input_bytes) + 1)
+			except (EOFError, IOError):
+				# python-3.0 lost data here
+				eof = True
+
+			if not a:
+				eof = True
+			else:
+				data.append(_unicode_decode(a.tostring(),
+					encoding='utf_8', errors='strict'))
+
+		f.close()
+
+		self.assertEqual(input_data, ''.join(data))
diff --git a/portage_with_autodep/pym/portage/tests/ebuild/test_config.py b/portage_with_autodep/pym/portage/tests/ebuild/test_config.py
new file mode 100644
index 0000000..7bec8c6
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/ebuild/test_config.py
@@ -0,0 +1,198 @@
+# Copyright 2010-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import portage
+from portage import os
+from portage.package.ebuild.config import config
+from portage.package.ebuild._config.LicenseManager import LicenseManager
+from portage.tests import TestCase
+from portage.tests.resolver.ResolverPlayground import ResolverPlayground, ResolverPlaygroundTestCase
+
+class ConfigTestCase(TestCase):
+
+	def testClone(self):
+		"""
+		Test the clone via constructor.
+		"""
+
+		ebuilds = {
+			"dev-libs/A-1": { },
+		}
+
+		playground = ResolverPlayground(ebuilds=ebuilds)
+		try:
+			settings = config(clone=playground.settings)
+			result = playground.run(["=dev-libs/A-1"])
+			pkg, existing_node = result.depgraph._select_package(
+				playground.root, "=dev-libs/A-1")
+			settings.setcpv(pkg)
+
+			# clone after setcpv tests deepcopy of LazyItemsDict
+			settings2 = config(clone=settings)
+		finally:
+			playground.cleanup()
+
+	def testFeaturesMutation(self):
+		"""
+		Test whether mutation of config.features updates the FEATURES
+		variable and persists through config.regenerate() calls. Also
+		verify that features_set._prune_overrides() works correctly.
+		"""
+		playground = ResolverPlayground()
+		try:
+			settings = config(clone=playground.settings)
+
+			settings.features.add('noclean')
+			self.assertEqual('noclean' in settings['FEATURES'].split(), True)
+			settings.regenerate()
+			self.assertEqual('noclean' in settings['FEATURES'].split(),True)
+
+			settings.features.discard('noclean')
+			self.assertEqual('noclean' in settings['FEATURES'].split(), False)
+			settings.regenerate()
+			self.assertEqual('noclean' in settings['FEATURES'].split(), False)
+
+			settings.features.add('noclean')
+			self.assertEqual('noclean' in settings['FEATURES'].split(), True)
+			settings.regenerate()
+			self.assertEqual('noclean' in settings['FEATURES'].split(),True)
+
+			# before: ['noclean', '-noclean', 'noclean']
+			settings.features._prune_overrides()
+			#  after: ['noclean']
+			self.assertEqual(settings._features_overrides.count('noclean'), 1)
+			self.assertEqual(settings._features_overrides.count('-noclean'), 0)
+
+			settings.features.remove('noclean')
+
+			# before: ['noclean', '-noclean']
+			settings.features._prune_overrides()
+			#  after: ['-noclean']
+			self.assertEqual(settings._features_overrides.count('noclean'), 0)
+			self.assertEqual(settings._features_overrides.count('-noclean'), 1)
+		finally:
+			playground.cleanup()
+
+	def testLicenseManager(self):
+
+		user_config = {
+			"package.license":
+				(
+					"dev-libs/* TEST",
+					"dev-libs/A -TEST2", 
+					"=dev-libs/A-2 TEST3 @TEST",
+					"*/* @EULA TEST2",
+					"=dev-libs/C-1 *",
+					"=dev-libs/C-2 -*",
+				),
+		}
+
+		playground = ResolverPlayground(user_config=user_config)
+		try:
+			portage.util.noiselimit = -2
+
+			license_group_locations = (os.path.join(playground.portdir, "profiles"),)
+			pkg_license = os.path.join(playground.eroot, "etc", "portage")
+
+			lic_man = LicenseManager(license_group_locations, pkg_license)
+
+			self.assertEqual(lic_man._accept_license_str, None)
+			self.assertEqual(lic_man._accept_license, None)
+			self.assertEqual(lic_man._license_groups, {"EULA": frozenset(["TEST"])})
+			self.assertEqual(lic_man._undef_lic_groups, set(["TEST"]))
+
+			self.assertEqual(lic_man.extract_global_changes(), "TEST TEST2")
+			self.assertEqual(lic_man.extract_global_changes(), "")
+
+			lic_man.set_accept_license_str("TEST TEST2")
+			self.assertEqual(lic_man._getPkgAcceptLicense("dev-libs/B-1", "0", None), ["TEST", "TEST2", "TEST"])
+			self.assertEqual(lic_man._getPkgAcceptLicense("dev-libs/A-1", "0", None), ["TEST", "TEST2", "TEST", "-TEST2"])
+			self.assertEqual(lic_man._getPkgAcceptLicense("dev-libs/A-2", "0", None), ["TEST", "TEST2", "TEST", "-TEST2", "TEST3", "@TEST"])
+
+			self.assertEqual(lic_man.get_prunned_accept_license("dev-libs/B-1", [], "TEST", "0", None), "TEST")
+			self.assertEqual(lic_man.get_prunned_accept_license("dev-libs/A-1", [], "-TEST2", "0", None), "")
+			self.assertEqual(lic_man.get_prunned_accept_license("dev-libs/A-2", [], "|| ( TEST TEST2 )", "0", None), "TEST")
+			self.assertEqual(lic_man.get_prunned_accept_license("dev-libs/C-1", [], "TEST5", "0", None), "TEST5")
+			self.assertEqual(lic_man.get_prunned_accept_license("dev-libs/C-2", [], "TEST2", "0", None), "")
+
+			self.assertEqual(lic_man.getMissingLicenses("dev-libs/B-1", [], "TEST", "0", None), [])
+			self.assertEqual(lic_man.getMissingLicenses("dev-libs/A-1", [], "-TEST2", "0", None), ["-TEST2"])
+			self.assertEqual(lic_man.getMissingLicenses("dev-libs/A-2", [], "|| ( TEST TEST2 )", "0", None), [])
+			self.assertEqual(lic_man.getMissingLicenses("dev-libs/A-3", [], "|| ( TEST2 || ( TEST3 TEST4 ) )", "0", None), ["TEST2", "TEST3", "TEST4"])
+			self.assertEqual(lic_man.getMissingLicenses("dev-libs/C-1", [], "TEST5", "0", None), [])
+			self.assertEqual(lic_man.getMissingLicenses("dev-libs/C-2", [], "TEST2", "0", None), ["TEST2"])
+			self.assertEqual(lic_man.getMissingLicenses("dev-libs/D-1", [], "", "0", None), [])
+		finally:
+			portage.util.noiselimit = 0
+			playground.cleanup()
+
+	def testPackageMaskOrder(self):
+
+		ebuilds = {
+			"dev-libs/A-1": { },
+			"dev-libs/B-1": { },
+			"dev-libs/C-1": { },
+			"dev-libs/D-1": { },
+			"dev-libs/E-1": { },
+		}
+
+		repo_configs = {
+			"test_repo": {
+				"package.mask":
+					(
+						"dev-libs/A",
+						"dev-libs/C",
+					),
+			}
+		}
+
+		profile = {
+			"package.mask":
+				(
+					"-dev-libs/A",
+					"dev-libs/B",
+					"-dev-libs/B",
+					"dev-libs/D",
+				),
+		}
+
+		user_config = {
+			"package.mask":
+				(
+					"-dev-libs/C",
+					"-dev-libs/D",
+					"dev-libs/E",
+				),
+		}
+
+		test_cases = (
+				ResolverPlaygroundTestCase(
+					["dev-libs/A"],
+					options = { "--autounmask": 'n' },
+					success = False),
+				ResolverPlaygroundTestCase(
+					["dev-libs/B"],
+					success = True,
+					mergelist = ["dev-libs/B-1"]),
+				ResolverPlaygroundTestCase(
+					["dev-libs/C"],
+					success = True,
+					mergelist = ["dev-libs/C-1"]),
+				ResolverPlaygroundTestCase(
+					["dev-libs/D"],
+					success = True,
+					mergelist = ["dev-libs/D-1"]),
+				ResolverPlaygroundTestCase(
+					["dev-libs/E"],
+					options = { "--autounmask": 'n' },
+					success = False),
+		)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, repo_configs=repo_configs, \
+			profile=profile, 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()
diff --git a/portage_with_autodep/pym/portage/tests/ebuild/test_doebuild_spawn.py b/portage_with_autodep/pym/portage/tests/ebuild/test_doebuild_spawn.py
new file mode 100644
index 0000000..ed08b2a
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/ebuild/test_doebuild_spawn.py
@@ -0,0 +1,82 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage import os
+from portage import _python_interpreter
+from portage import _shell_quote
+from portage.const import EBUILD_SH_BINARY
+from portage.package.ebuild.config import config
+from portage.package.ebuild.doebuild import spawn as doebuild_spawn
+from portage.tests import TestCase
+from portage.tests.resolver.ResolverPlayground import ResolverPlayground
+from _emerge.EbuildPhase import EbuildPhase
+from _emerge.MiscFunctionsProcess import MiscFunctionsProcess
+from _emerge.Package import Package
+from _emerge.PollScheduler import PollScheduler
+
+class DoebuildSpawnTestCase(TestCase):
+	"""
+	Invoke portage.package.ebuild.doebuild.spawn() with a
+	minimal environment. This gives coverage to some of
+	the ebuild execution internals, like ebuild.sh,
+	AbstractEbuildProcess, and EbuildIpcDaemon.
+	"""
+
+	def testDoebuildSpawn(self):
+		playground = ResolverPlayground()
+		try:
+			settings = config(clone=playground.settings)
+			cpv = 'sys-apps/portage-2.1'
+			metadata = {
+				'EAPI'      : '2',
+				'INHERITED' : 'python eutils',
+				'IUSE'      : 'build doc epydoc python3 selinux',
+				'LICENSE'   : 'GPL-2',
+				'PROVIDE'   : 'virtual/portage',
+				'RDEPEND'   : '>=app-shells/bash-3.2_p17 >=dev-lang/python-2.6',
+				'SLOT'      : '0',
+			}
+			root_config = playground.trees[playground.root]['root_config']
+			pkg = Package(built=False, cpv=cpv, installed=False,
+				metadata=metadata, root_config=root_config,
+				type_name='ebuild')
+			settings.setcpv(pkg)
+			settings['PORTAGE_PYTHON'] = _python_interpreter
+			settings['PORTAGE_BUILDDIR'] = os.path.join(
+				settings['PORTAGE_TMPDIR'], cpv)
+			settings['T'] = os.path.join(
+				settings['PORTAGE_BUILDDIR'], 'temp')
+			for x in ('PORTAGE_BUILDDIR', 'T'):
+				os.makedirs(settings[x])
+			# Create a fake environment, to pretend as if the ebuild
+			# has been sourced already.
+			open(os.path.join(settings['T'], 'environment'), 'wb')
+
+			scheduler = PollScheduler().sched_iface
+			for phase in ('_internal_test',):
+
+				# Test EbuildSpawnProcess by calling doebuild.spawn() with
+				# returnpid=False. This case is no longer used by portage
+				# internals since EbuildPhase is used instead and that passes
+				# returnpid=True to doebuild.spawn().
+				rval = doebuild_spawn("%s %s" % (_shell_quote(
+					os.path.join(settings["PORTAGE_BIN_PATH"],
+					os.path.basename(EBUILD_SH_BINARY))), phase),
+					settings, free=1)
+				self.assertEqual(rval, os.EX_OK)
+
+				ebuild_phase = EbuildPhase(background=False,
+					phase=phase, scheduler=scheduler,
+					settings=settings)
+				ebuild_phase.start()
+				ebuild_phase.wait()
+				self.assertEqual(ebuild_phase.returncode, os.EX_OK)
+
+			ebuild_phase = MiscFunctionsProcess(background=False,
+				commands=['success_hooks'],
+				scheduler=scheduler, settings=settings)
+			ebuild_phase.start()
+			ebuild_phase.wait()
+			self.assertEqual(ebuild_phase.returncode, os.EX_OK)
+		finally:
+			playground.cleanup()
diff --git a/portage_with_autodep/pym/portage/tests/ebuild/test_ipc_daemon.py b/portage_with_autodep/pym/portage/tests/ebuild/test_ipc_daemon.py
new file mode 100644
index 0000000..b5b4796
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/ebuild/test_ipc_daemon.py
@@ -0,0 +1,124 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import shutil
+import tempfile
+import time
+from portage import os
+from portage import _python_interpreter
+from portage.tests import TestCase
+from portage.const import PORTAGE_BIN_PATH
+from portage.const import PORTAGE_PYM_PATH
+from portage.const import BASH_BINARY
+from portage.package.ebuild._ipc.ExitCommand import ExitCommand
+from portage.util import ensure_dirs
+from _emerge.SpawnProcess import SpawnProcess
+from _emerge.EbuildBuildDir import EbuildBuildDir
+from _emerge.EbuildIpcDaemon import EbuildIpcDaemon
+from _emerge.TaskScheduler import TaskScheduler
+
+class IpcDaemonTestCase(TestCase):
+
+	_SCHEDULE_TIMEOUT = 40000 # 40 seconds
+
+	def testIpcDaemon(self):
+		tmpdir = tempfile.mkdtemp()
+		build_dir = None
+		try:
+			env = {}
+
+			# Pass along PORTAGE_USERNAME and PORTAGE_GRPNAME since they
+			# need to be inherited by ebuild subprocesses.
+			if 'PORTAGE_USERNAME' in os.environ:
+				env['PORTAGE_USERNAME'] = os.environ['PORTAGE_USERNAME']
+			if 'PORTAGE_GRPNAME' in os.environ:
+				env['PORTAGE_GRPNAME'] = os.environ['PORTAGE_GRPNAME']
+
+			env['PORTAGE_PYTHON'] = _python_interpreter
+			env['PORTAGE_BIN_PATH'] = PORTAGE_BIN_PATH
+			env['PORTAGE_PYM_PATH'] = PORTAGE_PYM_PATH
+			env['PORTAGE_BUILDDIR'] = os.path.join(tmpdir, 'cat', 'pkg-1')
+
+			task_scheduler = TaskScheduler(max_jobs=2)
+			build_dir = EbuildBuildDir(
+				scheduler=task_scheduler.sched_iface,
+				settings=env)
+			build_dir.lock()
+			ensure_dirs(env['PORTAGE_BUILDDIR'])
+
+			input_fifo = os.path.join(env['PORTAGE_BUILDDIR'], '.ipc_in')
+			output_fifo = os.path.join(env['PORTAGE_BUILDDIR'], '.ipc_out')
+			os.mkfifo(input_fifo)
+			os.mkfifo(output_fifo)
+
+			for exitcode in (0, 1, 2):
+				exit_command = ExitCommand()
+				commands = {'exit' : exit_command}
+				daemon = EbuildIpcDaemon(commands=commands,
+					input_fifo=input_fifo,
+					output_fifo=output_fifo,
+					scheduler=task_scheduler.sched_iface)
+				proc = SpawnProcess(
+					args=[BASH_BINARY, "-c",
+					'"$PORTAGE_BIN_PATH"/ebuild-ipc exit %d' % exitcode],
+					env=env, scheduler=task_scheduler.sched_iface)
+
+				self.received_command = False
+				def exit_command_callback():
+					self.received_command = True
+					proc.cancel()
+					daemon.cancel()
+
+				exit_command.reply_hook = exit_command_callback
+				task_scheduler.add(daemon)
+				task_scheduler.add(proc)
+				start_time = time.time()
+				task_scheduler.run(timeout=self._SCHEDULE_TIMEOUT)
+				task_scheduler.clear()
+
+				self.assertEqual(self.received_command, True,
+					"command not received after %d seconds" % \
+					(time.time() - start_time,))
+				self.assertEqual(proc.isAlive(), False)
+				self.assertEqual(daemon.isAlive(), False)
+				self.assertEqual(exit_command.exitcode, exitcode)
+
+			# Intentionally short timeout test for QueueScheduler.run()
+			sleep_time_s = 10      # 10.000 seconds
+			short_timeout_ms = 10  #  0.010 seconds
+
+			for i in range(3):
+				exit_command = ExitCommand()
+				commands = {'exit' : exit_command}
+				daemon = EbuildIpcDaemon(commands=commands,
+					input_fifo=input_fifo,
+					output_fifo=output_fifo,
+					scheduler=task_scheduler.sched_iface)
+				proc = SpawnProcess(
+					args=[BASH_BINARY, "-c", 'exec sleep %d' % sleep_time_s],
+					env=env, scheduler=task_scheduler.sched_iface)
+
+				self.received_command = False
+				def exit_command_callback():
+					self.received_command = True
+					proc.cancel()
+					daemon.cancel()
+
+				exit_command.reply_hook = exit_command_callback
+				task_scheduler.add(daemon)
+				task_scheduler.add(proc)
+				start_time = time.time()
+				task_scheduler.run(timeout=short_timeout_ms)
+				task_scheduler.clear()
+
+				self.assertEqual(self.received_command, False,
+					"command received after %d seconds" % \
+					(time.time() - start_time,))
+				self.assertEqual(proc.isAlive(), False)
+				self.assertEqual(daemon.isAlive(), False)
+				self.assertEqual(proc.returncode == os.EX_OK, False)
+
+		finally:
+			if build_dir is not None:
+				build_dir.unlock()
+			shutil.rmtree(tmpdir)
diff --git a/portage_with_autodep/pym/portage/tests/ebuild/test_pty_eof.py b/portage_with_autodep/pym/portage/tests/ebuild/test_pty_eof.py
new file mode 100644
index 0000000..4b6ff21
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/ebuild/test_pty_eof.py
@@ -0,0 +1,32 @@
+# Copyright 2009-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.util._pty import _can_test_pty_eof, _test_pty_eof
+
+class PtyEofFdopenBufferedTestCase(TestCase):
+
+	def testPtyEofFdopenBuffered(self):
+		# This tests if the following python issue is fixed yet:
+		#   http://bugs.python.org/issue5380
+		# Since it might not be fixed, mark as todo.
+		self.todo = True
+		# The result is only valid if openpty does not raise EnvironmentError.
+		if _can_test_pty_eof():
+			try:
+				self.assertEqual(_test_pty_eof(fdopen_buffered=True), True)
+			except EnvironmentError:
+				pass
+
+class PtyEofFdopenUnBufferedTestCase(TestCase):
+	def testPtyEofFdopenUnBuffered(self):
+		# New development: It appears that array.fromfile() is usable
+		# with python3 as long as fdopen is called with a bufsize
+		# argument of 0.
+
+		# The result is only valid if openpty does not raise EnvironmentError.
+		if _can_test_pty_eof():
+			try:
+				self.assertEqual(_test_pty_eof(), True)
+			except EnvironmentError:
+				pass
diff --git a/portage_with_autodep/pym/portage/tests/ebuild/test_spawn.py b/portage_with_autodep/pym/portage/tests/ebuild/test_spawn.py
new file mode 100644
index 0000000..fea4738
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/ebuild/test_spawn.py
@@ -0,0 +1,52 @@
+# Copyright 1998-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import errno
+import io
+import sys
+import tempfile
+from portage import os
+from portage import _encodings
+from portage import _unicode_encode
+from portage.const import BASH_BINARY
+from portage.tests import TestCase
+from _emerge.SpawnProcess import SpawnProcess
+from _emerge.PollScheduler import PollScheduler
+
+class SpawnTestCase(TestCase):
+
+	def testLogfile(self):
+		logfile = None
+		try:
+			fd, logfile = tempfile.mkstemp()
+			os.close(fd)
+			null_fd = os.open('/dev/null', os.O_RDWR)
+			test_string = 2 * "blah blah blah\n"
+			scheduler = PollScheduler().sched_iface
+			proc = SpawnProcess(
+				args=[BASH_BINARY, "-c",
+				"echo -n '%s'" % test_string],
+				env={}, fd_pipes={0:sys.stdin.fileno(), 1:null_fd, 2:null_fd},
+				scheduler=scheduler,
+				logfile=logfile)
+			proc.start()
+			os.close(null_fd)
+			self.assertEqual(proc.wait(), os.EX_OK)
+			f = io.open(_unicode_encode(logfile,
+				encoding=_encodings['fs'], errors='strict'),
+				mode='r', encoding=_encodings['content'], errors='strict')
+			log_content = f.read()
+			f.close()
+			# When logging passes through a pty, this comparison will fail
+			# unless the oflag terminal attributes have the termios.OPOST
+			# bit disabled. Otherwise, tranformations such as \n -> \r\n
+			# may occur.
+			self.assertEqual(test_string, log_content)
+		finally:
+			if logfile:
+				try:
+					os.unlink(logfile)
+				except EnvironmentError as e:
+					if e.errno != errno.ENOENT:
+						raise
+					del e
diff --git a/portage_with_autodep/pym/portage/tests/env/__init__.py b/portage_with_autodep/pym/portage/tests/env/__init__.py
new file mode 100644
index 0000000..cbeabe5
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/env/__init__.py
@@ -0,0 +1,4 @@
+# tests/portage/env/__init__.py -- Portage Unit Test functionality
+# Copyright 2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
diff --git a/portage_with_autodep/pym/portage/tests/env/__test__ b/portage_with_autodep/pym/portage/tests/env/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/env/__test__
diff --git a/portage_with_autodep/pym/portage/tests/env/config/__init__.py b/portage_with_autodep/pym/portage/tests/env/config/__init__.py
new file mode 100644
index 0000000..ef5cc43
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/env/config/__init__.py
@@ -0,0 +1,4 @@
+# tests/portage/env/config/__init__.py -- Portage Unit Test functionality
+# Copyright 2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
diff --git a/portage_with_autodep/pym/portage/tests/env/config/__test__ b/portage_with_autodep/pym/portage/tests/env/config/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/env/config/__test__
diff --git a/portage_with_autodep/pym/portage/tests/env/config/test_PackageKeywordsFile.py b/portage_with_autodep/pym/portage/tests/env/config/test_PackageKeywordsFile.py
new file mode 100644
index 0000000..f1e9e98
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/env/config/test_PackageKeywordsFile.py
@@ -0,0 +1,40 @@
+# test_PackageKeywordsFile.py -- Portage Unit Testing Functionality
+# Copyright 2006 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage import os
+from portage.tests import TestCase
+from portage.env.config import PackageKeywordsFile
+from tempfile import mkstemp
+
+class PackageKeywordsFileTestCase(TestCase):
+
+	cpv = ['sys-apps/portage']
+	keywords = ['~x86', 'amd64', '-mips']
+	
+	def testPackageKeywordsFile(self):
+		"""
+		A simple test to ensure the load works properly
+		"""
+
+		self.BuildFile()
+		try:
+			f = PackageKeywordsFile(self.fname)
+			f.load()
+			i = 0
+			for cpv, keyword in f.items():
+				self.assertEqual( cpv, self.cpv[i] )
+				[k for k in keyword if self.assertTrue(k in self.keywords)]
+				i = i + 1
+		finally:
+			self.NukeFile()
+	
+	def BuildFile(self):
+		fd, self.fname = mkstemp()
+		f = os.fdopen(fd, 'w')
+		for c in self.cpv:
+			f.write("%s %s\n" % (c,' '.join(self.keywords)))
+		f.close()
+
+	def NukeFile(self):
+		os.unlink(self.fname)
diff --git a/portage_with_autodep/pym/portage/tests/env/config/test_PackageMaskFile.py b/portage_with_autodep/pym/portage/tests/env/config/test_PackageMaskFile.py
new file mode 100644
index 0000000..0c5b30f
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/env/config/test_PackageMaskFile.py
@@ -0,0 +1,29 @@
+# test_PackageMaskFile.py -- Portage Unit Testing Functionality
+# Copyright 2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage import os
+from portage.env.config import PackageMaskFile
+from portage.tests import TestCase, test_cps
+from tempfile import mkstemp
+
+class PackageMaskFileTestCase(TestCase):
+	
+	def testPackageMaskFile(self):
+		self.BuildFile()
+		try:
+			f = PackageMaskFile(self.fname)
+			f.load()
+			for atom in f:
+				self.assertTrue(atom in test_cps)
+		finally:
+			self.NukeFile()
+	
+	def BuildFile(self):
+		fd, self.fname = mkstemp()
+		f = os.fdopen(fd, 'w')
+		f.write("\n".join(test_cps))
+		f.close()
+	
+	def NukeFile(self):
+		os.unlink(self.fname)
diff --git a/portage_with_autodep/pym/portage/tests/env/config/test_PackageUseFile.py b/portage_with_autodep/pym/portage/tests/env/config/test_PackageUseFile.py
new file mode 100644
index 0000000..7a38067
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/env/config/test_PackageUseFile.py
@@ -0,0 +1,37 @@
+# test_PackageUseFile.py -- Portage Unit Testing Functionality
+# Copyright 2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage import os
+from portage.tests import TestCase
+from portage.env.config import PackageUseFile
+from tempfile import mkstemp
+
+
+class PackageUseFileTestCase(TestCase):
+
+	cpv = 'sys-apps/portage'
+	useflags = ['cdrom', 'far', 'boo', 'flag', 'blat']
+	
+	def testPackageUseFile(self):
+		"""
+		A simple test to ensure the load works properly
+		"""
+		self.BuildFile()
+		try:
+			f = PackageUseFile(self.fname)
+			f.load()
+			for cpv, use in f.items():
+				self.assertEqual( cpv, self.cpv )
+				[flag for flag in use if self.assertTrue(flag in self.useflags)]
+		finally:
+			self.NukeFile()
+
+	def BuildFile(self):
+		fd, self.fname = mkstemp()
+		f = os.fdopen(fd, 'w')
+		f.write("%s %s" % (self.cpv, ' '.join(self.useflags)))
+		f.close()
+	
+	def NukeFile(self):
+		os.unlink(self.fname)
diff --git a/portage_with_autodep/pym/portage/tests/env/config/test_PortageModulesFile.py b/portage_with_autodep/pym/portage/tests/env/config/test_PortageModulesFile.py
new file mode 100644
index 0000000..2cd1a8a
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/env/config/test_PortageModulesFile.py
@@ -0,0 +1,39 @@
+# Copyright 2006-2009 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage import os
+from portage.tests import TestCase
+from portage.env.config import PortageModulesFile
+from tempfile import mkstemp
+
+class PortageModulesFileTestCase(TestCase):
+
+	keys = ['foo.bar','baz','bob','extra_key']
+	invalid_keys = ['',""]
+	modules = ['spanky','zmedico','antarus','ricer','5','6']
+
+	def setUp(self):
+		self.items = {}
+		for k, v in zip(self.keys + self.invalid_keys, 
+				self.modules):
+			self.items[k] = v
+
+	def testPortageModulesFile(self):
+		self.BuildFile()
+		f = PortageModulesFile(self.fname)
+		f.load()
+		for k in self.keys:
+			self.assertEqual(f[k], self.items[k])
+		for ik in self.invalid_keys:
+			self.assertEqual(False, ik in f)
+		self.NukeFile()
+
+	def BuildFile(self):
+		fd, self.fname = mkstemp()
+		f = os.fdopen(fd, 'w')
+		for k, v in self.items.items():
+			f.write('%s=%s\n' % (k,v))
+		f.close()
+
+	def NukeFile(self):
+		os.unlink(self.fname)
diff --git a/portage_with_autodep/pym/portage/tests/lafilefixer/__init__.py b/portage_with_autodep/pym/portage/tests/lafilefixer/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/lafilefixer/__init__.py
diff --git a/portage_with_autodep/pym/portage/tests/lafilefixer/__test__ b/portage_with_autodep/pym/portage/tests/lafilefixer/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/lafilefixer/__test__
diff --git a/portage_with_autodep/pym/portage/tests/lafilefixer/test_lafilefixer.py b/portage_with_autodep/pym/portage/tests/lafilefixer/test_lafilefixer.py
new file mode 100644
index 0000000..0bcffaa
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/lafilefixer/test_lafilefixer.py
@@ -0,0 +1,145 @@
+# test_lafilefixer.py -- Portage Unit Testing Functionality
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.exception import InvalidData
+
+class test_lafilefixer(TestCase):
+
+	def get_test_cases_clean(self):
+		yield b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' -lm'\n" + \
+			b"current=6\n" + \
+			b"age=0\n" + \
+			b"revision=2\n" + \
+			b"installed=yes\n" + \
+			b"dlopen=''\n" + \
+			b"dlpreopen=''\n" + \
+			b"libdir='/usr/lib64'\n"
+		yield b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' -lm'\n" + \
+			b"current=6\n" + \
+			b"age=0\n" + \
+			b"revision=2\n" + \
+			b"installed=yes\n" + \
+			b"dlopen=''\n" + \
+			b"dlpreopen=''\n" + \
+			b"libdir='/usr/lib64'\n"
+		yield b"dependency_libs=' liba.la /usr/lib64/bar.la -lc'\n"
+
+	def get_test_cases_update(self):
+		#.la -> -l*
+		yield b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' /usr/lib64/liba.la /usr/lib64/libb.la -lc'\n", \
+			b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' -L/usr/lib64 -la -lb -lc'\n"
+		#move stuff into inherited_linker_flags
+		yield b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' /usr/lib64/liba.la -pthread /usr/lib64/libb.la -lc'\n" + \
+			b"inherited_linker_flags=''\n", \
+			b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' -L/usr/lib64 -la -lb -lc'\n" + \
+			b"inherited_linker_flags=' -pthread'\n"
+		#reorder 
+		yield b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' /usr/lib64/liba.la -R/usr/lib64 /usr/lib64/libb.la -lc'\n", \
+			b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' -R/usr/lib64 -L/usr/lib64 -la -lb -lc'\n"
+		#remove duplicates from dependency_libs (the original version didn't do it for inherited_linker_flags)
+		yield b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' /usr/lib64/liba.la /usr/lib64/libc.la -pthread -mt" + \
+			b" -L/usr/lib -R/usr/lib64 -lc /usr/lib64/libb.la -lc'\n" +\
+			b"inherited_linker_flags=' -pthread -pthread'\n", \
+			b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' -R/usr/lib64 -L/usr/lib64 -L/usr/lib -la -lc -lb'\n" +\
+			b"inherited_linker_flags=' -pthread -pthread -mt'\n"
+		#-L rewriting
+		yield b"dependency_libs=' -L/usr/X11R6/lib'\n", \
+			b"dependency_libs=' -L/usr/lib'\n"
+		yield b"dependency_libs=' -L/usr/local/lib'\n", \
+			b"dependency_libs=' -L/usr/lib'\n"
+		yield b"dependency_libs=' -L/usr/lib64/pkgconfig/../..'\n", \
+			b"dependency_libs=' -L/usr'\n"
+		yield b"dependency_libs=' -L/usr/lib/pkgconfig/..'\n", \
+			b"dependency_libs=' -L/usr/lib'\n"
+		yield b"dependency_libs=' -L/usr/lib/pkgconfig/../.. -L/usr/lib/pkgconfig/..'\n", \
+			b"dependency_libs=' -L/usr -L/usr/lib'\n"
+		#we once got a backtrace on this one
+		yield b"dependency_libs=' /usr/lib64/libMagickCore.la -L/usr/lib64 -llcms2 /usr/lib64/libtiff.la " + \
+			b"-ljbig -lc /usr/lib64/libfreetype.la /usr/lib64/libjpeg.la /usr/lib64/libXext.la " + \
+			b"/usr/lib64/libXt.la /usr/lib64/libSM.la -lICE -luuid /usr/lib64/libICE.la /usr/lib64/libX11.la " + \
+			b"/usr/lib64/libxcb.la /usr/lib64/libXau.la /usr/lib64/libXdmcp.la -lbz2 -lz -lm " + \
+			b"/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.4/libgomp.la -lrt -lpthread /usr/lib64/libltdl.la -ldl " + \
+			b"/usr/lib64/libfpx.la -lstdc++'", \
+			b"dependency_libs=' -L/usr/lib64 -L/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.4 -lMagickCore -llcms2 " + \
+			b"-ltiff -ljbig -lc -lfreetype -ljpeg -lXext -lXt -lSM -lICE -luuid -lX11 -lxcb -lXau -lXdmcp " + \
+			b"-lbz2 -lz -lm -lgomp -lrt -lpthread -lltdl -ldl -lfpx -lstdc++'"
+
+
+	def get_test_cases_broken(self):
+		yield b""
+		#no dependency_libs
+		yield b"dlname='libfoo.so.1'\n" + \
+			b"current=6\n" + \
+			b"age=0\n" + \
+			b"revision=2\n"
+		#borken dependency_libs
+		yield b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' /usr/lib64/liba.la /usr/lib64/libb.la -lc' \n"
+			#borken dependency_libs
+		yield b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' /usr/lib64/liba.la /usr/lib64/libb.la -lc\n"
+		#crap in dependency_libs
+		yield b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' /usr/lib64/liba.la /usr/lib64/libb.la -lc /-lstdc++'\n"
+		#dependency_libs twice
+		yield b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"dependency_libs=' /usr/lib64/liba.la /usr/lib64/libb.la -lc /-lstdc++'\n" +\
+			b"dependency_libs=' /usr/lib64/liba.la /usr/lib64/libb.la -lc /-lstdc++'\n"
+		#inherited_linker_flags twice
+		yield b"dlname='libfoo.so.1'\n" + \
+			b"library_names='libfoo.so.1.0.2 libfoo.so.1 libfoo.so'\n" + \
+			b"old_library='libpdf.a'\n" + \
+			b"inherited_linker_flags=''\n" +\
+			b"inherited_linker_flags=''\n"
+
+	def testlafilefixer(self):
+		from portage.util.lafilefixer import _parse_lafile_contents, rewrite_lafile
+
+		for clean_contents in self.get_test_cases_clean():
+			self.assertEqual(rewrite_lafile(clean_contents), (False, None))
+
+		for original_contents, fixed_contents in self.get_test_cases_update():
+			self.assertEqual(rewrite_lafile(original_contents), (True, fixed_contents))
+
+		for broken_contents in self.get_test_cases_broken():
+			self.assertRaises(InvalidData, rewrite_lafile, broken_contents)
diff --git a/portage_with_autodep/pym/portage/tests/lazyimport/__init__.py b/portage_with_autodep/pym/portage/tests/lazyimport/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/lazyimport/__init__.py
diff --git a/portage_with_autodep/pym/portage/tests/lazyimport/__test__ b/portage_with_autodep/pym/portage/tests/lazyimport/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/lazyimport/__test__
diff --git a/portage_with_autodep/pym/portage/tests/lazyimport/test_lazy_import_portage_baseline.py b/portage_with_autodep/pym/portage/tests/lazyimport/test_lazy_import_portage_baseline.py
new file mode 100644
index 0000000..08ccfa7
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/lazyimport/test_lazy_import_portage_baseline.py
@@ -0,0 +1,81 @@
+# Copyright 2010-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import re
+import portage
+from portage import os
+from portage.const import PORTAGE_PYM_PATH
+from portage.tests import TestCase
+
+from _emerge.PollScheduler import PollScheduler
+from _emerge.PipeReader import PipeReader
+from _emerge.SpawnProcess import SpawnProcess
+
+class LazyImportPortageBaselineTestCase(TestCase):
+
+	_module_re = re.compile(r'^(portage|repoman|_emerge)\.')
+
+	_baseline_imports = frozenset([
+		'portage.const', 'portage.localization',
+		'portage.proxy', 'portage.proxy.lazyimport',
+		'portage.proxy.objectproxy',
+		'portage._selinux',
+	])
+
+	_baseline_import_cmd = [portage._python_interpreter, '-c', '''
+import os
+import sys
+sys.path.insert(0, os.environ["PORTAGE_PYM_PATH"])
+import portage
+sys.stdout.write(" ".join(k for k in sys.modules
+	if sys.modules[k] is not None))
+''']
+
+	def testLazyImportPortageBaseline(self):
+		"""
+		Check what modules are imported by a baseline module import.
+		"""
+
+		env = os.environ.copy()
+		pythonpath = env.get('PYTHONPATH')
+		if pythonpath is not None and not pythonpath.strip():
+			pythonpath = None
+		if pythonpath is None:
+			pythonpath = ''
+		else:
+			pythonpath = ':' + pythonpath
+		pythonpath = PORTAGE_PYM_PATH + pythonpath
+		env[pythonpath] = pythonpath
+
+		# If python is patched to insert the path of the
+		# currently installed portage module into sys.path,
+		# then the above PYTHONPATH override doesn't help.
+		env['PORTAGE_PYM_PATH'] = PORTAGE_PYM_PATH
+
+		scheduler = PollScheduler().sched_iface
+		master_fd, slave_fd = os.pipe()
+		master_file = os.fdopen(master_fd, 'rb', 0)
+		slave_file = os.fdopen(slave_fd, 'wb')
+		producer = SpawnProcess(
+			args=self._baseline_import_cmd,
+			env=env, fd_pipes={1:slave_fd},
+			scheduler=scheduler)
+		producer.start()
+		slave_file.close()
+
+		consumer = PipeReader(
+			input_files={"producer" : master_file},
+			scheduler=scheduler)
+
+		consumer.start()
+		consumer.wait()
+		self.assertEqual(producer.wait(), os.EX_OK)
+		self.assertEqual(consumer.wait(), os.EX_OK)
+
+		output = consumer.getvalue().decode('ascii', 'replace').split()
+
+		unexpected_modules = " ".join(sorted(x for x in output \
+			if self._module_re.match(x) is not None and \
+			x not in self._baseline_imports))
+
+		self.assertEqual("", unexpected_modules)
diff --git a/portage_with_autodep/pym/portage/tests/lazyimport/test_preload_portage_submodules.py b/portage_with_autodep/pym/portage/tests/lazyimport/test_preload_portage_submodules.py
new file mode 100644
index 0000000..9d20eba
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/lazyimport/test_preload_portage_submodules.py
@@ -0,0 +1,16 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import portage
+from portage.tests import TestCase
+
+class PreloadPortageSubmodulesTestCase(TestCase):
+
+	def testPreloadPortageSubmodules(self):
+		"""
+		Verify that _preload_portage_submodules() doesn't leave any
+		remaining proxies that refer to the portage.* namespace.
+		"""
+		portage.proxy.lazyimport._preload_portage_submodules()
+		for name in portage.proxy.lazyimport._module_proxies:
+			self.assertEqual(name.startswith('portage.'), False)
diff --git a/portage_with_autodep/pym/portage/tests/lint/__init__.py b/portage_with_autodep/pym/portage/tests/lint/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/lint/__init__.py
diff --git a/portage_with_autodep/pym/portage/tests/lint/__test__ b/portage_with_autodep/pym/portage/tests/lint/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/lint/__test__
diff --git a/portage_with_autodep/pym/portage/tests/lint/test_bash_syntax.py b/portage_with_autodep/pym/portage/tests/lint/test_bash_syntax.py
new file mode 100644
index 0000000..aef8d74
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/lint/test_bash_syntax.py
@@ -0,0 +1,42 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import stat
+
+from portage.const import BASH_BINARY, PORTAGE_BIN_PATH
+from portage.tests import TestCase
+from portage import os
+from portage import subprocess_getstatusoutput
+from portage import _encodings
+from portage import _shell_quote
+from portage import _unicode_decode, _unicode_encode
+
+class BashSyntaxTestCase(TestCase):
+
+	def testBashSyntax(self):
+		for parent, dirs, files in os.walk(PORTAGE_BIN_PATH):
+			parent = _unicode_decode(parent,
+				encoding=_encodings['fs'], errors='strict')
+			for x in files:
+				x = _unicode_decode(x,
+					encoding=_encodings['fs'], errors='strict')
+				ext = x.split('.')[-1]
+				if ext in ('.py', '.pyc', '.pyo'):
+					continue
+				x = os.path.join(parent, x)
+				st = os.lstat(x)
+				if not stat.S_ISREG(st.st_mode):
+					continue
+
+				# Check for bash shebang
+				f = open(_unicode_encode(x,
+					encoding=_encodings['fs'], errors='strict'), 'rb')
+				line = _unicode_decode(f.readline(),
+					encoding=_encodings['content'], errors='replace')
+				f.close()
+				if line[:2] == '#!' and \
+					'bash' in line:
+					cmd = "%s -n %s" % (_shell_quote(BASH_BINARY), _shell_quote(x))
+					status, output = subprocess_getstatusoutput(cmd)
+					self.assertEqual(os.WIFEXITED(status) and \
+						os.WEXITSTATUS(status) == os.EX_OK, True, msg=output)
diff --git a/portage_with_autodep/pym/portage/tests/lint/test_compile_modules.py b/portage_with_autodep/pym/portage/tests/lint/test_compile_modules.py
new file mode 100644
index 0000000..f90a666
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/lint/test_compile_modules.py
@@ -0,0 +1,46 @@
+# Copyright 2009-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import itertools
+import stat
+
+from portage.const import PORTAGE_BIN_PATH, PORTAGE_PYM_PATH
+from portage.tests import TestCase
+from portage import os
+from portage import _encodings
+from portage import _unicode_decode, _unicode_encode
+
+import py_compile
+
+class CompileModulesTestCase(TestCase):
+
+	def testCompileModules(self):
+		for parent, dirs, files in itertools.chain(
+			os.walk(PORTAGE_BIN_PATH),
+			os.walk(PORTAGE_PYM_PATH)):
+			parent = _unicode_decode(parent,
+				encoding=_encodings['fs'], errors='strict')
+			for x in files:
+				x = _unicode_decode(x,
+					encoding=_encodings['fs'], errors='strict')
+				if x[-4:] in ('.pyc', '.pyo'):
+					continue
+				x = os.path.join(parent, x)
+				st = os.lstat(x)
+				if not stat.S_ISREG(st.st_mode):
+					continue
+				do_compile = False
+				if x[-3:] == '.py':
+					do_compile = True
+				else:
+					# Check for python shebang
+					f = open(_unicode_encode(x,
+						encoding=_encodings['fs'], errors='strict'), 'rb')
+					line = _unicode_decode(f.readline(),
+						encoding=_encodings['content'], errors='replace')
+					f.close()
+					if line[:2] == '#!' and \
+						'python' in line:
+						do_compile = True
+				if do_compile:
+					py_compile.compile(x, cfile='/dev/null', doraise=True)
diff --git a/portage_with_autodep/pym/portage/tests/lint/test_import_modules.py b/portage_with_autodep/pym/portage/tests/lint/test_import_modules.py
new file mode 100644
index 0000000..8d257c5
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/lint/test_import_modules.py
@@ -0,0 +1,40 @@
+# Copyright 2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.const import PORTAGE_PYM_PATH
+from portage.tests import TestCase
+from portage import os
+from portage import _encodings
+from portage import _unicode_decode
+
+class ImportModulesTestCase(TestCase):
+
+	def testImportModules(self):
+		expected_failures = frozenset((
+		))
+
+		for mod in self._iter_modules(PORTAGE_PYM_PATH):
+			try:
+				__import__(mod)
+			except ImportError as e:
+				if mod not in expected_failures:
+					self.assertTrue(False, "failed to import '%s': %s" % (mod, e))
+				del e
+
+	def _iter_modules(self, base_dir):
+		for parent, dirs, files in os.walk(base_dir):
+			parent = _unicode_decode(parent,
+				encoding=_encodings['fs'], errors='strict')
+			parent_mod = parent[len(PORTAGE_PYM_PATH)+1:]
+			parent_mod = parent_mod.replace("/", ".")
+			for x in files:
+				x = _unicode_decode(x,
+					encoding=_encodings['fs'], errors='strict')
+				if x[-3:] != '.py':
+					continue
+				x = x[:-3]
+				if x[-8:] == '__init__':
+					x = parent_mod
+				else:
+					x = parent_mod + "." + x
+				yield x
diff --git a/portage_with_autodep/pym/portage/tests/locks/__init__.py b/portage_with_autodep/pym/portage/tests/locks/__init__.py
new file mode 100644
index 0000000..21a391a
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/locks/__init__.py
@@ -0,0 +1,2 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
diff --git a/portage_with_autodep/pym/portage/tests/locks/__test__ b/portage_with_autodep/pym/portage/tests/locks/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/locks/__test__
diff --git a/portage_with_autodep/pym/portage/tests/locks/test_asynchronous_lock.py b/portage_with_autodep/pym/portage/tests/locks/test_asynchronous_lock.py
new file mode 100644
index 0000000..8946caf
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/locks/test_asynchronous_lock.py
@@ -0,0 +1,124 @@
+# Copyright 2010-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import shutil
+import signal
+import tempfile
+
+from portage import os
+from portage.tests import TestCase
+from _emerge.AsynchronousLock import AsynchronousLock
+from _emerge.PollScheduler import PollScheduler
+
+class AsynchronousLockTestCase(TestCase):
+
+	def testAsynchronousLock(self):
+		scheduler = PollScheduler().sched_iface
+		tempdir = tempfile.mkdtemp()
+		try:
+			path = os.path.join(tempdir, 'lock_me')
+			for force_async in (True, False):
+				for force_dummy in (True, False):
+					async_lock = AsynchronousLock(path=path,
+						scheduler=scheduler, _force_async=force_async,
+						_force_thread=True,
+						_force_dummy=force_dummy)
+					async_lock.start()
+					self.assertEqual(async_lock.wait(), os.EX_OK)
+					self.assertEqual(async_lock.returncode, os.EX_OK)
+					async_lock.unlock()
+
+				async_lock = AsynchronousLock(path=path,
+					scheduler=scheduler, _force_async=force_async,
+					_force_process=True)
+				async_lock.start()
+				self.assertEqual(async_lock.wait(), os.EX_OK)
+				self.assertEqual(async_lock.returncode, os.EX_OK)
+				async_lock.unlock()
+
+		finally:
+			shutil.rmtree(tempdir)
+
+	def testAsynchronousLockWait(self):
+		scheduler = PollScheduler().sched_iface
+		tempdir = tempfile.mkdtemp()
+		try:
+			path = os.path.join(tempdir, 'lock_me')
+			lock1 = AsynchronousLock(path=path, scheduler=scheduler)
+			lock1.start()
+			self.assertEqual(lock1.wait(), os.EX_OK)
+			self.assertEqual(lock1.returncode, os.EX_OK)
+
+			# lock2 requires _force_async=True since the portage.locks
+			# module is not designed to work as intended here if the
+			# same process tries to lock the same file more than
+			# one time concurrently.
+			lock2 = AsynchronousLock(path=path, scheduler=scheduler,
+				_force_async=True, _force_process=True)
+			lock2.start()
+			# lock2 should be waiting for lock1 to release
+			self.assertEqual(lock2.poll(), None)
+			self.assertEqual(lock2.returncode, None)
+
+			lock1.unlock()
+			self.assertEqual(lock2.wait(), os.EX_OK)
+			self.assertEqual(lock2.returncode, os.EX_OK)
+			lock2.unlock()
+		finally:
+			shutil.rmtree(tempdir)
+
+	def testAsynchronousLockWaitCancel(self):
+		scheduler = PollScheduler().sched_iface
+		tempdir = tempfile.mkdtemp()
+		try:
+			path = os.path.join(tempdir, 'lock_me')
+			lock1 = AsynchronousLock(path=path, scheduler=scheduler)
+			lock1.start()
+			self.assertEqual(lock1.wait(), os.EX_OK)
+			self.assertEqual(lock1.returncode, os.EX_OK)
+			lock2 = AsynchronousLock(path=path, scheduler=scheduler,
+				_force_async=True, _force_process=True)
+			lock2.start()
+			# lock2 should be waiting for lock1 to release
+			self.assertEqual(lock2.poll(), None)
+			self.assertEqual(lock2.returncode, None)
+
+			# Cancel lock2 and then check wait() and returncode results.
+			lock2.cancel()
+			self.assertEqual(lock2.wait() == os.EX_OK, False)
+			self.assertEqual(lock2.returncode == os.EX_OK, False)
+			self.assertEqual(lock2.returncode is None, False)
+			lock1.unlock()
+		finally:
+			shutil.rmtree(tempdir)
+
+	def testAsynchronousLockWaitKill(self):
+		scheduler = PollScheduler().sched_iface
+		tempdir = tempfile.mkdtemp()
+		try:
+			path = os.path.join(tempdir, 'lock_me')
+			lock1 = AsynchronousLock(path=path, scheduler=scheduler)
+			lock1.start()
+			self.assertEqual(lock1.wait(), os.EX_OK)
+			self.assertEqual(lock1.returncode, os.EX_OK)
+			lock2 = AsynchronousLock(path=path, scheduler=scheduler,
+				_force_async=True, _force_process=True)
+			lock2.start()
+			# lock2 should be waiting for lock1 to release
+			self.assertEqual(lock2.poll(), None)
+			self.assertEqual(lock2.returncode, None)
+
+			# Kill lock2's process and then check wait() and
+			# returncode results. This is intended to simulate
+			# a SIGINT sent via the controlling tty.
+			self.assertEqual(lock2._imp is not None, True)
+			self.assertEqual(lock2._imp._proc is not None, True)
+			self.assertEqual(lock2._imp._proc.pid is not None, True)
+			lock2._imp._kill_test = True
+			os.kill(lock2._imp._proc.pid, signal.SIGTERM)
+			self.assertEqual(lock2.wait() == os.EX_OK, False)
+			self.assertEqual(lock2.returncode == os.EX_OK, False)
+			self.assertEqual(lock2.returncode is None, False)
+			lock1.unlock()
+		finally:
+			shutil.rmtree(tempdir)
diff --git a/portage_with_autodep/pym/portage/tests/locks/test_lock_nonblock.py b/portage_with_autodep/pym/portage/tests/locks/test_lock_nonblock.py
new file mode 100644
index 0000000..d5748ad
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/locks/test_lock_nonblock.py
@@ -0,0 +1,46 @@
+# Copyright 2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import shutil
+import tempfile
+import traceback
+
+import portage
+from portage import os
+from portage.tests import TestCase
+
+class LockNonblockTestCase(TestCase):
+
+	def testLockNonblock(self):
+		tempdir = tempfile.mkdtemp()
+		try:
+			path = os.path.join(tempdir, 'lock_me')
+			lock1 = portage.locks.lockfile(path)
+			pid = os.fork()
+			if pid == 0:
+				portage.process._setup_pipes({0:0, 1:1, 2:2})
+				rval = 2
+				try:
+					try:
+						lock2 = portage.locks.lockfile(path, flags=os.O_NONBLOCK)
+					except portage.exception.TryAgain:
+						rval = os.EX_OK
+					else:
+						rval = 1
+						portage.locks.unlockfile(lock2)
+				except SystemExit:
+					raise
+				except:
+					traceback.print_exc()
+				finally:
+					os._exit(rval)
+
+			self.assertEqual(pid > 0, True)
+			pid, status = os.waitpid(pid, 0)
+			self.assertEqual(os.WIFEXITED(status), True)
+			self.assertEqual(os.WEXITSTATUS(status), os.EX_OK)
+
+			portage.locks.unlockfile(lock1)
+		finally:
+			shutil.rmtree(tempdir)
+
diff --git a/portage_with_autodep/pym/portage/tests/news/__init__.py b/portage_with_autodep/pym/portage/tests/news/__init__.py
new file mode 100644
index 0000000..28a753f
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/news/__init__.py
@@ -0,0 +1,3 @@
+# tests/portage.news/__init__.py -- Portage Unit Test functionality
+# Copyright 2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
diff --git a/portage_with_autodep/pym/portage/tests/news/__test__ b/portage_with_autodep/pym/portage/tests/news/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/news/__test__
diff --git a/portage_with_autodep/pym/portage/tests/news/test_NewsItem.py b/portage_with_autodep/pym/portage/tests/news/test_NewsItem.py
new file mode 100644
index 0000000..a4e76f3
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/news/test_NewsItem.py
@@ -0,0 +1,95 @@
+# test_NewsItem.py -- Portage Unit Testing Functionality
+# Copyright 2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage import os
+from portage.tests import TestCase
+from portage.news import NewsItem
+from portage.dbapi.virtual import testdbapi
+from tempfile import mkstemp
+# TODO(antarus) Make newsitem use a loader so we can load using a string instead of a tempfile
+
+class NewsItemTestCase(TestCase):
+	"""These tests suck: they use your running config instead of making their own"""
+	fakeItem = """
+Title: YourSQL Upgrades from 4.0 to 4.1
+Author: Ciaran McCreesh <ciaranm@gentoo.org>
+Content-Type: text/plain
+Posted: 01-Nov-2005
+Revision: 1
+#Display-If-Installed:
+#Display-If-Profile:
+#Display-If-Arch:
+
+YourSQL databases created using YourSQL version 4.0 are incompatible
+with YourSQL version 4.1 or later. There is no reliable way to
+automate the database format conversion, so action from the system
+administrator is required before an upgrade can take place.
+
+Please see the Gentoo YourSQL Upgrade Guide for instructions:
+
+    http://www.gentoo.org/doc/en/yoursql-upgrading.xml
+
+Also see the official YourSQL documentation:
+
+    http://dev.yoursql.com/doc/refman/4.1/en/upgrading-from-4-0.html
+
+After upgrading, you should also recompile any packages which link
+against YourSQL:
+
+    revdep-rebuild --library=libyoursqlclient.so.12
+
+The revdep-rebuild tool is provided by app-portage/gentoolkit.
+"""
+	def setUp(self):
+		self.profile = "/usr/portage/profiles/default-linux/x86/2007.0/"
+		self.keywords = "x86"
+		# Use fake/test dbapi to avoid slow tests
+		self.vardb = testdbapi()
+		# self.vardb.inject_cpv('sys-apps/portage-2.0', { 'SLOT' : 0 })
+		# Consumers only use ARCH, so avoid portage.settings by using a dict
+		self.settings = { 'ARCH' : 'x86' }
+
+	def testDisplayIfProfile(self):
+		tmpItem = self.fakeItem[:].replace("#Display-If-Profile:", "Display-If-Profile: %s" %
+			self.profile)
+
+		item = self._processItem(tmpItem)
+		try:
+			self.assertTrue(item.isRelevant(self.vardb, self.settings, self.profile),
+				msg="Expected %s to be relevant, but it was not!" % tmpItem)
+		finally:
+			os.unlink(item.path)
+
+	def testDisplayIfInstalled(self):
+		tmpItem = self.fakeItem[:].replace("#Display-If-Installed:", "Display-If-Installed: %s" %
+			"sys-apps/portage")
+
+		try:
+			item = self._processItem(tmpItem)
+			self.assertTrue(item.isRelevant(self.vardb, self.settings, self.profile),
+				msg="Expected %s to be relevant, but it was not!" % tmpItem)
+		finally:
+			os.unlink(item.path)
+
+	def testDisplayIfKeyword(self):
+		tmpItem = self.fakeItem[:].replace("#Display-If-Keyword:", "Display-If-Keyword: %s" %
+			self.keywords)
+
+		try:
+			item = self._processItem(tmpItem)
+			self.assertTrue(item.isRelevant(self.vardb, self.settings, self.profile),
+				msg="Expected %s to be relevant, but it was not!" % tmpItem)
+		finally:
+			os.unlink(item.path)
+
+	def _processItem(self, item):
+		filename = None
+		fd, filename = mkstemp()
+		f = os.fdopen(fd, 'w')
+		f.write(item)
+		f.close()
+		try:
+			return NewsItem(filename, 0)
+		except TypeError:
+			self.fail("Error while processing news item %s" % filename)
diff --git a/portage_with_autodep/pym/portage/tests/process/__init__.py b/portage_with_autodep/pym/portage/tests/process/__init__.py
new file mode 100644
index 0000000..d19e353
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/process/__init__.py
@@ -0,0 +1,2 @@
+# Copyright 1998-2008 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
diff --git a/portage_with_autodep/pym/portage/tests/process/__test__ b/portage_with_autodep/pym/portage/tests/process/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/process/__test__
diff --git a/portage_with_autodep/pym/portage/tests/process/test_poll.py b/portage_with_autodep/pym/portage/tests/process/test_poll.py
new file mode 100644
index 0000000..ee6ee0c
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/process/test_poll.py
@@ -0,0 +1,39 @@
+# Copyright 1998-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage import os
+from portage.tests import TestCase
+from _emerge.PollScheduler import PollScheduler
+from _emerge.PipeReader import PipeReader
+from _emerge.SpawnProcess import SpawnProcess
+
+class PipeReaderTestCase(TestCase):
+
+	def testPipeReader(self):
+		"""
+		Use a poll loop to read data from a pipe and assert that
+		the data written to the pipe is identical to the data
+		read from the pipe.
+		"""
+
+		test_string = 2 * "blah blah blah\n"
+
+		scheduler = PollScheduler().sched_iface
+		master_fd, slave_fd = os.pipe()
+		master_file = os.fdopen(master_fd, 'rb', 0)
+		slave_file = os.fdopen(slave_fd, 'wb')
+		producer = SpawnProcess(
+			args=["bash", "-c", "echo -n '%s'" % test_string],
+			env=os.environ, fd_pipes={1:slave_fd},
+			scheduler=scheduler)
+		producer.start()
+		slave_file.close()
+
+		consumer = PipeReader(
+			input_files={"producer" : master_file},
+			scheduler=scheduler)
+
+		consumer.start()
+		consumer.wait()
+		output = consumer.getvalue().decode('ascii', 'replace')
+		self.assertEqual(test_string, output)
diff --git a/portage_with_autodep/pym/portage/tests/resolver/ResolverPlayground.py b/portage_with_autodep/pym/portage/tests/resolver/ResolverPlayground.py
new file mode 100644
index 0000000..6a8e3c1
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/ResolverPlayground.py
@@ -0,0 +1,690 @@
+# Copyright 2010-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from itertools import permutations
+import shutil
+import sys
+import tempfile
+import portage
+from portage import os
+from portage.const import PORTAGE_BASE_PATH
+from portage.dbapi.vartree import vartree
+from portage.dbapi.porttree import portagetree
+from portage.dbapi.bintree import binarytree
+from portage.dep import Atom, _repo_separator
+from portage.package.ebuild.config import config
+from portage.package.ebuild.digestgen import digestgen
+from portage._sets import load_default_config
+from portage._sets.base import InternalPackageSet
+from portage.versions import catsplit
+
+import _emerge
+from _emerge.actions import calc_depclean
+from _emerge.Blocker import Blocker
+from _emerge.create_depgraph_params import create_depgraph_params
+from _emerge.depgraph import backtrack_depgraph
+from _emerge.RootConfig import RootConfig
+
+if sys.hexversion >= 0x3000000:
+	basestring = str
+
+class ResolverPlayground(object):
+	"""
+	This class helps to create the necessary files on disk and
+	the needed settings instances, etc. for the resolver to do
+	its work.
+	"""
+
+	config_files = frozenset(("package.use", "package.mask", "package.keywords", \
+		"package.unmask", "package.properties", "package.license", "use.mask", "use.force"))
+
+	def __init__(self, ebuilds={}, installed={}, profile={}, repo_configs={}, \
+		user_config={}, sets={}, world=[], debug=False):
+		"""
+		ebuilds: cpv -> metadata mapping simulating available ebuilds. 
+		installed: cpv -> metadata mapping simulating installed packages.
+			If a metadata key is missing, it gets a default value.
+		profile: settings defined by the profile.
+		"""
+		self.debug = debug
+		self.root = "/"
+		self.eprefix = tempfile.mkdtemp()
+		self.eroot = self.root + self.eprefix.lstrip(os.sep) + os.sep
+		self.portdir = os.path.join(self.eroot, "usr/portage")
+		self.vdbdir = os.path.join(self.eroot, "var/db/pkg")
+		os.makedirs(self.portdir)
+		os.makedirs(self.vdbdir)
+
+		if not debug:
+			portage.util.noiselimit = -2
+
+		self.repo_dirs = {}
+		#Make sure the main repo is always created
+		self._get_repo_dir("test_repo")
+
+		self._create_ebuilds(ebuilds)
+		self._create_installed(installed)
+		self._create_profile(ebuilds, installed, profile, repo_configs, user_config, sets)
+		self._create_world(world)
+
+		self.settings, self.trees = self._load_config()
+
+		self._create_ebuild_manifests(ebuilds)
+		
+		portage.util.noiselimit = 0
+
+	def _get_repo_dir(self, repo):
+		"""
+		Create the repo directory if needed.
+		"""
+		if repo not in self.repo_dirs:
+			if repo == "test_repo":
+				repo_path = self.portdir
+			else:
+				repo_path = os.path.join(self.eroot, "usr", "local", repo)
+
+			self.repo_dirs[repo] = repo_path
+			profile_path = os.path.join(repo_path, "profiles")
+
+			try:
+				os.makedirs(profile_path)
+			except os.error:
+				pass
+
+			repo_name_file = os.path.join(profile_path, "repo_name")
+			f = open(repo_name_file, "w")
+			f.write("%s\n" % repo)
+			f.close()
+
+		return self.repo_dirs[repo]
+
+	def _create_ebuilds(self, ebuilds):
+		for cpv in ebuilds:
+			a = Atom("=" + cpv, allow_repo=True)
+			repo = a.repo
+			if repo is None:
+				repo = "test_repo"
+
+			metadata = ebuilds[cpv].copy()
+			eapi = metadata.pop("EAPI", 0)
+			lic = metadata.pop("LICENSE", "")
+			properties = metadata.pop("PROPERTIES", "")
+			slot = metadata.pop("SLOT", 0)
+			keywords = metadata.pop("KEYWORDS", "x86")
+			iuse = metadata.pop("IUSE", "")
+			depend = metadata.pop("DEPEND", "")
+			rdepend = metadata.pop("RDEPEND", None)
+			pdepend = metadata.pop("PDEPEND", None)
+			required_use = metadata.pop("REQUIRED_USE", None)
+
+			if metadata:
+				raise ValueError("metadata of ebuild '%s' contains unknown keys: %s" % (cpv, metadata.keys()))
+
+			repo_dir = self._get_repo_dir(repo)
+			ebuild_dir = os.path.join(repo_dir, a.cp)
+			ebuild_path = os.path.join(ebuild_dir, a.cpv.split("/")[1] + ".ebuild")
+			try:
+				os.makedirs(ebuild_dir)
+			except os.error:
+				pass
+
+			f = open(ebuild_path, "w")
+			f.write('EAPI="' + str(eapi) + '"\n')
+			f.write('LICENSE="' + str(lic) + '"\n')
+			f.write('PROPERTIES="' + str(properties) + '"\n')
+			f.write('SLOT="' + str(slot) + '"\n')
+			f.write('KEYWORDS="' + str(keywords) + '"\n')
+			f.write('IUSE="' + str(iuse) + '"\n')
+			f.write('DEPEND="' + str(depend) + '"\n')
+			if rdepend is not None:
+				f.write('RDEPEND="' + str(rdepend) + '"\n')
+			if pdepend is not None:
+				f.write('PDEPEND="' + str(pdepend) + '"\n')
+			if required_use is not None:
+				f.write('REQUIRED_USE="' + str(required_use) + '"\n')
+			f.close()
+
+	def _create_ebuild_manifests(self, ebuilds):
+		tmpsettings = config(clone=self.settings)
+		tmpsettings['PORTAGE_QUIET'] = '1'
+		for cpv in ebuilds:
+			a = Atom("=" + cpv, allow_repo=True)
+			repo = a.repo
+			if repo is None:
+				repo = "test_repo"
+
+			repo_dir = self._get_repo_dir(repo)
+			ebuild_dir = os.path.join(repo_dir, a.cp)
+			ebuild_path = os.path.join(ebuild_dir, a.cpv.split("/")[1] + ".ebuild")
+
+			portdb = self.trees[self.root]["porttree"].dbapi
+			tmpsettings['O'] = ebuild_dir
+			if not digestgen(mysettings=tmpsettings, myportdb=portdb):
+				raise AssertionError('digest creation failed for %s' % ebuild_path)
+
+	def _create_installed(self, installed):
+		for cpv in installed:
+			a = Atom("=" + cpv, allow_repo=True)
+			repo = a.repo
+			if repo is None:
+				repo = "test_repo"
+
+			vdb_pkg_dir = os.path.join(self.vdbdir, a.cpv)
+			try:
+				os.makedirs(vdb_pkg_dir)
+			except os.error:
+				pass
+
+			metadata = installed[cpv].copy()
+			eapi = metadata.pop("EAPI", 0)
+			lic = metadata.pop("LICENSE", "")
+			properties = metadata.pop("PROPERTIES", "")
+			slot = metadata.pop("SLOT", 0)
+			keywords = metadata.pop("KEYWORDS", "~x86")
+			iuse = metadata.pop("IUSE", "")
+			use = metadata.pop("USE", "")
+			depend = metadata.pop("DEPEND", "")
+			rdepend = metadata.pop("RDEPEND", None)
+			pdepend = metadata.pop("PDEPEND", None)
+			required_use = metadata.pop("REQUIRED_USE", None)
+
+			if metadata:
+				raise ValueError("metadata of installed '%s' contains unknown keys: %s" % (cpv, metadata.keys()))
+
+			def write_key(key, value):
+				f = open(os.path.join(vdb_pkg_dir, key), "w")
+				f.write(str(value) + "\n")
+				f.close()
+			
+			write_key("EAPI", eapi)
+			write_key("LICENSE", lic)
+			write_key("PROPERTIES", properties)
+			write_key("SLOT", slot)
+			write_key("LICENSE", lic)
+			write_key("PROPERTIES", properties)
+			write_key("repository", repo)
+			write_key("KEYWORDS", keywords)
+			write_key("IUSE", iuse)
+			write_key("USE", use)
+			write_key("DEPEND", depend)
+			if rdepend is not None:
+				write_key("RDEPEND", rdepend)
+			if pdepend is not None:
+				write_key("PDEPEND", pdepend)
+			if required_use is not None:
+				write_key("REQUIRED_USE", required_use)
+
+	def _create_profile(self, ebuilds, installed, profile, repo_configs, user_config, sets):
+
+		for repo in self.repo_dirs:
+			repo_dir = self._get_repo_dir(repo)
+			profile_dir = os.path.join(self._get_repo_dir(repo), "profiles")
+
+			#Create $REPO/profiles/categories
+			categories = set()
+			for cpv in ebuilds:
+				ebuilds_repo = Atom("="+cpv, allow_repo=True).repo
+				if ebuilds_repo is None:
+					ebuilds_repo = "test_repo"
+				if ebuilds_repo == repo:
+					categories.add(catsplit(cpv)[0])
+
+			categories_file = os.path.join(profile_dir, "categories")
+			f = open(categories_file, "w")
+			for cat in categories:
+				f.write(cat + "\n")
+			f.close()
+			
+			#Create $REPO/profiles/license_groups
+			license_file = os.path.join(profile_dir, "license_groups")
+			f = open(license_file, "w")
+			f.write("EULA TEST\n")
+			f.close()
+
+			repo_config = repo_configs.get(repo) 
+			if repo_config:
+				for config_file, lines in repo_config.items():
+					if config_file not in self.config_files:
+						raise ValueError("Unknown config file: '%s'" % config_file)
+		
+					file_name = os.path.join(profile_dir, config_file)
+					f = open(file_name, "w")
+					for line in lines:
+						f.write("%s\n" % line)
+					f.close()
+
+			#Create $profile_dir/eclass (we fail to digest the ebuilds if it's not there)
+			os.makedirs(os.path.join(repo_dir, "eclass"))
+
+			if repo == "test_repo":
+				#Create a minimal profile in /usr/portage
+				sub_profile_dir = os.path.join(profile_dir, "default", "linux", "x86", "test_profile")
+				os.makedirs(sub_profile_dir)
+
+				eapi_file = os.path.join(sub_profile_dir, "eapi")
+				f = open(eapi_file, "w")
+				f.write("0\n")
+				f.close()
+
+				make_defaults_file = os.path.join(sub_profile_dir, "make.defaults")
+				f = open(make_defaults_file, "w")
+				f.write("ARCH=\"x86\"\n")
+				f.write("ACCEPT_KEYWORDS=\"x86\"\n")
+				f.close()
+
+				use_force_file = os.path.join(sub_profile_dir, "use.force")
+				f = open(use_force_file, "w")
+				f.write("x86\n")
+				f.close()
+
+				if profile:
+					for config_file, lines in profile.items():
+						if config_file not in self.config_files:
+							raise ValueError("Unknown config file: '%s'" % config_file)
+
+						file_name = os.path.join(sub_profile_dir, config_file)
+						f = open(file_name, "w")
+						for line in lines:
+							f.write("%s\n" % line)
+						f.close()
+
+				#Create profile symlink
+				os.makedirs(os.path.join(self.eroot, "etc"))
+				os.symlink(sub_profile_dir, os.path.join(self.eroot, "etc", "make.profile"))
+
+		user_config_dir = os.path.join(self.eroot, "etc", "portage")
+
+		try:
+			os.makedirs(user_config_dir)
+		except os.error:
+			pass
+
+		repos_conf_file = os.path.join(user_config_dir, "repos.conf")		
+		f = open(repos_conf_file, "w")
+		priority = 0
+		for repo in sorted(self.repo_dirs.keys()):
+			f.write("[%s]\n" % repo)
+			f.write("LOCATION=%s\n" % self.repo_dirs[repo])
+			if repo == "test_repo":
+				f.write("PRIORITY=%s\n" % -1000)
+			else:
+				f.write("PRIORITY=%s\n" % priority)
+				priority += 1
+		f.close()
+
+		for config_file, lines in user_config.items():
+			if config_file not in self.config_files:
+				raise ValueError("Unknown config file: '%s'" % config_file)
+
+			file_name = os.path.join(user_config_dir, config_file)
+			f = open(file_name, "w")
+			for line in lines:
+				f.write("%s\n" % line)
+			f.close()
+
+		#Create /usr/share/portage/config/sets/portage.conf
+		default_sets_conf_dir = os.path.join(self.eroot, "usr/share/portage/config/sets")
+		
+		try:
+			os.makedirs(default_sets_conf_dir)
+		except os.error:
+			pass
+
+		provided_sets_portage_conf = \
+			os.path.join(PORTAGE_BASE_PATH, "cnf/sets/portage.conf")
+		os.symlink(provided_sets_portage_conf, os.path.join(default_sets_conf_dir, "portage.conf"))
+
+		set_config_dir = os.path.join(user_config_dir, "sets")
+
+		try:
+			os.makedirs(set_config_dir)
+		except os.error:
+			pass
+
+		for sets_file, lines in sets.items():
+			file_name = os.path.join(set_config_dir, sets_file)
+			f = open(file_name, "w")
+			for line in lines:
+				f.write("%s\n" % line)
+			f.close()
+
+		user_config_dir = os.path.join(self.eroot, "etc", "portage")
+
+		try:
+			os.makedirs(user_config_dir)
+		except os.error:
+			pass
+
+		for config_file, lines in user_config.items():
+			if config_file not in self.config_files:
+				raise ValueError("Unknown config file: '%s'" % config_file)
+
+			file_name = os.path.join(user_config_dir, config_file)
+			f = open(file_name, "w")
+			for line in lines:
+				f.write("%s\n" % line)
+			f.close()
+
+	def _create_world(self, world):
+		#Create /var/lib/portage/world
+		var_lib_portage = os.path.join(self.eroot, "var", "lib", "portage")
+		os.makedirs(var_lib_portage)
+
+		world_file = os.path.join(var_lib_portage, "world")
+
+		f = open(world_file, "w")
+		for atom in world:
+			f.write("%s\n" % atom)
+		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'),
+		}
+
+		# Pass along PORTAGE_USERNAME and PORTAGE_GRPNAME since they
+		# need to be inherited by ebuild subprocesses.
+		if 'PORTAGE_USERNAME' in os.environ:
+			env['PORTAGE_USERNAME'] = os.environ['PORTAGE_USERNAME']
+		if 'PORTAGE_GRPNAME' in os.environ:
+			env['PORTAGE_GRPNAME'] = os.environ['PORTAGE_GRPNAME']
+
+		settings = config(_eprefix=self.eprefix, env=env)
+		settings.lock()
+
+		trees = {
+			self.root: {
+					"vartree": vartree(settings=settings),
+					"porttree": portagetree(self.root, settings=settings),
+					"bintree": binarytree(self.root,
+						os.path.join(self.eroot, "usr/portage/packages"),
+						settings=settings)
+				}
+			}
+
+		for root, root_trees in trees.items():
+			settings = root_trees["vartree"].settings
+			settings._init_dirs()
+			setconfig = load_default_config(settings, root_trees)
+			root_trees["root_config"] = RootConfig(settings, root_trees, setconfig)
+		
+		return settings, trees
+
+	def run(self, atoms, options={}, action=None):
+		options = options.copy()
+		options["--pretend"] = True
+		if self.debug:
+			options["--debug"] = True
+
+		global_noiselimit = portage.util.noiselimit
+		global_emergelog_disable = _emerge.emergelog._disable
+		try:
+
+			if not self.debug:
+				portage.util.noiselimit = -2
+			_emerge.emergelog._disable = True
+
+			if options.get("--depclean"):
+				rval, cleanlist, ordered, req_pkg_count = \
+					calc_depclean(self.settings, self.trees, None,
+					options, "depclean", InternalPackageSet(initial_atoms=atoms, allow_wildcard=True), None)
+				result = ResolverPlaygroundDepcleanResult( \
+					atoms, rval, cleanlist, ordered, req_pkg_count)
+			else:
+				params = create_depgraph_params(options, action)
+				success, depgraph, favorites = backtrack_depgraph(
+					self.settings, self.trees, options, params, action, atoms, None)
+				depgraph._show_merge_list()
+				depgraph.display_problems()
+				result = ResolverPlaygroundResult(atoms, success, depgraph, favorites)
+		finally:
+			portage.util.noiselimit = global_noiselimit
+			_emerge.emergelog._disable = global_emergelog_disable
+
+		return result
+
+	def run_TestCase(self, test_case):
+		if not isinstance(test_case, ResolverPlaygroundTestCase):
+			raise TypeError("ResolverPlayground needs a ResolverPlaygroundTestCase")
+		for atoms in test_case.requests:
+			result = self.run(atoms, test_case.options, test_case.action)
+			if not test_case.compare_with_result(result):
+				return
+
+	def cleanup(self):
+		portdb = self.trees[self.root]["porttree"].dbapi
+		portdb.close_caches()
+		portage.dbapi.porttree.portdbapi.portdbapi_instances.remove(portdb)
+		if self.debug:
+			print("\nEROOT=%s" % self.eroot)
+		else:
+			shutil.rmtree(self.eroot)
+
+class ResolverPlaygroundTestCase(object):
+
+	def __init__(self, request, **kwargs):
+		self.all_permutations = kwargs.pop("all_permutations", False)
+		self.ignore_mergelist_order = kwargs.pop("ignore_mergelist_order", False)
+		self.ambiguous_merge_order = kwargs.pop("ambiguous_merge_order", False)
+		self.check_repo_names = kwargs.pop("check_repo_names", False)
+		self.merge_order_assertions = kwargs.pop("merge_order_assertions", False)
+
+		if self.all_permutations:
+			self.requests = list(permutations(request))
+		else:
+			self.requests = [request]
+
+		self.options = kwargs.pop("options", {})
+		self.action = kwargs.pop("action", None)
+		self.test_success = True
+		self.fail_msg = None
+		self._checks = kwargs.copy()
+
+	def compare_with_result(self, result):
+		checks = dict.fromkeys(result.checks)
+		for key, value in self._checks.items():
+			if not key in checks:
+				raise KeyError("Not an available check: '%s'" % key)
+			checks[key] = value
+
+		fail_msgs = []
+		for key, value in checks.items():
+			got = getattr(result, key)
+			expected = value
+
+			if key in result.optional_checks and expected is None:
+				continue
+
+			if key == "mergelist":
+				if not self.check_repo_names:
+					#Strip repo names if we don't check them
+					if got:
+						new_got = []
+						for cpv in got:
+							if cpv[:1] == "!":
+								new_got.append(cpv)
+								continue
+							a = Atom("="+cpv, allow_repo=True)
+							new_got.append(a.cpv)
+						got = new_got
+					if expected:
+						new_expected = []
+						for obj in expected:
+							if isinstance(obj, basestring):
+								if obj[:1] == "!":
+									new_expected.append(obj)
+									continue
+								a = Atom("="+obj, allow_repo=True)
+								new_expected.append(a.cpv)
+								continue
+							new_expected.append(set())
+							for cpv in obj:
+								if cpv[:1] != "!":
+									cpv = Atom("="+cpv, allow_repo=True).cpv
+								new_expected[-1].add(cpv)
+						expected = new_expected
+				if self.ignore_mergelist_order and got is not None:
+					got = set(got)
+					expected = set(expected)
+
+				if self.ambiguous_merge_order and got:
+					expected_stack = list(reversed(expected))
+					got_stack = list(reversed(got))
+					new_expected = []
+					match = True
+					while got_stack and expected_stack:
+						got_token = got_stack.pop()
+						expected_obj = expected_stack.pop()
+						if isinstance(expected_obj, basestring):
+							new_expected.append(expected_obj)
+							if got_token == expected_obj:
+								continue
+							# result doesn't match, so stop early
+							match = False
+							break
+						expected_obj = set(expected_obj)
+						try:
+							expected_obj.remove(got_token)
+						except KeyError:
+							# result doesn't match, so stop early
+							match = False
+							break
+						new_expected.append(got_token)
+						while got_stack and expected_obj:
+							got_token = got_stack.pop()
+							try:
+								expected_obj.remove(got_token)
+							except KeyError:
+								match = False
+								break
+							new_expected.append(got_token)
+						if not match:
+							# result doesn't match, so stop early
+							break
+						if expected_obj:
+							# result does not match, so stop early
+							match = False
+							new_expected.append(tuple(expected_obj))
+							break
+					if expected_stack:
+						# result does not match, add leftovers to new_expected
+						match = False
+						expected_stack.reverse()
+						new_expected.extend(expected_stack)
+					expected = new_expected
+
+					if match and self.merge_order_assertions:
+						for node1, node2 in self.merge_order_assertions:
+							if not (got.index(node1) < got.index(node2)):
+								fail_msgs.append("atoms: (" + \
+									", ".join(result.atoms) + "), key: " + \
+									("merge_order_assertions, expected: %s" % \
+									str((node1, node2))) + \
+									", got: " + str(got))
+
+			elif key in ("unstable_keywords", "needed_p_mask_changes") and expected is not None:
+				expected = set(expected)
+
+			if got != expected:
+				fail_msgs.append("atoms: (" + ", ".join(result.atoms) + "), key: " + \
+					key + ", expected: " + str(expected) + ", got: " + str(got))
+		if fail_msgs:
+			self.test_success = False
+			self.fail_msg = "\n".join(fail_msgs)
+			return False
+		return True
+
+class ResolverPlaygroundResult(object):
+
+	checks = (
+		"success", "mergelist", "use_changes", "license_changes", "unstable_keywords", "slot_collision_solutions",
+		"circular_dependency_solutions", "needed_p_mask_changes",
+		)
+	optional_checks = (
+		)
+
+	def __init__(self, atoms, success, mydepgraph, favorites):
+		self.atoms = atoms
+		self.success = success
+		self.depgraph = mydepgraph
+		self.favorites = favorites
+		self.mergelist = None
+		self.use_changes = None
+		self.license_changes = None
+		self.unstable_keywords = None
+		self.needed_p_mask_changes = None
+		self.slot_collision_solutions = None
+		self.circular_dependency_solutions = None
+
+		if self.depgraph._dynamic_config._serialized_tasks_cache is not None:
+			self.mergelist = []
+			for x in self.depgraph._dynamic_config._serialized_tasks_cache:
+				if isinstance(x, Blocker):
+					self.mergelist.append(x.atom)
+				else:
+					repo_str = ""
+					if x.metadata["repository"] != "test_repo":
+						repo_str = _repo_separator + x.metadata["repository"]
+					self.mergelist.append(x.cpv + repo_str)
+
+		if self.depgraph._dynamic_config._needed_use_config_changes:
+			self.use_changes = {}
+			for pkg, needed_use_config_changes in \
+				self.depgraph._dynamic_config._needed_use_config_changes.items():
+				new_use, changes = needed_use_config_changes
+				self.use_changes[pkg.cpv] = changes
+
+		if self.depgraph._dynamic_config._needed_unstable_keywords:
+			self.unstable_keywords = set()
+			for pkg in self.depgraph._dynamic_config._needed_unstable_keywords:
+				self.unstable_keywords.add(pkg.cpv)
+
+		if self.depgraph._dynamic_config._needed_p_mask_changes:
+			self.needed_p_mask_changes = set()
+			for pkg in self.depgraph._dynamic_config._needed_p_mask_changes:
+				self.needed_p_mask_changes.add(pkg.cpv)
+
+		if self.depgraph._dynamic_config._needed_license_changes:
+			self.license_changes = {}
+			for pkg, missing_licenses in self.depgraph._dynamic_config._needed_license_changes.items():
+				self.license_changes[pkg.cpv] = missing_licenses
+
+		if self.depgraph._dynamic_config._slot_conflict_handler is not None:
+			self.slot_collision_solutions  = []
+			handler = self.depgraph._dynamic_config._slot_conflict_handler
+
+			for change in handler.changes:
+				new_change = {}
+				for pkg in change:
+					new_change[pkg.cpv] = change[pkg]
+				self.slot_collision_solutions.append(new_change)
+
+		if self.depgraph._dynamic_config._circular_dependency_handler is not None:
+			handler = self.depgraph._dynamic_config._circular_dependency_handler
+			sol = handler.solutions
+			self.circular_dependency_solutions = dict( zip([x.cpv for x in sol.keys()], sol.values()) )
+
+class ResolverPlaygroundDepcleanResult(object):
+
+	checks = (
+		"success", "cleanlist", "ordered", "req_pkg_count",
+		)
+	optional_checks = (
+		"ordered", "req_pkg_count",
+		)
+
+	def __init__(self, atoms, rval, cleanlist, ordered, req_pkg_count):
+		self.atoms = atoms
+		self.success = rval == 0
+		self.cleanlist = cleanlist
+		self.ordered = ordered
+		self.req_pkg_count = req_pkg_count
diff --git a/portage_with_autodep/pym/portage/tests/resolver/__init__.py b/portage_with_autodep/pym/portage/tests/resolver/__init__.py
new file mode 100644
index 0000000..21a391a
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/__init__.py
@@ -0,0 +1,2 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
diff --git a/portage_with_autodep/pym/portage/tests/resolver/__test__ b/portage_with_autodep/pym/portage/tests/resolver/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/__test__
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_autounmask.py b/portage_with_autodep/pym/portage/tests/resolver/test_autounmask.py
new file mode 100644
index 0000000..54c435f
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_autounmask.py
@@ -0,0 +1,326 @@
+# Copyright 2010-2011 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 AutounmaskTestCase(TestCase):
+
+	def testAutounmask(self):
+
+		ebuilds = {
+			#ebuilds to test use changes
+			"dev-libs/A-1": { "SLOT": 1, "DEPEND": "dev-libs/B[foo]", "EAPI": 2}, 
+			"dev-libs/A-2": { "SLOT": 2, "DEPEND": "dev-libs/B[bar]", "EAPI": 2}, 
+			"dev-libs/B-1": { "DEPEND": "foo? ( dev-libs/C ) bar? ( dev-libs/D )", "IUSE": "foo bar"}, 
+			"dev-libs/C-1": {},
+			"dev-libs/D-1": {},
+
+			#ebuilds to test if we allow changing of masked or forced flags
+			"dev-libs/E-1": { "SLOT": 1, "DEPEND": "dev-libs/F[masked-flag]", "EAPI": 2},
+			"dev-libs/E-2": { "SLOT": 2, "DEPEND": "dev-libs/G[-forced-flag]", "EAPI": 2},
+			"dev-libs/F-1": { "IUSE": "masked-flag"},
+			"dev-libs/G-1": { "IUSE": "forced-flag"},
+
+			#ebuilds to test keyword changes
+			"app-misc/Z-1": { "KEYWORDS": "~x86", "DEPEND": "app-misc/Y" },
+			"app-misc/Y-1": { "KEYWORDS": "~x86" },
+			"app-misc/W-1": {},
+			"app-misc/W-2": { "KEYWORDS": "~x86" },
+			"app-misc/V-1": { "KEYWORDS": "~x86", "DEPEND": ">=app-misc/W-2"},
+
+			#ebuilds to test mask and keyword changes
+			"app-text/A-1": {},
+			"app-text/B-1": { "KEYWORDS": "~x86" },
+			"app-text/C-1": { "KEYWORDS": "" },
+			"app-text/D-1": { "KEYWORDS": "~x86" },
+			"app-text/D-2": { "KEYWORDS": "" },
+
+			#ebuilds for mixed test for || dep handling
+			"sci-libs/K-1": { "DEPEND": " || ( sci-libs/L[bar] || ( sci-libs/M sci-libs/P ) )", "EAPI": 2},
+			"sci-libs/K-2": { "DEPEND": " || ( sci-libs/L[bar] || ( sci-libs/P sci-libs/M ) )", "EAPI": 2},
+			"sci-libs/K-3": { "DEPEND": " || ( sci-libs/M || ( sci-libs/L[bar] sci-libs/P ) )", "EAPI": 2},
+			"sci-libs/K-4": { "DEPEND": " || ( sci-libs/M || ( sci-libs/P sci-libs/L[bar] ) )", "EAPI": 2},
+			"sci-libs/K-5": { "DEPEND": " || ( sci-libs/P || ( sci-libs/L[bar] sci-libs/M ) )", "EAPI": 2},
+			"sci-libs/K-6": { "DEPEND": " || ( sci-libs/P || ( sci-libs/M sci-libs/L[bar] ) )", "EAPI": 2},
+			"sci-libs/K-7": { "DEPEND": " || ( sci-libs/M sci-libs/L[bar] )", "EAPI": 2},
+			"sci-libs/K-8": { "DEPEND": " || ( sci-libs/L[bar] sci-libs/M )", "EAPI": 2},
+
+			"sci-libs/L-1": { "IUSE": "bar" },
+			"sci-libs/M-1": { "KEYWORDS": "~x86" },
+			"sci-libs/P-1": { },
+
+			#ebuilds to test these nice "required by cat/pkg[foo]" messages
+			"dev-util/Q-1": { "DEPEND": "foo? ( dev-util/R[bar] )", "IUSE": "+foo", "EAPI": 2 },
+			"dev-util/Q-2": { "RDEPEND": "!foo? ( dev-util/R[bar] )", "IUSE": "foo", "EAPI": 2 },
+			"dev-util/R-1": { "IUSE": "bar" },
+
+			#ebuilds to test interaction with REQUIRED_USE
+			"app-portage/A-1": { "DEPEND": "app-portage/B[foo]", "EAPI": 2 }, 
+			"app-portage/A-2": { "DEPEND": "app-portage/B[foo=]", "IUSE": "+foo", "REQUIRED_USE": "foo", "EAPI": "4" }, 
+
+			"app-portage/B-1": { "IUSE": "foo +bar", "REQUIRED_USE": "^^ ( foo bar )", "EAPI": "4" }, 
+			"app-portage/C-1": { "IUSE": "+foo +bar", "REQUIRED_USE": "^^ ( foo bar )", "EAPI": "4" },
+			}
+
+		test_cases = (
+				#Test USE changes.
+				#The simple case.
+
+				ResolverPlaygroundTestCase(
+					["dev-libs/A:1"],
+					options = {"--autounmask": "n"},
+					success = False),
+				ResolverPlaygroundTestCase(
+					["dev-libs/A:1"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["dev-libs/C-1", "dev-libs/B-1", "dev-libs/A-1"],
+					use_changes = { "dev-libs/B-1": {"foo": True} } ),
+
+				#Make sure we restart if needed.
+				ResolverPlaygroundTestCase(
+					["dev-libs/A:1", "dev-libs/B"],
+					options = {"--autounmask": True},
+					all_permutations = True,
+					success = False,
+					mergelist = ["dev-libs/C-1", "dev-libs/B-1", "dev-libs/A-1"],
+					use_changes = { "dev-libs/B-1": {"foo": True} } ),
+				ResolverPlaygroundTestCase(
+					["dev-libs/A:1", "dev-libs/A:2", "dev-libs/B"],
+					options = {"--autounmask": True},
+					all_permutations = True,
+					success = False,
+					mergelist = ["dev-libs/D-1", "dev-libs/C-1", "dev-libs/B-1", "dev-libs/A-1", "dev-libs/A-2"],
+					ignore_mergelist_order = True,
+					use_changes = { "dev-libs/B-1": {"foo": True, "bar": True} } ),
+
+				#Test keywording.
+				#The simple case.
+
+				ResolverPlaygroundTestCase(
+					["app-misc/Z"],
+					options = {"--autounmask": "n"},
+					success = False),
+				ResolverPlaygroundTestCase(
+					["app-misc/Z"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["app-misc/Y-1", "app-misc/Z-1"],
+					unstable_keywords = ["app-misc/Y-1", "app-misc/Z-1"]),
+
+				#Make sure that the backtracking for slot conflicts handles our mess.
+
+				ResolverPlaygroundTestCase(
+					["=app-misc/V-1", "app-misc/W"],
+					options = {"--autounmask": True},
+					all_permutations = True,
+					success = False,
+					mergelist = ["app-misc/W-2", "app-misc/V-1"],
+					unstable_keywords = ["app-misc/W-2", "app-misc/V-1"]),
+
+				#Mixed testing
+				#Make sure we don't change use for something in a || dep if there is another choice
+				#that needs no change.
+				
+				ResolverPlaygroundTestCase(
+					["=sci-libs/K-1"],
+					options = {"--autounmask": True},
+					success = True,
+					mergelist = ["sci-libs/P-1", "sci-libs/K-1"]),
+				ResolverPlaygroundTestCase(
+					["=sci-libs/K-2"],
+					options = {"--autounmask": True},
+					success = True,
+					mergelist = ["sci-libs/P-1", "sci-libs/K-2"]),
+				ResolverPlaygroundTestCase(
+					["=sci-libs/K-3"],
+					options = {"--autounmask": True},
+					success = True,
+					mergelist = ["sci-libs/P-1", "sci-libs/K-3"]),
+				ResolverPlaygroundTestCase(
+					["=sci-libs/K-4"],
+					options = {"--autounmask": True},
+					success = True,
+					mergelist = ["sci-libs/P-1", "sci-libs/K-4"]),
+				ResolverPlaygroundTestCase(
+					["=sci-libs/K-5"],
+					options = {"--autounmask": True},
+					success = True,
+					mergelist = ["sci-libs/P-1", "sci-libs/K-5"]),
+				ResolverPlaygroundTestCase(
+					["=sci-libs/K-6"],
+					options = {"--autounmask": True},
+					success = True,
+					mergelist = ["sci-libs/P-1", "sci-libs/K-6"]),
+
+				#Make sure we prefer use changes over keyword changes.
+				ResolverPlaygroundTestCase(
+					["=sci-libs/K-7"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["sci-libs/L-1", "sci-libs/K-7"],
+					use_changes = { "sci-libs/L-1": { "bar": True } }),
+				ResolverPlaygroundTestCase(
+					["=sci-libs/K-8"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["sci-libs/L-1", "sci-libs/K-8"],
+					use_changes = { "sci-libs/L-1": { "bar": True } }),
+
+				#Test these nice "required by cat/pkg[foo]" messages.
+				ResolverPlaygroundTestCase(
+					["=dev-util/Q-1"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["dev-util/R-1", "dev-util/Q-1"],
+					use_changes = { "dev-util/R-1": { "bar": True } }),
+				ResolverPlaygroundTestCase(
+					["=dev-util/Q-2"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["dev-util/R-1", "dev-util/Q-2"],
+					use_changes = { "dev-util/R-1": { "bar": True } }),
+
+				#Test interaction with REQUIRED_USE.
+				ResolverPlaygroundTestCase(
+					["=app-portage/A-1"],
+					options = { "--autounmask": True },
+					use_changes = None,
+					success = False),
+				ResolverPlaygroundTestCase(
+					["=app-portage/A-2"],
+					options = { "--autounmask": True },
+					use_changes = None,
+					success = False),
+				ResolverPlaygroundTestCase(
+					["=app-portage/C-1"],
+					options = { "--autounmask": True },
+					use_changes = None,
+					success = False),
+
+				#Make sure we don't change masked/forced flags.
+				ResolverPlaygroundTestCase(
+					["dev-libs/E:1"],
+					options = {"--autounmask": True},
+					use_changes = None,
+					success = False),
+				ResolverPlaygroundTestCase(
+					["dev-libs/E:2"],
+					options = {"--autounmask": True},
+					use_changes = None,
+					success = False),
+
+				#Test mask and keyword changes.
+				ResolverPlaygroundTestCase(
+					["app-text/A"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["app-text/A-1"],
+					needed_p_mask_changes = ["app-text/A-1"]),
+				ResolverPlaygroundTestCase(
+					["app-text/B"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["app-text/B-1"],
+					unstable_keywords = ["app-text/B-1"],
+					needed_p_mask_changes = ["app-text/B-1"]),
+				ResolverPlaygroundTestCase(
+					["app-text/C"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["app-text/C-1"],
+					unstable_keywords = ["app-text/C-1"],
+					needed_p_mask_changes = ["app-text/C-1"]),
+				#Make sure unstable keyword is preferred over missing keyword
+				ResolverPlaygroundTestCase(
+					["app-text/D"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["app-text/D-1"],
+					unstable_keywords = ["app-text/D-1"]),
+				#Test missing keyword
+				ResolverPlaygroundTestCase(
+					["=app-text/D-2"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["app-text/D-2"],
+					unstable_keywords = ["app-text/D-2"])
+			)
+
+		profile = {
+			"use.mask":
+				(
+					"masked-flag",
+				),
+			"use.force":
+				(
+					"forced-flag",
+				),
+			"package.mask":
+				(
+					"app-text/A",
+					"app-text/B",
+					"app-text/C",
+				),
+		}
+
+		playground = ResolverPlayground(ebuilds=ebuilds, profile=profile)
+		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 testAutounmaskForLicenses(self):
+
+		ebuilds = {
+			"dev-libs/A-1": { "LICENSE": "TEST" },
+			"dev-libs/B-1": { "LICENSE": "TEST", "IUSE": "foo", "KEYWORDS": "~x86"},
+			"dev-libs/C-1": { "DEPEND": "dev-libs/B[foo]", "EAPI": 2 },
+			
+			"dev-libs/D-1": { "DEPEND": "dev-libs/E dev-libs/F", "LICENSE": "TEST" },
+			"dev-libs/E-1": { "LICENSE": "TEST" },
+			"dev-libs/E-2": { "LICENSE": "TEST" },
+			"dev-libs/F-1": { "DEPEND": "=dev-libs/E-1", "LICENSE": "TEST" },
+			}
+
+		test_cases = (
+				ResolverPlaygroundTestCase(
+					["=dev-libs/A-1"],
+					options = {"--autounmask": 'n'},
+					success = False),
+				ResolverPlaygroundTestCase(
+					["=dev-libs/A-1"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["dev-libs/A-1"],
+					license_changes = { "dev-libs/A-1": set(["TEST"]) }),
+
+				#Test license+keyword+use change at once.
+				ResolverPlaygroundTestCase(
+					["=dev-libs/C-1"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["dev-libs/B-1", "dev-libs/C-1"],
+					license_changes = { "dev-libs/B-1": set(["TEST"]) },
+					unstable_keywords = ["dev-libs/B-1"],
+					use_changes = { "dev-libs/B-1": { "foo": True } }),
+
+				#Test license with backtracking.
+				ResolverPlaygroundTestCase(
+					["=dev-libs/D-1"],
+					options = {"--autounmask": True},
+					success = False,
+					mergelist = ["dev-libs/E-1", "dev-libs/F-1", "dev-libs/D-1"],
+					license_changes = { "dev-libs/D-1": set(["TEST"]), "dev-libs/E-1": set(["TEST"]), "dev-libs/E-2": set(["TEST"]), "dev-libs/F-1": set(["TEST"]) }),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_backtracking.py b/portage_with_autodep/pym/portage/tests/resolver/test_backtracking.py
new file mode 100644
index 0000000..fc49306
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_backtracking.py
@@ -0,0 +1,169 @@
+# 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 BacktrackingTestCase(TestCase):
+
+	def testBacktracking(self):
+		ebuilds = {
+			"dev-libs/A-1": {},
+			"dev-libs/A-2": {},
+			"dev-libs/B-1": { "DEPEND": "dev-libs/A" },
+			}
+
+		test_cases = (
+				ResolverPlaygroundTestCase(
+					["=dev-libs/A-1", "dev-libs/B"],
+					all_permutations = True,
+					mergelist = ["dev-libs/A-1", "dev-libs/B-1"],
+					success = True),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds)
+
+		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 testHittingTheBacktrackLimit(self):
+		ebuilds = {
+			"dev-libs/A-1": {},
+			"dev-libs/A-2": {},
+			"dev-libs/B-1": {},
+			"dev-libs/B-2": {},
+			"dev-libs/C-1": { "DEPEND": "dev-libs/A dev-libs/B" },
+			"dev-libs/D-1": { "DEPEND": "=dev-libs/A-1 =dev-libs/B-1" },
+			}
+
+		test_cases = (
+				ResolverPlaygroundTestCase(
+					["dev-libs/C", "dev-libs/D"],
+					all_permutations = True,
+					mergelist = ["dev-libs/A-1", "dev-libs/B-1", "dev-libs/C-1", "dev-libs/D-1"],
+					ignore_mergelist_order = True,
+					success = True),
+				#This one hits the backtrack limit. Be aware that this depends on the argument order.
+				ResolverPlaygroundTestCase(
+					["dev-libs/D", "dev-libs/C"],
+					options = { "--backtrack": 1 },
+					mergelist = ["dev-libs/A-1", "dev-libs/B-1", "dev-libs/A-2", "dev-libs/B-2", "dev-libs/C-1", "dev-libs/D-1"],
+					ignore_mergelist_order = True,
+					slot_collision_solutions = [],
+					success = False),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds)
+
+		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 testBacktrackingGoodVersionFirst(self):
+		"""
+		When backtracking due to slot conflicts, we masked the version that has been pulled
+		in first. This is not always a good idea. Mask the highest version instead.
+		"""
+
+		ebuilds = {
+			"dev-libs/A-1": { "DEPEND": "=dev-libs/C-1 dev-libs/B" },
+			"dev-libs/B-1": { "DEPEND": "=dev-libs/C-1" },
+			"dev-libs/B-2": { "DEPEND": "=dev-libs/C-2" },
+			"dev-libs/C-1": { },
+			"dev-libs/C-2": { },
+			}
+
+		test_cases = (
+				ResolverPlaygroundTestCase(
+					["dev-libs/A"],
+					mergelist = ["dev-libs/C-1", "dev-libs/B-1", "dev-libs/A-1", ],
+					success = True),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds)
+
+		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 testBacktrackWithoutUpdates(self):
+		"""
+		If --update is not given we might have to mask the old installed version later.
+		"""
+
+		ebuilds = {
+			"dev-libs/A-1": { "DEPEND": "dev-libs/Z" },
+			"dev-libs/B-1": { "DEPEND": ">=dev-libs/Z-2" },
+			"dev-libs/Z-1": { },
+			"dev-libs/Z-2": { },
+			}
+
+		installed = {
+			"dev-libs/Z-1": { "USE": "" },
+			}
+
+		test_cases = (
+				ResolverPlaygroundTestCase(
+					["dev-libs/B", "dev-libs/A"],
+					all_permutations = True,
+					mergelist = ["dev-libs/Z-2", "dev-libs/B-1", "dev-libs/A-1", ],
+					ignore_mergelist_order = True,
+					success = True),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, installed=installed)
+
+		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 testBacktrackMissedUpdates(self):
+		"""
+		An update is missed due to a dependency on an older version.
+		"""
+
+		ebuilds = {
+			"dev-libs/A-1": { },
+			"dev-libs/A-2": { },
+			"dev-libs/B-1": { "RDEPEND": "<=dev-libs/A-1" },
+			}
+
+		installed = {
+			"dev-libs/A-1": { "USE": "" },
+			"dev-libs/B-1": { "USE": "", "RDEPEND": "<=dev-libs/A-1" },
+			}
+
+		options = {'--update' : True, '--deep' : True, '--selective' : True}
+
+		test_cases = (
+				ResolverPlaygroundTestCase(
+					["dev-libs/A", "dev-libs/B"],
+					options = options,
+					all_permutations = True,
+					mergelist = [],
+					success = True),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, installed=installed)
+
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_circular_dependencies.py b/portage_with_autodep/pym/portage/tests/resolver/test_circular_dependencies.py
new file mode 100644
index 0000000..f8331ac
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_circular_dependencies.py
@@ -0,0 +1,84 @@
+# Copyright 2010-2011 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 CircularDependencyTestCase(TestCase):
+
+	#TODO:
+	#	use config change by autounmask
+	#	conflict on parent's parent
+	#	difference in RDEPEND and DEPEND
+	#	is there anything else than priority buildtime and runtime?
+	#	play with use.{mask,force}
+	#	play with REQUIRED_USE
+	
+
+	def testCircularDependency(self):
+
+		ebuilds = {
+			"dev-libs/Z-1": { "DEPEND": "foo? ( !bar? ( dev-libs/Y ) )", "IUSE": "+foo bar", "EAPI": 1 }, 
+			"dev-libs/Z-2": { "DEPEND": "foo? ( dev-libs/Y ) !bar? ( dev-libs/Y )", "IUSE": "+foo bar", "EAPI": 1 }, 
+			"dev-libs/Z-3": { "DEPEND": "foo? ( !bar? ( dev-libs/Y ) ) foo? ( dev-libs/Y ) !bar? ( dev-libs/Y )", "IUSE": "+foo bar", "EAPI": 1 }, 
+			"dev-libs/Y-1": { "DEPEND": "dev-libs/Z" },
+			"dev-libs/W-1": { "DEPEND": "dev-libs/Z[foo] dev-libs/Y", "EAPI": 2 },
+			"dev-libs/W-2": { "DEPEND": "dev-libs/Z[foo=] dev-libs/Y", "IUSE": "+foo", "EAPI": 2 },
+			"dev-libs/W-3": { "DEPEND": "dev-libs/Z[bar] dev-libs/Y", "EAPI": 2 },
+
+			"app-misc/A-1": { "DEPEND": "foo? ( =app-misc/B-1 )", "IUSE": "+foo bar", "REQUIRED_USE": "^^ ( foo bar )", "EAPI": "4" },
+			"app-misc/A-2": { "DEPEND": "foo? ( =app-misc/B-2 ) bar? ( =app-misc/B-2 )", "IUSE": "+foo bar", "REQUIRED_USE": "^^ ( foo bar )", "EAPI": "4" },
+			"app-misc/B-1": { "DEPEND": "=app-misc/A-1" },
+			"app-misc/B-2": { "DEPEND": "=app-misc/A-2" },
+			}
+
+		test_cases = (
+			#Simple tests
+			ResolverPlaygroundTestCase(
+				["=dev-libs/Z-1"],
+				circular_dependency_solutions = { "dev-libs/Y-1": frozenset([frozenset([("foo", False)]), frozenset([("bar", True)])])},
+				success = False),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/Z-2"],
+				circular_dependency_solutions = { "dev-libs/Y-1": frozenset([frozenset([("foo", False), ("bar", True)])])},
+				success = False),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/Z-3"],
+				circular_dependency_solutions = { "dev-libs/Y-1": frozenset([frozenset([("foo", False), ("bar", True)])])},
+				success = False),
+
+			#Conflict on parent
+			ResolverPlaygroundTestCase(
+				["=dev-libs/W-1"],
+				circular_dependency_solutions = {},
+				success = False),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/W-2"],
+				circular_dependency_solutions = { "dev-libs/Y-1": frozenset([frozenset([("foo", False), ("bar", True)])])},
+				success = False),
+
+			#Conflict with autounmask
+			ResolverPlaygroundTestCase(
+				["=dev-libs/W-3"],
+				circular_dependency_solutions = { "dev-libs/Y-1": frozenset([frozenset([("foo", False)])])},
+				use_changes = { "dev-libs/Z-3": {"bar": True}},
+				success = False),
+
+			#Conflict with REQUIRED_USE
+			ResolverPlaygroundTestCase(
+				["=app-misc/B-1"],
+				circular_dependency_solutions = { "app-misc/B-1": frozenset([frozenset([("foo", False), ("bar", True)])])},
+				success = False),
+			ResolverPlaygroundTestCase(
+				["=app-misc/B-2"],
+				circular_dependency_solutions = {},
+				success = False),
+		)
+
+		playground = ResolverPlayground(ebuilds=ebuilds)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_depclean.py b/portage_with_autodep/pym/portage/tests/resolver/test_depclean.py
new file mode 100644
index 0000000..ba70144
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_depclean.py
@@ -0,0 +1,285 @@
+# 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 SimpleDepcleanTestCase(TestCase):
+
+	def testSimpleDepclean(self):
+		ebuilds = {
+			"dev-libs/A-1": {},
+			"dev-libs/B-1": {},
+			}
+		installed = {
+			"dev-libs/A-1": {},
+			"dev-libs/B-1": {},
+			}
+
+		world = (
+			"dev-libs/A",
+			)
+
+		test_cases = (
+			ResolverPlaygroundTestCase(
+				[],
+				options = {"--depclean": True},
+				success = True,
+				cleanlist = ["dev-libs/B-1"]),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, installed=installed, world=world)
+		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()
+
+class DepcleanWithDepsTestCase(TestCase):
+
+	def testDepcleanWithDeps(self):
+		ebuilds = {
+			"dev-libs/A-1": { "RDEPEND": "dev-libs/C" },
+			"dev-libs/B-1": { "RDEPEND": "dev-libs/D" },
+			"dev-libs/C-1": {},
+			"dev-libs/D-1": { "RDEPEND": "dev-libs/E" },
+			"dev-libs/E-1": { "RDEPEND": "dev-libs/F" },
+			"dev-libs/F-1": {},
+			}
+		installed = {
+			"dev-libs/A-1": { "RDEPEND": "dev-libs/C" },
+			"dev-libs/B-1": { "RDEPEND": "dev-libs/D" },
+			"dev-libs/C-1": {},
+			"dev-libs/D-1": { "RDEPEND": "dev-libs/E" },
+			"dev-libs/E-1": { "RDEPEND": "dev-libs/F" },
+			"dev-libs/F-1": {},
+			}
+
+		world = (
+			"dev-libs/A",
+			)
+
+		test_cases = (
+			ResolverPlaygroundTestCase(
+				[],
+				options = {"--depclean": True},
+				success = True,
+				cleanlist = ["dev-libs/B-1", "dev-libs/D-1",
+					"dev-libs/E-1", "dev-libs/F-1"]),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, installed=installed, world=world)
+		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()
+
+
+class DepcleanWithInstalledMaskedTestCase(TestCase):
+
+	def testDepcleanWithInstalledMasked(self):
+		"""
+		Test case for bug 332719.
+		emerge --declean ignores that B is masked by license and removes C.
+		The next emerge -uDN world doesn't take B and installs C again.
+		"""
+		ebuilds = {
+			"dev-libs/A-1": { "RDEPEND": "|| ( dev-libs/B dev-libs/C )" },
+			"dev-libs/B-1": { "LICENSE": "TEST", "KEYWORDS": "x86" },
+			"dev-libs/C-1": { "KEYWORDS": "x86" },
+			}
+		installed = {
+			"dev-libs/A-1": { "RDEPEND": "|| ( dev-libs/B dev-libs/C )" },
+			"dev-libs/B-1": { "LICENSE": "TEST", "KEYWORDS": "x86" },
+			"dev-libs/C-1": { "KEYWORDS": "x86" },
+			}
+
+		world = (
+			"dev-libs/A",
+			)
+
+		test_cases = (
+			ResolverPlaygroundTestCase(
+				[],
+				options = {"--depclean": True},
+				success = True,
+				#cleanlist = ["dev-libs/C-1"]),
+				cleanlist = ["dev-libs/B-1"]),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, installed=installed, world=world)
+		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()
+
+class DepcleanInstalledKeywordMaskedSlotTestCase(TestCase):
+
+	def testDepcleanInstalledKeywordMaskedSlot(self):
+		"""
+		Verify that depclean removes newer slot
+		masked by KEYWORDS (see bug #350285).
+		"""
+		ebuilds = {
+			"dev-libs/A-1": { "RDEPEND": "|| ( =dev-libs/B-2.7* =dev-libs/B-2.6* )" },
+			"dev-libs/B-2.6": { "SLOT":"2.6", "KEYWORDS": "x86" },
+			"dev-libs/B-2.7": { "SLOT":"2.7", "KEYWORDS": "~x86" },
+			}
+		installed = {
+			"dev-libs/A-1": { "EAPI" : "3", "RDEPEND": "|| ( dev-libs/B:2.7 dev-libs/B:2.6 )" },
+			"dev-libs/B-2.6": { "SLOT":"2.6", "KEYWORDS": "x86" },
+			"dev-libs/B-2.7": { "SLOT":"2.7", "KEYWORDS": "~x86" },
+			}
+
+		world = (
+			"dev-libs/A",
+			)
+
+		test_cases = (
+			ResolverPlaygroundTestCase(
+				[],
+				options = {"--depclean": True},
+				success = True,
+				cleanlist = ["dev-libs/B-2.7"]),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, installed=installed, world=world)
+		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()
+
+class DepcleanWithExcludeTestCase(TestCase):
+
+	def testDepcleanWithExclude(self):
+
+		installed = {
+			"dev-libs/A-1": {},
+			"dev-libs/B-1": { "RDEPEND": "dev-libs/A" },
+			}
+
+		test_cases = (
+			#Without --exclude.
+			ResolverPlaygroundTestCase(
+				[],
+				options = {"--depclean": True},
+				success = True,
+				cleanlist = ["dev-libs/B-1", "dev-libs/A-1"]),
+			ResolverPlaygroundTestCase(
+				["dev-libs/A"],
+				options = {"--depclean": True},
+				success = True,
+				cleanlist = []),
+			ResolverPlaygroundTestCase(
+				["dev-libs/B"],
+				options = {"--depclean": True},
+				success = True,
+				cleanlist = ["dev-libs/B-1"]),
+
+			#With --exclude
+			ResolverPlaygroundTestCase(
+				[],
+				options = {"--depclean": True, "--exclude": ["dev-libs/A"]},
+				success = True,
+				cleanlist = ["dev-libs/B-1"]),
+			ResolverPlaygroundTestCase(
+				["dev-libs/B"],
+				options = {"--depclean": True, "--exclude": ["dev-libs/B"]},
+				success = True,
+				cleanlist = []),
+			)
+
+		playground = ResolverPlayground(installed=installed)
+		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()
+
+class DepcleanWithExcludeAndSlotsTestCase(TestCase):
+
+	def testDepcleanWithExcludeAndSlots(self):
+
+		installed = {
+			"dev-libs/Z-1": { "SLOT": 1},
+			"dev-libs/Z-2": { "SLOT": 2},
+			"dev-libs/Y-1": { "RDEPEND": "=dev-libs/Z-1", "SLOT": 1 },
+			"dev-libs/Y-2": { "RDEPEND": "=dev-libs/Z-2", "SLOT": 2 },
+			}
+
+		world = [ "dev-libs/Y" ]
+
+		test_cases = (
+			#Without --exclude.
+			ResolverPlaygroundTestCase(
+				[],
+				options = {"--depclean": True},
+				success = True,
+				cleanlist = ["dev-libs/Y-1", "dev-libs/Z-1"]),
+			ResolverPlaygroundTestCase(
+				[],
+				options = {"--depclean": True, "--exclude": ["dev-libs/Z"]},
+				success = True,
+				cleanlist = ["dev-libs/Y-1"]),
+			ResolverPlaygroundTestCase(
+				[],
+				options = {"--depclean": True, "--exclude": ["dev-libs/Y"]},
+				success = True,
+				cleanlist = []),
+			)
+
+		playground = ResolverPlayground(installed=installed, world=world)
+		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()
+
+class DepcleanAndWildcardsTestCase(TestCase):
+
+	def testDepcleanAndWildcards(self):
+
+		installed = {
+			"dev-libs/A-1": { "RDEPEND": "dev-libs/B" },
+			"dev-libs/B-1": {},
+			}
+
+		test_cases = (
+			ResolverPlaygroundTestCase(
+				["*/*"],
+				options = {"--depclean": True},
+				success = True,
+				cleanlist = ["dev-libs/A-1", "dev-libs/B-1"]),
+			ResolverPlaygroundTestCase(
+				["dev-libs/*"],
+				options = {"--depclean": True},
+				success = True,
+				cleanlist = ["dev-libs/A-1", "dev-libs/B-1"]),
+			ResolverPlaygroundTestCase(
+				["*/A"],
+				options = {"--depclean": True},
+				success = True,
+				cleanlist = ["dev-libs/A-1"]),
+			ResolverPlaygroundTestCase(
+				["*/B"],
+				options = {"--depclean": True},
+				success = True,
+				cleanlist = []),
+			)
+
+		playground = ResolverPlayground(installed=installed)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_depth.py b/portage_with_autodep/pym/portage/tests/resolver/test_depth.py
new file mode 100644
index 0000000..cb1e2dd
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_depth.py
@@ -0,0 +1,252 @@
+# Copyright 2011 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 ResolverDepthTestCase(TestCase):
+
+	def testResolverDepth(self):
+
+		ebuilds = {
+			"dev-libs/A-1": {"RDEPEND" : "dev-libs/B"},
+			"dev-libs/A-2": {"RDEPEND" : "dev-libs/B"},
+			"dev-libs/B-1": {"RDEPEND" : "dev-libs/C"},
+			"dev-libs/B-2": {"RDEPEND" : "dev-libs/C"},
+			"dev-libs/C-1": {},
+			"dev-libs/C-2": {},
+
+			"virtual/libusb-0"         : {"EAPI" :"2", "SLOT" : "0", "RDEPEND" : "|| ( >=dev-libs/libusb-0.1.12-r1:0 dev-libs/libusb-compat >=sys-freebsd/freebsd-lib-8.0[usb] )"},
+			"virtual/libusb-1"         : {"EAPI" :"2", "SLOT" : "1", "RDEPEND" : ">=dev-libs/libusb-1.0.4:1"},
+			"dev-libs/libusb-0.1.13"   : {},
+			"dev-libs/libusb-1.0.5"    : {"SLOT":"1"},
+			"dev-libs/libusb-compat-1" : {},
+			"sys-freebsd/freebsd-lib-8": {"IUSE" : "+usb"},
+
+			"sys-fs/udev-164"          : {"EAPI" : "1", "RDEPEND" : "virtual/libusb:0"},
+
+			"virtual/jre-1.5.0"        : {"SLOT" : "1.5", "RDEPEND" : "|| ( =dev-java/sun-jre-bin-1.5.0* =virtual/jdk-1.5.0* )"},
+			"virtual/jre-1.5.0-r1"     : {"SLOT" : "1.5", "RDEPEND" : "|| ( =dev-java/sun-jre-bin-1.5.0* =virtual/jdk-1.5.0* )"},
+			"virtual/jre-1.6.0"        : {"SLOT" : "1.6", "RDEPEND" : "|| ( =dev-java/sun-jre-bin-1.6.0* =virtual/jdk-1.6.0* )"},
+			"virtual/jre-1.6.0-r1"     : {"SLOT" : "1.6", "RDEPEND" : "|| ( =dev-java/sun-jre-bin-1.6.0* =virtual/jdk-1.6.0* )"},
+			"virtual/jdk-1.5.0"        : {"SLOT" : "1.5", "RDEPEND" : "|| ( =dev-java/sun-jdk-1.5.0* dev-java/gcj-jdk )"},
+			"virtual/jdk-1.5.0-r1"     : {"SLOT" : "1.5", "RDEPEND" : "|| ( =dev-java/sun-jdk-1.5.0* dev-java/gcj-jdk )"},
+			"virtual/jdk-1.6.0"        : {"SLOT" : "1.6", "RDEPEND" : "|| ( =dev-java/icedtea-6* =dev-java/sun-jdk-1.6.0* )"},
+			"virtual/jdk-1.6.0-r1"     : {"SLOT" : "1.6", "RDEPEND" : "|| ( =dev-java/icedtea-6* =dev-java/sun-jdk-1.6.0* )"},
+			"dev-java/gcj-jdk-4.5"     : {},
+			"dev-java/gcj-jdk-4.5-r1"  : {},
+			"dev-java/icedtea-6.1"     : {},
+			"dev-java/icedtea-6.1-r1"  : {},
+			"dev-java/sun-jdk-1.5"     : {"SLOT" : "1.5"},
+			"dev-java/sun-jdk-1.6"     : {"SLOT" : "1.6"},
+			"dev-java/sun-jre-bin-1.5" : {"SLOT" : "1.5"},
+			"dev-java/sun-jre-bin-1.6" : {"SLOT" : "1.6"},
+
+			"dev-java/ant-core-1.8"   : {"DEPEND"  : ">=virtual/jdk-1.4"},
+			"dev-db/hsqldb-1.8"       : {"RDEPEND" : ">=virtual/jre-1.6"},
+			}
+
+		installed = {
+			"dev-libs/A-1": {"RDEPEND" : "dev-libs/B"},
+			"dev-libs/B-1": {"RDEPEND" : "dev-libs/C"},
+			"dev-libs/C-1": {},
+
+			"virtual/jre-1.5.0"       : {"SLOT" : "1.5", "RDEPEND" : "|| ( =virtual/jdk-1.5.0* =dev-java/sun-jre-bin-1.5.0* )"},
+			"virtual/jre-1.6.0"       : {"SLOT" : "1.6", "RDEPEND" : "|| ( =virtual/jdk-1.6.0* =dev-java/sun-jre-bin-1.6.0* )"},
+			"virtual/jdk-1.5.0"       : {"SLOT" : "1.5", "RDEPEND" : "|| ( =dev-java/sun-jdk-1.5.0* dev-java/gcj-jdk )"},
+			"virtual/jdk-1.6.0"       : {"SLOT" : "1.6", "RDEPEND" : "|| ( =dev-java/icedtea-6* =dev-java/sun-jdk-1.6.0* )"},
+			"dev-java/gcj-jdk-4.5"    : {},
+			"dev-java/icedtea-6.1"    : {},
+
+			"virtual/libusb-0"         : {"EAPI" :"2", "SLOT" : "0", "RDEPEND" : "|| ( >=dev-libs/libusb-0.1.12-r1:0 dev-libs/libusb-compat >=sys-freebsd/freebsd-lib-8.0[usb] )"},
+			}
+
+		world = ["dev-libs/A"]
+
+		test_cases = (
+			ResolverPlaygroundTestCase(
+				["dev-libs/A"],
+				options = {"--update": True, "--deep": 0},
+				success = True,
+				mergelist = ["dev-libs/A-2"]),
+
+			ResolverPlaygroundTestCase(
+				["dev-libs/A"],
+				options = {"--update": True, "--deep": 1},
+				success = True,
+				mergelist = ["dev-libs/B-2", "dev-libs/A-2"]),
+
+			ResolverPlaygroundTestCase(
+				["dev-libs/A"],
+				options = {"--update": True, "--deep": 2},
+				success = True,
+				mergelist = ["dev-libs/C-2", "dev-libs/B-2", "dev-libs/A-2"]),
+
+			ResolverPlaygroundTestCase(
+				["@world"],
+				options = {"--update": True, "--deep": True},
+				success = True,
+				mergelist = ["dev-libs/C-2", "dev-libs/B-2", "dev-libs/A-2"]),
+
+			ResolverPlaygroundTestCase(
+				["@world"],
+				options = {"--emptytree": True},
+				success = True,
+				mergelist = ["dev-libs/C-2", "dev-libs/B-2", "dev-libs/A-2"]),
+
+			ResolverPlaygroundTestCase(
+				["@world"],
+				options = {"--selective": True, "--deep": True},
+				success = True,
+				mergelist = []),
+
+			ResolverPlaygroundTestCase(
+				["dev-libs/A"],
+				options = {"--deep": 2},
+				success = True,
+				mergelist = ["dev-libs/A-2"]),
+
+			ResolverPlaygroundTestCase(
+				["virtual/jre"],
+				options = {},
+				success = True,
+				mergelist = ['virtual/jre-1.6.0-r1']),
+
+			ResolverPlaygroundTestCase(
+				["virtual/jre"],
+				options = {"--deep" : True},
+				success = True,
+				mergelist = ['virtual/jre-1.6.0-r1']),
+
+			# Test bug #141118, where we avoid pulling in
+			# redundant deps, satisfying nested virtuals
+			# as efficiently as possible.
+			ResolverPlaygroundTestCase(
+				["virtual/jre"],
+				options = {"--selective" : True, "--deep" : True},
+				success = True,
+				mergelist = []),
+
+			# Test bug #150361, where depgraph._greedy_slots()
+			# is triggered by --update with AtomArg.
+			ResolverPlaygroundTestCase(
+				["virtual/jre"],
+				options = {"--update" : True},
+				success = True,
+				ambiguous_merge_order = True,
+				mergelist = [('virtual/jre-1.6.0-r1', 'virtual/jre-1.5.0-r1')]),
+
+			# Recursively traversed virtual dependencies, and their
+			# direct dependencies, are considered to have the same
+			# depth as direct dependencies.
+			ResolverPlaygroundTestCase(
+				["virtual/jre"],
+				options = {"--update" : True, "--deep" : 1},
+				success = True,
+				ambiguous_merge_order = True,
+				merge_order_assertions=(('dev-java/icedtea-6.1-r1', 'virtual/jdk-1.6.0-r1'), ('virtual/jdk-1.6.0-r1', 'virtual/jre-1.6.0-r1'),
+					('dev-java/gcj-jdk-4.5-r1', 'virtual/jdk-1.5.0-r1'), ('virtual/jdk-1.5.0-r1', 'virtual/jre-1.5.0-r1')),
+				mergelist = [('dev-java/icedtea-6.1-r1', 'dev-java/gcj-jdk-4.5-r1', 'virtual/jdk-1.6.0-r1', 'virtual/jdk-1.5.0-r1', 'virtual/jre-1.6.0-r1', 'virtual/jre-1.5.0-r1')]),
+
+			ResolverPlaygroundTestCase(
+				["virtual/jre:1.5"],
+				options = {"--update" : True},
+				success = True,
+				mergelist = ['virtual/jre-1.5.0-r1']),
+
+			ResolverPlaygroundTestCase(
+				["virtual/jre:1.6"],
+				options = {"--update" : True},
+				success = True,
+				mergelist = ['virtual/jre-1.6.0-r1']),
+
+			# Test that we don't pull in any unnecessary updates
+			# when --update is not specified, even though we
+			# specified --deep.
+			ResolverPlaygroundTestCase(
+				["dev-java/ant-core"],
+				options = {"--deep" : True},
+				success = True,
+				mergelist = ["dev-java/ant-core-1.8"]),
+
+			ResolverPlaygroundTestCase(
+				["dev-java/ant-core"],
+				options = {"--update" : True},
+				success = True,
+				mergelist = ["dev-java/ant-core-1.8"]),
+
+			# Recursively traversed virtual dependencies, and their
+			# direct dependencies, are considered to have the same
+			# depth as direct dependencies.
+			ResolverPlaygroundTestCase(
+				["dev-java/ant-core"],
+				options = {"--update" : True, "--deep" : 1},
+				success = True,
+				mergelist = ['dev-java/icedtea-6.1-r1', 'virtual/jdk-1.6.0-r1', 'dev-java/ant-core-1.8']),
+
+			ResolverPlaygroundTestCase(
+				["dev-db/hsqldb"],
+				options = {"--deep" : True},
+				success = True,
+				mergelist = ["dev-db/hsqldb-1.8"]),
+
+			# Don't traverse deps of an installed package with --deep=0,
+			# even if it's a virtual.
+			ResolverPlaygroundTestCase(
+				["virtual/libusb:0"],
+				options = {"--selective" : True, "--deep" : 0},
+				success = True,
+				mergelist = []),
+
+			# Satisfy unsatisfied dep of installed package with --deep=1.
+			ResolverPlaygroundTestCase(
+				["virtual/libusb:0"],
+				options = {"--selective" : True, "--deep" : 1},
+				success = True,
+				mergelist = ['dev-libs/libusb-0.1.13']),
+
+			# Pull in direct dep of virtual, even with --deep=0.
+			ResolverPlaygroundTestCase(
+				["sys-fs/udev"],
+				options = {"--deep" : 0},
+				success = True,
+				mergelist = ['dev-libs/libusb-0.1.13', 'sys-fs/udev-164']),
+
+			# Test --nodeps with direct virtual deps.
+			ResolverPlaygroundTestCase(
+				["sys-fs/udev"],
+				options = {"--nodeps" : True},
+				success = True,
+				mergelist = ["sys-fs/udev-164"]),
+
+			# Test that --nodeps overrides --deep.
+			ResolverPlaygroundTestCase(
+				["sys-fs/udev"],
+				options = {"--nodeps" : True, "--deep" : True},
+				success = True,
+				mergelist = ["sys-fs/udev-164"]),
+
+			# Test that --nodeps overrides --emptytree.
+			ResolverPlaygroundTestCase(
+				["sys-fs/udev"],
+				options = {"--nodeps" : True, "--emptytree" : True},
+				success = True,
+				mergelist = ["sys-fs/udev-164"]),
+
+			# Test --emptytree with virtuals.
+			ResolverPlaygroundTestCase(
+				["sys-fs/udev"],
+				options = {"--emptytree" : True},
+				success = True,
+				mergelist = ['dev-libs/libusb-0.1.13', 'virtual/libusb-0', 'sys-fs/udev-164']),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, installed=installed,
+			world=world)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_eapi.py b/portage_with_autodep/pym/portage/tests/resolver/test_eapi.py
new file mode 100644
index 0000000..525b585
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_eapi.py
@@ -0,0 +1,115 @@
+# 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 EAPITestCase(TestCase):
+
+	def testEAPI(self):
+
+		ebuilds = {
+			#EAPI-1: IUSE-defaults
+			"dev-libs/A-1.0": { "EAPI": 0, "IUSE": "+foo" }, 
+			"dev-libs/A-1.1": { "EAPI": 1, "IUSE": "+foo" }, 
+			"dev-libs/A-1.2": { "EAPI": 2, "IUSE": "+foo" }, 
+			"dev-libs/A-1.3": { "EAPI": 3, "IUSE": "+foo" }, 
+			"dev-libs/A-1.4": { "EAPI": "4", "IUSE": "+foo" }, 
+
+			#EAPI-1: slot deps
+			"dev-libs/A-2.0": { "EAPI": 0, "DEPEND": "dev-libs/B:0" }, 
+			"dev-libs/A-2.1": { "EAPI": 1, "DEPEND": "dev-libs/B:0" }, 
+			"dev-libs/A-2.2": { "EAPI": 2, "DEPEND": "dev-libs/B:0" }, 
+			"dev-libs/A-2.3": { "EAPI": 3, "DEPEND": "dev-libs/B:0" }, 
+			"dev-libs/A-2.4": { "EAPI": "4", "DEPEND": "dev-libs/B:0" }, 
+
+			#EAPI-2: use deps
+			"dev-libs/A-3.0": { "EAPI": 0, "DEPEND": "dev-libs/B[foo]" }, 
+			"dev-libs/A-3.1": { "EAPI": 1, "DEPEND": "dev-libs/B[foo]" }, 
+			"dev-libs/A-3.2": { "EAPI": 2, "DEPEND": "dev-libs/B[foo]" }, 
+			"dev-libs/A-3.3": { "EAPI": 3, "DEPEND": "dev-libs/B[foo]" }, 
+			"dev-libs/A-3.4": { "EAPI": "4", "DEPEND": "dev-libs/B[foo]" }, 
+
+			#EAPI-2: strong blocks
+			"dev-libs/A-4.0": { "EAPI": 0, "DEPEND": "!!dev-libs/B" }, 
+			"dev-libs/A-4.1": { "EAPI": 1, "DEPEND": "!!dev-libs/B" }, 
+			"dev-libs/A-4.2": { "EAPI": 2, "DEPEND": "!!dev-libs/B" }, 
+			"dev-libs/A-4.3": { "EAPI": 3, "DEPEND": "!!dev-libs/B" }, 
+			"dev-libs/A-4.4": { "EAPI": "4", "DEPEND": "!!dev-libs/B" }, 
+
+			#EAPI-4: slot operator deps
+			#~ "dev-libs/A-5.0": { "EAPI": 0, "DEPEND": "dev-libs/B:*" }, 
+			#~ "dev-libs/A-5.1": { "EAPI": 1, "DEPEND": "dev-libs/B:*" }, 
+			#~ "dev-libs/A-5.2": { "EAPI": 2, "DEPEND": "dev-libs/B:*" }, 
+			#~ "dev-libs/A-5.3": { "EAPI": 3, "DEPEND": "dev-libs/B:*" }, 
+			#~ "dev-libs/A-5.4": { "EAPI": "4", "DEPEND": "dev-libs/B:*" }, 
+
+			#EAPI-4: use dep defaults
+			"dev-libs/A-6.0": { "EAPI": 0, "DEPEND": "dev-libs/B[bar(+)]" }, 
+			"dev-libs/A-6.1": { "EAPI": 1, "DEPEND": "dev-libs/B[bar(+)]" }, 
+			"dev-libs/A-6.2": { "EAPI": 2, "DEPEND": "dev-libs/B[bar(+)]" }, 
+			"dev-libs/A-6.3": { "EAPI": 3, "DEPEND": "dev-libs/B[bar(+)]" }, 
+			"dev-libs/A-6.4": { "EAPI": "4", "DEPEND": "dev-libs/B[bar(+)]" }, 
+			
+			#EAPI-4: REQUIRED_USE
+			"dev-libs/A-7.0": { "EAPI": 0, "IUSE": "foo bar", "REQUIRED_USE": "|| ( foo bar )" }, 
+			"dev-libs/A-7.1": { "EAPI": 1, "IUSE": "foo +bar", "REQUIRED_USE": "|| ( foo bar )" }, 
+			"dev-libs/A-7.2": { "EAPI": 2, "IUSE": "foo +bar", "REQUIRED_USE": "|| ( foo bar )" }, 
+			"dev-libs/A-7.3": { "EAPI": 3, "IUSE": "foo +bar", "REQUIRED_USE": "|| ( foo bar )" }, 
+			"dev-libs/A-7.4": { "EAPI": "4", "IUSE": "foo +bar", "REQUIRED_USE": "|| ( foo bar )" }, 
+
+			"dev-libs/B-1": {"EAPI": 1, "IUSE": "+foo"}, 
+			}
+
+		test_cases = (
+			ResolverPlaygroundTestCase(["=dev-libs/A-1.0"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-1.1"], success = True, mergelist = ["dev-libs/A-1.1"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-1.2"], success = True, mergelist = ["dev-libs/A-1.2"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-1.3"], success = True, mergelist = ["dev-libs/A-1.3"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-1.4"], success = True, mergelist = ["dev-libs/A-1.4"]),
+
+			ResolverPlaygroundTestCase(["=dev-libs/A-2.0"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-2.1"], success = True, mergelist = ["dev-libs/B-1", "dev-libs/A-2.1"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-2.2"], success = True, mergelist = ["dev-libs/B-1", "dev-libs/A-2.2"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-2.3"], success = True, mergelist = ["dev-libs/B-1", "dev-libs/A-2.3"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-2.4"], success = True, mergelist = ["dev-libs/B-1", "dev-libs/A-2.4"]),
+
+			ResolverPlaygroundTestCase(["=dev-libs/A-3.0"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-3.1"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-3.2"], success = True, mergelist = ["dev-libs/B-1", "dev-libs/A-3.2"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-3.3"], success = True, mergelist = ["dev-libs/B-1", "dev-libs/A-3.3"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-3.4"], success = True, mergelist = ["dev-libs/B-1", "dev-libs/A-3.4"]),
+
+			ResolverPlaygroundTestCase(["=dev-libs/A-4.0"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-4.1"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-4.2"], success = True, mergelist = ["dev-libs/A-4.2"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-4.3"], success = True, mergelist = ["dev-libs/A-4.3"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-4.4"], success = True, mergelist = ["dev-libs/A-4.4"]),
+
+			ResolverPlaygroundTestCase(["=dev-libs/A-5.0"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-5.1"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-5.2"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-5.3"], success = False),
+			# not implemented: EAPI-4: slot operator deps
+			#~ ResolverPlaygroundTestCase(["=dev-libs/A-5.4"], success = True, mergelist = ["dev-libs/B-1", "dev-libs/A-5.4"]),
+
+			ResolverPlaygroundTestCase(["=dev-libs/A-6.0"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-6.1"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-6.2"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-6.3"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-6.4"], success = True, mergelist = ["dev-libs/B-1", "dev-libs/A-6.4"]),
+			
+			ResolverPlaygroundTestCase(["=dev-libs/A-7.0"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-7.1"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-7.2"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-7.3"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-7.4"], success = True, mergelist = ["dev-libs/A-7.4"]),
+		)
+
+		playground = ResolverPlayground(ebuilds=ebuilds)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_merge_order.py b/portage_with_autodep/pym/portage/tests/resolver/test_merge_order.py
new file mode 100644
index 0000000..0a52c81
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_merge_order.py
@@ -0,0 +1,453 @@
+# Copyright 2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import portage
+from portage.tests import TestCase
+from portage.tests.resolver.ResolverPlayground import (ResolverPlayground,
+	ResolverPlaygroundTestCase)
+
+class MergeOrderTestCase(TestCase):
+
+	def testMergeOrder(self):
+		ebuilds = {
+			"app-misc/blocker-buildtime-a-1" : {},
+			"app-misc/blocker-buildtime-unbuilt-a-1" : {
+				"DEPEND" : "!app-misc/installed-blocker-a",
+			},
+			"app-misc/blocker-buildtime-unbuilt-hard-a-1" : {
+				"EAPI"   : "2",
+				"DEPEND" : "!!app-misc/installed-blocker-a",
+			},
+			"app-misc/blocker-update-order-a-1" : {},
+			"app-misc/blocker-update-order-hard-a-1" : {},
+			"app-misc/blocker-update-order-hard-unsolvable-a-1" : {},
+			"app-misc/blocker-runtime-a-1" : {},
+			"app-misc/blocker-runtime-b-1" : {},
+			"app-misc/blocker-runtime-hard-a-1" : {},
+			"app-misc/circ-buildtime-a-0": {},
+			"app-misc/circ-buildtime-a-1": {
+				"RDEPEND": "app-misc/circ-buildtime-b",
+			},
+			"app-misc/circ-buildtime-b-1": {
+				"RDEPEND": "app-misc/circ-buildtime-c",
+			},
+			"app-misc/circ-buildtime-c-1": {
+				"DEPEND": "app-misc/circ-buildtime-a",
+			},
+			"app-misc/circ-buildtime-unsolvable-a-1": {
+				"RDEPEND": "app-misc/circ-buildtime-unsolvable-b",
+			},
+			"app-misc/circ-buildtime-unsolvable-b-1": {
+				"RDEPEND": "app-misc/circ-buildtime-unsolvable-c",
+			},
+			"app-misc/circ-buildtime-unsolvable-c-1": {
+				"DEPEND": "app-misc/circ-buildtime-unsolvable-a",
+			},
+			"app-misc/circ-post-runtime-a-1": {
+				"PDEPEND": "app-misc/circ-post-runtime-b",
+			},
+			"app-misc/circ-post-runtime-b-1": {
+				"RDEPEND": "app-misc/circ-post-runtime-c",
+			},
+			"app-misc/circ-post-runtime-c-1": {
+				"RDEPEND": "app-misc/circ-post-runtime-a",
+			},
+			"app-misc/circ-runtime-a-1": {
+				"RDEPEND": "app-misc/circ-runtime-b",
+			},
+			"app-misc/circ-runtime-b-1": {
+				"RDEPEND": "app-misc/circ-runtime-c",
+			},
+			"app-misc/circ-runtime-c-1": {
+				"RDEPEND": "app-misc/circ-runtime-a",
+			},
+			"app-misc/circ-satisfied-a-0": {
+				"RDEPEND": "app-misc/circ-satisfied-b",
+			},
+			"app-misc/circ-satisfied-a-1": {
+				"RDEPEND": "app-misc/circ-satisfied-b",
+			},
+			"app-misc/circ-satisfied-b-0": {
+				"RDEPEND": "app-misc/circ-satisfied-c",
+			},
+			"app-misc/circ-satisfied-b-1": {
+				"RDEPEND": "app-misc/circ-satisfied-c",
+			},
+			"app-misc/circ-satisfied-c-0": {
+				"DEPEND": "app-misc/circ-satisfied-a",
+				"RDEPEND": "app-misc/circ-satisfied-a",
+			},
+			"app-misc/circ-satisfied-c-1": {
+				"DEPEND": "app-misc/circ-satisfied-a",
+				"RDEPEND": "app-misc/circ-satisfied-a",
+			},
+			"app-misc/circ-smallest-a-1": {
+				"RDEPEND": "app-misc/circ-smallest-b",
+			},
+			"app-misc/circ-smallest-b-1": {
+				"RDEPEND": "app-misc/circ-smallest-a",
+			},
+			"app-misc/circ-smallest-c-1": {
+				"RDEPEND": "app-misc/circ-smallest-d",
+			},
+			"app-misc/circ-smallest-d-1": {
+				"RDEPEND": "app-misc/circ-smallest-e",
+			},
+			"app-misc/circ-smallest-e-1": {
+				"RDEPEND": "app-misc/circ-smallest-c",
+			},
+			"app-misc/circ-smallest-f-1": {
+				"RDEPEND": "app-misc/circ-smallest-g app-misc/circ-smallest-a app-misc/circ-smallest-c",
+			},
+			"app-misc/circ-smallest-g-1": {
+				"RDEPEND": "app-misc/circ-smallest-f",
+			},
+			"app-misc/installed-blocker-a-1" : {
+				"EAPI"   : "2",
+				"DEPEND" : "!app-misc/blocker-buildtime-a",
+				"RDEPEND" : "!app-misc/blocker-runtime-a !app-misc/blocker-runtime-b !!app-misc/blocker-runtime-hard-a",
+			},
+			"app-misc/installed-old-version-blocks-a-1" : {
+				"RDEPEND" : "!app-misc/blocker-update-order-a",
+			},
+			"app-misc/installed-old-version-blocks-a-2" : {},
+			"app-misc/installed-old-version-blocks-hard-a-1" : {
+				"EAPI"    : "2",
+				"RDEPEND" : "!!app-misc/blocker-update-order-hard-a",
+			},
+			"app-misc/installed-old-version-blocks-hard-a-2" : {},
+			"app-misc/installed-old-version-blocks-hard-unsolvable-a-1" : {
+				"EAPI"    : "2",
+				"RDEPEND" : "!!app-misc/blocker-update-order-hard-unsolvable-a",
+			},
+			"app-misc/installed-old-version-blocks-hard-unsolvable-a-2" : {
+				"DEPEND"  : "app-misc/blocker-update-order-hard-unsolvable-a",
+				"RDEPEND" : "",
+			},
+			"app-misc/some-app-a-1": {
+				"RDEPEND": "app-misc/circ-runtime-a app-misc/circ-runtime-b",
+			},
+			"app-misc/some-app-b-1": {
+				"RDEPEND": "app-misc/circ-post-runtime-a app-misc/circ-post-runtime-b",
+			},
+			"app-misc/some-app-c-1": {
+				"RDEPEND": "app-misc/circ-buildtime-a app-misc/circ-buildtime-b",
+			},
+			"app-admin/eselect-python-20100321" : {},
+			"sys-apps/portage-2.1.9.42" : {
+				"DEPEND"  : "dev-lang/python",
+				"RDEPEND" : "dev-lang/python",
+			},
+			"sys-apps/portage-2.1.9.49" : {
+				"DEPEND"  : "dev-lang/python >=app-admin/eselect-python-20091230",
+				"RDEPEND" : "dev-lang/python",
+			},
+			"dev-lang/python-3.1" : {},
+			"dev-lang/python-3.2" : {},
+			"virtual/libc-0" : {
+				"RDEPEND" : "sys-libs/glibc",
+			},
+			"sys-devel/gcc-4.5.2" : {},
+			"sys-devel/binutils-2.18" : {},
+			"sys-devel/binutils-2.20.1" : {},
+			"sys-libs/glibc-2.11" : {
+				"DEPEND" : "virtual/os-headers sys-devel/gcc sys-devel/binutils",
+				"RDEPEND": "",
+			},
+			"sys-libs/glibc-2.13" : {
+				"DEPEND" : "virtual/os-headers sys-devel/gcc sys-devel/binutils",
+				"RDEPEND": "",
+			},
+			"virtual/os-headers-0" : {
+				"RDEPEND" : "sys-kernel/linux-headers",
+			},
+			"sys-kernel/linux-headers-2.6.38": {
+				"DEPEND" : "app-arch/xz-utils",
+				"RDEPEND": "",
+			},
+			"sys-kernel/linux-headers-2.6.39": {
+				"DEPEND" : "app-arch/xz-utils",
+				"RDEPEND": "",
+			},
+			"app-arch/xz-utils-5.0.1" : {},
+			"app-arch/xz-utils-5.0.2" : {},
+			"dev-util/pkgconfig-0.25-r2" : {},
+			"kde-base/kdelibs-3.5.7" : {
+				"PDEPEND" : "kde-misc/kdnssd-avahi",
+			},
+			"kde-misc/kdnssd-avahi-0.1.2" : {
+				"DEPEND"  : "kde-base/kdelibs app-arch/xz-utils dev-util/pkgconfig",
+				"RDEPEND" : "kde-base/kdelibs",
+			},
+			"kde-base/kdnssd-3.5.7" : {
+				"DEPEND"  : "kde-base/kdelibs",
+				"RDEPEND" : "kde-base/kdelibs",
+			},
+			"kde-base/libkdegames-3.5.7" : {
+				"DEPEND"  : "kde-base/kdelibs",
+				"RDEPEND" : "kde-base/kdelibs",
+			},
+			"kde-base/kmines-3.5.7" : {
+				"DEPEND"  : "kde-base/libkdegames",
+				"RDEPEND" : "kde-base/libkdegames",
+			},
+			"media-video/libav-0.7_pre20110327" : {
+				"EAPI" : "2",
+				"IUSE" : "X +encode",
+				"RDEPEND" : "!media-video/ffmpeg",
+			},
+			"media-video/ffmpeg-0.7_rc1" : {
+				"EAPI" : "2",
+				"IUSE" : "X +encode",
+			},
+			"virtual/ffmpeg-0.6.90" : {
+				"EAPI" : "2",
+				"IUSE" : "X +encode",
+				"RDEPEND" : "|| ( >=media-video/ffmpeg-0.6.90_rc0-r2[X=,encode=] >=media-video/libav-0.6.90_rc[X=,encode=] )",
+			},
+		}
+
+		installed = {
+			"app-misc/circ-buildtime-a-0": {},
+			"app-misc/circ-satisfied-a-0": {
+				"RDEPEND": "app-misc/circ-satisfied-b",
+			},
+			"app-misc/circ-satisfied-b-0": {
+				"RDEPEND": "app-misc/circ-satisfied-c",
+			},
+			"app-misc/circ-satisfied-c-0": {
+				"DEPEND": "app-misc/circ-satisfied-a",
+				"RDEPEND": "app-misc/circ-satisfied-a",
+			},
+			"app-misc/installed-blocker-a-1" : {
+				"EAPI"   : "2",
+				"DEPEND" : "!app-misc/blocker-buildtime-a",
+				"RDEPEND" : "!app-misc/blocker-runtime-a !app-misc/blocker-runtime-b !!app-misc/blocker-runtime-hard-a",
+			},
+			"app-misc/installed-old-version-blocks-a-1" : {
+				"RDEPEND" : "!app-misc/blocker-update-order-a",
+			},
+			"app-misc/installed-old-version-blocks-hard-a-1" : {
+				"EAPI"    : "2",
+				"RDEPEND" : "!!app-misc/blocker-update-order-hard-a",
+			},
+			"app-misc/installed-old-version-blocks-hard-unsolvable-a-1" : {
+				"EAPI"    : "2",
+				"RDEPEND" : "!!app-misc/blocker-update-order-hard-unsolvable-a",
+			},
+			"sys-apps/portage-2.1.9.42" : {
+				"DEPEND"  : "dev-lang/python",
+				"RDEPEND" : "dev-lang/python",
+			},
+			"dev-lang/python-3.1" : {},
+			"virtual/libc-0" : {
+				"RDEPEND" : "sys-libs/glibc",
+			},
+			"sys-devel/binutils-2.18" : {},
+			"sys-libs/glibc-2.11" : {
+				"DEPEND" : "virtual/os-headers sys-devel/gcc sys-devel/binutils",
+				"RDEPEND": "",
+			},
+			"virtual/os-headers-0" : {
+				"RDEPEND" : "sys-kernel/linux-headers",
+			},
+			"sys-kernel/linux-headers-2.6.38": {
+				"DEPEND" : "app-arch/xz-utils",
+				"RDEPEND": "",
+			},
+			"app-arch/xz-utils-5.0.1" : {},
+			"media-video/ffmpeg-0.7_rc1" : {
+				"EAPI" : "2",
+				"IUSE" : "X +encode",
+				"USE" : "encode",
+			},
+			"virtual/ffmpeg-0.6.90" : {
+				"EAPI" : "2",
+				"IUSE" : "X +encode",
+				"USE" : "encode",
+				"RDEPEND" : "|| ( >=media-video/ffmpeg-0.6.90_rc0-r2[X=,encode=] >=media-video/libav-0.6.90_rc[X=,encode=] )",
+			},
+		}
+
+		test_cases = (
+			ResolverPlaygroundTestCase(
+				["app-misc/some-app-a"],
+				success = True,
+				ambiguous_merge_order = True,
+				mergelist = [("app-misc/circ-runtime-a-1", "app-misc/circ-runtime-b-1", "app-misc/circ-runtime-c-1"), "app-misc/some-app-a-1"]),
+			ResolverPlaygroundTestCase(
+				["app-misc/some-app-a"],
+				success = True,
+				ambiguous_merge_order = True,
+				mergelist = [("app-misc/circ-runtime-c-1", "app-misc/circ-runtime-b-1", "app-misc/circ-runtime-a-1"), "app-misc/some-app-a-1"]),
+			# Test unsolvable circular dep that is RDEPEND in one
+			# direction and DEPEND in the other.
+			ResolverPlaygroundTestCase(
+				["app-misc/circ-buildtime-unsolvable-a"],
+				success = False,
+				circular_dependency_solutions = {}),
+			# Test optimal merge order for a circular dep that is
+			# RDEPEND in one direction and DEPEND in the other.
+			# This requires an installed instance of the DEPEND
+			# package in order to be solvable.
+			ResolverPlaygroundTestCase(
+				["app-misc/some-app-c", "app-misc/circ-buildtime-a"],
+				success = True,
+				ambiguous_merge_order = True,
+				mergelist = [("app-misc/circ-buildtime-b-1", "app-misc/circ-buildtime-c-1"), "app-misc/circ-buildtime-a-1", "app-misc/some-app-c-1"]),
+			# Test optimal merge order for a circular dep that is
+			# RDEPEND in one direction and PDEPEND in the other.
+			ResolverPlaygroundTestCase(
+				["app-misc/some-app-b"],
+				success = True,
+				ambiguous_merge_order = True,
+				mergelist = ["app-misc/circ-post-runtime-a-1", ("app-misc/circ-post-runtime-b-1", "app-misc/circ-post-runtime-c-1"), "app-misc/some-app-b-1"]),
+			# Test optimal merge order for a circular dep that is
+			# RDEPEND in one direction and DEPEND in the other,
+			# with all dependencies initially satisfied. Optimally,
+			# the DEPEND/buildtime dep should be updated before the
+			# package that depends on it, even though it's feasible
+			# to update it later since it is already satisfied.
+			ResolverPlaygroundTestCase(
+				["app-misc/circ-satisfied-a", "app-misc/circ-satisfied-b", "app-misc/circ-satisfied-c"],
+				success = True,
+				all_permutations = True,
+				ambiguous_merge_order = True,
+				merge_order_assertions = (("app-misc/circ-satisfied-a-1", "app-misc/circ-satisfied-c-1"),),
+				mergelist = [("app-misc/circ-satisfied-a-1", "app-misc/circ-satisfied-b-1", "app-misc/circ-satisfied-c-1")]),
+			# In the case of multiple runtime cycles, where some cycles
+			# may depend on smaller independent cycles, it's optimal
+			# to merge smaller independent cycles before other cycles
+			# that depend on them.
+			ResolverPlaygroundTestCase(
+				["app-misc/circ-smallest-a", "app-misc/circ-smallest-c", "app-misc/circ-smallest-f"],
+				success = True,
+				ambiguous_merge_order = True,
+				all_permutations = True,
+				mergelist = [('app-misc/circ-smallest-a-1', 'app-misc/circ-smallest-b-1'),
+				('app-misc/circ-smallest-c-1', 'app-misc/circ-smallest-d-1', 'app-misc/circ-smallest-e-1'),
+				('app-misc/circ-smallest-f-1', 'app-misc/circ-smallest-g-1')]),
+			# installed package has buildtime-only blocker
+			# that should be ignored
+			ResolverPlaygroundTestCase(
+				["app-misc/blocker-buildtime-a"],
+				success = True,
+				mergelist = ["app-misc/blocker-buildtime-a-1"]),
+			# We're installing a package that an old version of
+			# an installed package blocks. However, an update is
+			# available to the old package. The old package should
+			# be updated first, in order to solve the blocker without
+			# any need for blocking packages to temporarily overlap.
+			ResolverPlaygroundTestCase(
+				["app-misc/blocker-update-order-a", "app-misc/installed-old-version-blocks-a"],
+				success = True,
+				all_permutations = True,
+				mergelist = ["app-misc/installed-old-version-blocks-a-2", "app-misc/blocker-update-order-a-1"]),
+			# This is the same as above but with a hard blocker. The hard
+			# blocker is solved automatically since the update makes it
+			# irrelevant.
+			ResolverPlaygroundTestCase(
+				["app-misc/blocker-update-order-hard-a", "app-misc/installed-old-version-blocks-hard-a"],
+				success = True,
+				all_permutations = True,
+				mergelist = ["app-misc/installed-old-version-blocks-hard-a-2", "app-misc/blocker-update-order-hard-a-1"]),
+			# This is similar to the above case except that it's unsolvable
+			# due to merge order, unless bug 250286 is implemented so that
+			# the installed blocker will be unmerged before installation
+			# of the package it blocks (rather than after like a soft blocker
+			# would be handled). The "unmerge before" behavior requested
+			# in bug 250286 must be optional since essential programs or
+			# libraries may be temporarily unavailable during a
+			# non-overlapping update like this.
+			ResolverPlaygroundTestCase(
+				["app-misc/blocker-update-order-hard-unsolvable-a", "app-misc/installed-old-version-blocks-hard-unsolvable-a"],
+				success = False,
+				all_permutations = True,
+				ambiguous_merge_order = True,
+				merge_order_assertions = (('app-misc/blocker-update-order-hard-unsolvable-a-1', 'app-misc/installed-old-version-blocks-hard-unsolvable-a-2'),),
+				mergelist = [('app-misc/blocker-update-order-hard-unsolvable-a-1', 'app-misc/installed-old-version-blocks-hard-unsolvable-a-2', '!!app-misc/blocker-update-order-hard-unsolvable-a')]),
+			# The installed package has runtime blockers that
+			# should cause it to be uninstalled. The uninstall
+			# task is executed only after blocking packages have
+			# been merged.
+			# TODO: distinguish between install/uninstall tasks in mergelist
+			ResolverPlaygroundTestCase(
+				["app-misc/blocker-runtime-a", "app-misc/blocker-runtime-b"],
+				success = True,
+				all_permutations = True,
+				ambiguous_merge_order = True,
+				mergelist = [("app-misc/blocker-runtime-a-1", "app-misc/blocker-runtime-b-1"), "app-misc/installed-blocker-a-1", ("!app-misc/blocker-runtime-a", "!app-misc/blocker-runtime-b")]),
+			# We have a soft buildtime blocker against an installed
+			# package that should cause it to be uninstalled. Note that with
+			# soft blockers, the blocking packages are allowed to temporarily
+			# overlap. This allows any essential programs/libraries provided
+			# by both packages to be available at all times.
+			# TODO: distinguish between install/uninstall tasks in mergelist
+			ResolverPlaygroundTestCase(
+				["app-misc/blocker-buildtime-unbuilt-a"],
+				success = True,
+				mergelist = ["app-misc/blocker-buildtime-unbuilt-a-1", "app-misc/installed-blocker-a-1", "!app-misc/installed-blocker-a"]),
+			# We have a hard buildtime blocker against an installed
+			# package that will not resolve automatically (unless
+			# the option requested in bug 250286 is implemented).
+			ResolverPlaygroundTestCase(
+				["app-misc/blocker-buildtime-unbuilt-hard-a"],
+				success = False,
+				mergelist = ['app-misc/blocker-buildtime-unbuilt-hard-a-1', '!!app-misc/installed-blocker-a']),
+			# An installed package has a hard runtime blocker that
+			# will not resolve automatically (unless the option
+			# requested in bug 250286 is implemented).
+			ResolverPlaygroundTestCase(
+				["app-misc/blocker-runtime-hard-a"],
+				success = False,
+				mergelist = ['app-misc/blocker-runtime-hard-a-1', '!!app-misc/blocker-runtime-hard-a']),
+			# Test swapping of providers for a new-style virtual package,
+			# which relies on delayed evaluation of disjunctive (virtual
+			# and ||) deps as required to solve bug #264434. Note that
+			# this behavior is not supported for old-style PROVIDE virtuals,
+			# as reported in bug #339164.
+			ResolverPlaygroundTestCase(
+				["media-video/libav"],
+				success=True,
+				mergelist = ['media-video/libav-0.7_pre20110327', 'media-video/ffmpeg-0.7_rc1', '!media-video/ffmpeg']),
+			# Test that PORTAGE_PACKAGE_ATOM is merged asap. Optimally,
+			# satisfied deps are always merged after the asap nodes that
+			# depend on them.
+			ResolverPlaygroundTestCase(
+				["dev-lang/python", portage.const.PORTAGE_PACKAGE_ATOM],
+				success = True,
+				all_permutations = True,
+				mergelist = ['app-admin/eselect-python-20100321', 'sys-apps/portage-2.1.9.49', 'dev-lang/python-3.2']),
+			# Test that OS_HEADERS_PACKAGE_ATOM and LIBC_PACKAGE_ATOM
+			# are merged asap, in order to account for implicit
+			# dependencies. See bug #303567. Optimally, satisfied deps
+			# are always merged after the asap nodes that depend on them.
+			ResolverPlaygroundTestCase(
+				["app-arch/xz-utils", "sys-kernel/linux-headers", "sys-devel/binutils", "sys-libs/glibc"],
+				options = {"--complete-graph" : True},
+				success = True,
+				all_permutations = True,
+				ambiguous_merge_order = True,
+				mergelist = ['sys-kernel/linux-headers-2.6.39', 'sys-devel/gcc-4.5.2', 'sys-libs/glibc-2.13', ('app-arch/xz-utils-5.0.2', 'sys-devel/binutils-2.20.1')]),
+			# Test asap install of PDEPEND for bug #180045.
+			ResolverPlaygroundTestCase(
+				["kde-base/kmines", "kde-base/kdnssd", "kde-base/kdelibs", "app-arch/xz-utils"],
+				success = True,
+				all_permutations = True,
+				ambiguous_merge_order = True,
+				merge_order_assertions = (
+					('dev-util/pkgconfig-0.25-r2', 'kde-misc/kdnssd-avahi-0.1.2'),
+					('kde-misc/kdnssd-avahi-0.1.2', 'kde-base/libkdegames-3.5.7'),
+					('kde-misc/kdnssd-avahi-0.1.2', 'kde-base/kdnssd-3.5.7'),
+					('kde-base/libkdegames-3.5.7', 'kde-base/kmines-3.5.7'),
+				),
+				mergelist = [('kde-base/kdelibs-3.5.7', 'dev-util/pkgconfig-0.25-r2', 'kde-misc/kdnssd-avahi-0.1.2', 'app-arch/xz-utils-5.0.2', 'kde-base/libkdegames-3.5.7', 'kde-base/kdnssd-3.5.7', 'kde-base/kmines-3.5.7')]),
+		)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, installed=installed)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_missing_iuse_and_evaluated_atoms.py b/portage_with_autodep/pym/portage/tests/resolver/test_missing_iuse_and_evaluated_atoms.py
new file mode 100644
index 0000000..a860e7b
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_missing_iuse_and_evaluated_atoms.py
@@ -0,0 +1,31 @@
+# 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 MissingIUSEandEvaluatedAtomsTestCase(TestCase):
+
+	def testMissingIUSEandEvaluatedAtoms(self):
+		ebuilds = {
+			"dev-libs/A-1": { "DEPEND": "dev-libs/B[foo?]", "IUSE": "foo bar", "EAPI": 2 }, 
+			"dev-libs/A-2": { "DEPEND": "dev-libs/B[foo?,bar]", "IUSE": "foo bar", "EAPI": 2 }, 
+			"dev-libs/B-1": { "IUSE": "bar" }, 
+			}
+
+		test_cases = (
+			ResolverPlaygroundTestCase(
+				["=dev-libs/A-1"],
+				success = False),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/A-2"],
+				success = False),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, debug=False)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_multirepo.py b/portage_with_autodep/pym/portage/tests/resolver/test_multirepo.py
new file mode 100644
index 0000000..34c6d45
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_multirepo.py
@@ -0,0 +1,318 @@
+# Copyright 2010-2011 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": { },
+
+			#Packages 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" },
+
+			"dev-libs/G-1::repo1": { "EAPI" : "4", "IUSE":"+x +y", "REQUIRED_USE" : "" },
+			"dev-libs/G-1::repo2": { "EAPI" : "4", "IUSE":"+x +y", "REQUIRED_USE" : "^^ ( x y )" },
+
+			"dev-libs/H-1": {	"KEYWORDS": "x86", "EAPI" : "3",
+								"RDEPEND" : "|| ( dev-libs/I:2 dev-libs/I:1 )" },
+
+			"dev-libs/I-1::repo2": { "SLOT" : "1"},
+			"dev-libs/I-2::repo2": { "SLOT" : "2"},
+			}
+
+		installed = {
+			"dev-libs/H-1": { "RDEPEND" : "|| ( dev-libs/I:2 dev-libs/I:1 )"},
+			"dev-libs/I-2::repo1": {"SLOT" : "2"},
+			}
+
+		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"]),
+
+			#Packages 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 2 must be used
+			ResolverPlaygroundTestCase(
+				["dev-libs/D"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/D-1::repo2"]),
+
+			#Atoms with slots
+			ResolverPlaygroundTestCase(
+				["dev-libs/E"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/E-1::repo2"]),
+			ResolverPlaygroundTestCase(
+				["dev-libs/E:1::repo2"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/E-1::repo2"]),
+			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::repo2"]),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/F-1:1"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/F-1::repo2"]),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/F-1:1::repo1"],
+				success = True,
+				check_repo_names = True,
+				mergelist = ["dev-libs/F-1::repo1"]),
+
+			# Dependency on installed dev-libs/C-2 ebuild for which ebuild is
+			# not available from the same repo should not unnecessarily
+			# reinstall the same version from a different repo.
+			ResolverPlaygroundTestCase(
+				["dev-libs/H"],
+				options = {"--update": True, "--deep": True},
+				success = True,
+				mergelist = []),
+
+			# Check interaction between repo priority and unsatisfied
+			# REQUIRED_USE, for bug #350254.
+			ResolverPlaygroundTestCase(
+				["=dev-libs/G-1"],
+				check_repo_names = True,
+				success = False),
+
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds,
+			installed=installed, 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": { },
+			"dev-libs/H-1": { },
+			"dev-libs/H-1::repo1": { },
+			"dev-libs/I-1::repo2": { "SLOT" : "1"},
+			"dev-libs/I-2::repo2": { "SLOT" : "2"},
+			"dev-libs/J-1": {	"KEYWORDS": "x86", "EAPI" : "3",
+								"RDEPEND" : "|| ( dev-libs/I:2 dev-libs/I:1 )" },
+
+			#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": { },
+
+			#package.mask with wildcards
+			"dev-libs/Z-1::repo3": { },
+			}
+
+		installed = {
+			"dev-libs/J-1": { "RDEPEND" : "|| ( dev-libs/I:2 dev-libs/I:1 )"},
+			"dev-libs/I-2::repo1": {"SLOT" : "2"},
+			}
+
+		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",
+					"dev-libs/H",
+					"dev-libs/I::repo1",
+					#needed for package.unmask test
+					"dev-libs/G",
+					#wildcard test
+					"*/*::repo3",
+				),
+			"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"],
+				options = { "--autounmask": 'n' },
+				success = False,
+				check_repo_names = True),
+
+			#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"]),
+
+			# Dependency on installed dev-libs/C-2 ebuild for which ebuild is
+			# masked from the same repo should not unnecessarily pull
+			# in a different slot. It should just pull in the same slot from
+			# a different repo (bug #351828).
+			ResolverPlaygroundTestCase(
+				["dev-libs/J"],
+				options = {"--update": True, "--deep": True},
+				success = True,
+				mergelist = ["dev-libs/I-2"]),
+
+			#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"]),
+			ResolverPlaygroundTestCase(
+				["dev-libs/H"],
+				options = { "--autounmask": 'n' },
+				success = False),
+
+			#package.mask with wildcards
+			ResolverPlaygroundTestCase(
+				["dev-libs/Z"],
+				options = { "--autounmask": 'n' },
+				success = False),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds,
+			installed=installed, 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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_multislot.py b/portage_with_autodep/pym/portage/tests/resolver/test_multislot.py
new file mode 100644
index 0000000..8615419
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_multislot.py
@@ -0,0 +1,40 @@
+# 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 MultSlotTestCase(TestCase):
+
+	def testMultiSlotSelective(self):
+		"""
+		Test that a package isn't reinstalled due to SLOT dependency
+		interaction with USE=multislot (bug #220341).
+		"""
+
+		ebuilds = {
+			"sys-devel/gcc-4.4.4": { "SLOT": "4.4" },
+			}
+
+		installed = {
+			"sys-devel/gcc-4.4.4": { "SLOT": "i686-pc-linux-gnu-4.4.4" },
+			}
+
+		options = {'--update' : True, '--deep' : True, '--selective' : True}
+
+		test_cases = (
+				ResolverPlaygroundTestCase(
+					["sys-devel/gcc:4.4"],
+					options = options,
+					mergelist = [],
+					success = True),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, installed=installed)
+
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_old_dep_chain_display.py b/portage_with_autodep/pym/portage/tests/resolver/test_old_dep_chain_display.py
new file mode 100644
index 0000000..8aedf59
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_old_dep_chain_display.py
@@ -0,0 +1,35 @@
+# Copyright 2010-2011 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 OldDepChainDisplayTestCase(TestCase):
+
+	def testOldDepChainDisplay(self):
+		ebuilds = {
+			"dev-libs/A-1": { "DEPEND": "foo? ( dev-libs/B[-bar] )", "IUSE": "+foo", "EAPI": "2" }, 
+			"dev-libs/A-2": { "DEPEND": "foo? ( dev-libs/C )", "IUSE": "+foo", "EAPI": "1" }, 
+			"dev-libs/B-1": { "IUSE": "bar", "DEPEND": "!bar? ( dev-libs/D[-baz] )", "EAPI": "2" },
+			"dev-libs/C-1": { "KEYWORDS": "~x86" },
+			"dev-libs/D-1": { "IUSE": "+baz", "EAPI": "1" },
+			}
+
+		test_cases = (
+			ResolverPlaygroundTestCase(
+				["=dev-libs/A-1"],
+				options = { "--autounmask": 'n' },
+				success = False),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/A-2"],
+				options = { "--autounmask": 'n' },
+				success = False),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_output.py b/portage_with_autodep/pym/portage/tests/resolver/test_output.py
new file mode 100644
index 0000000..34efe9c
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_output.py
@@ -0,0 +1,88 @@
+# 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 MergelistOutputTestCase(TestCase):
+
+	def testMergelistOutput(self):
+		"""
+		This test doesn't check if the output is correct, but makes sure
+		that we don't backtrace somewhere in the output code.
+		"""
+		ebuilds = {
+			"dev-libs/A-1": { "DEPEND": "dev-libs/B dev-libs/C", "IUSE": "+foo", "EAPI": 1 },
+			"dev-libs/B-1": { "DEPEND": "dev-libs/D", "IUSE": "foo +bar", "EAPI": 1 },
+			"dev-libs/C-1": { "DEPEND": "dev-libs/E", "IUSE": "foo bar" },
+			"dev-libs/D-1": { "IUSE": "" },
+			"dev-libs/E-1": {},
+
+			#reinstall for flags
+			"dev-libs/Z-1": { "IUSE": "+foo", "EAPI": 1 },
+			"dev-libs/Y-1": { "IUSE": "foo", "EAPI": 1 },
+			"dev-libs/X-1": {},
+			"dev-libs/W-1": { "IUSE": "+foo", "EAPI": 1 },
+			}
+
+		installed = {
+			"dev-libs/Z-1": { "USE": "", "IUSE": "foo" },
+			"dev-libs/Y-1": { "USE": "foo", "IUSE": "+foo", "EAPI": 1 },
+			"dev-libs/X-1": { "USE": "foo", "IUSE": "+foo", "EAPI": 1 },
+			"dev-libs/W-1": { },
+		}
+
+		option_cobos = (
+			(),
+			("verbose",),
+			("tree",),
+			("tree", "unordered-display",),
+			("verbose",),
+			("verbose", "tree",),
+			("verbose", "tree", "unordered-display",),
+		)
+
+		test_cases = []
+		for options in option_cobos:
+			testcase_opts = {}
+			for opt in options:
+				testcase_opts["--" + opt] = True
+
+			test_cases.append(ResolverPlaygroundTestCase(
+				["dev-libs/A"],
+				options = testcase_opts,
+				success = True,
+				ignore_mergelist_order=True,
+				mergelist = ["dev-libs/D-1", "dev-libs/E-1", "dev-libs/C-1", "dev-libs/B-1", "dev-libs/A-1"]))
+
+			test_cases.append(ResolverPlaygroundTestCase(
+				["dev-libs/Z"],
+				options = testcase_opts,
+				success = True,
+				mergelist = ["dev-libs/Z-1"]))
+
+			test_cases.append(ResolverPlaygroundTestCase(
+				["dev-libs/Y"],
+				options = testcase_opts,
+				success = True,
+				mergelist = ["dev-libs/Y-1"]))
+
+			test_cases.append(ResolverPlaygroundTestCase(
+				["dev-libs/X"],
+				options = testcase_opts,
+				success = True,
+				mergelist = ["dev-libs/X-1"]))
+
+			test_cases.append(ResolverPlaygroundTestCase(
+				["dev-libs/W"],
+				options = testcase_opts,
+				success = True,
+				mergelist = ["dev-libs/W-1"]))
+
+		playground = ResolverPlayground(ebuilds=ebuilds, installed=installed)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_rebuild.py b/portage_with_autodep/pym/portage/tests/resolver/test_rebuild.py
new file mode 100644
index 0000000..b9c4d6d
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_rebuild.py
@@ -0,0 +1,138 @@
+# Copyright 2011 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 RebuildTestCase(TestCase):
+
+	def testRebuild(self):
+		"""
+		Rebuild packages when dependencies that are used at both build-time and
+		run-time are upgraded.
+		"""
+
+		ebuilds = {
+			"sys-libs/x-1": { },
+			"sys-libs/x-1-r1": { },
+			"sys-libs/x-2": { },
+			"sys-apps/a-1": { "DEPEND"  : "sys-libs/x", "RDEPEND" : "sys-libs/x"},
+			"sys-apps/a-2": { "DEPEND"  : "sys-libs/x", "RDEPEND" : "sys-libs/x"},
+			"sys-apps/b-1": { "DEPEND"  : "sys-libs/x", "RDEPEND" : "sys-libs/x"},
+			"sys-apps/b-2": { "DEPEND"  : "sys-libs/x", "RDEPEND" : "sys-libs/x"},
+			"sys-apps/c-1": { "DEPEND"  : "sys-libs/x", "RDEPEND" : ""},
+			"sys-apps/c-2": { "DEPEND"  : "sys-libs/x", "RDEPEND" : ""},
+			"sys-apps/d-1": { "RDEPEND" : "sys-libs/x"},
+			"sys-apps/d-2": { "RDEPEND" : "sys-libs/x"},
+			"sys-apps/e-2": { "DEPEND"  : "sys-libs/x", "RDEPEND" : "sys-libs/x"},
+			"sys-apps/f-2": { "DEPEND"  : "sys-apps/a", "RDEPEND" : "sys-apps/a"},
+			"sys-apps/g-2": { "DEPEND"  : "sys-apps/b sys-libs/x",
+				"RDEPEND" : "sys-apps/b"},
+			}
+
+		installed = {
+			"sys-libs/x-1": { },
+			"sys-apps/a-1": { "DEPEND"  : "sys-libs/x", "RDEPEND" : "sys-libs/x"},
+			"sys-apps/b-1": { "DEPEND"  : "sys-libs/x", "RDEPEND" : "sys-libs/x"},
+			"sys-apps/c-1": { "DEPEND"  : "sys-libs/x", "RDEPEND" : ""},
+			"sys-apps/d-1": { "RDEPEND" : "sys-libs/x"},
+			"sys-apps/e-1": { "DEPEND"  : "sys-libs/x", "RDEPEND" : "sys-libs/x"},
+			"sys-apps/f-1": { "DEPEND"  : "sys-apps/a", "RDEPEND" : "sys-apps/a"},
+			"sys-apps/g-1": { "DEPEND"  : "sys-apps/b sys-libs/x",
+				"RDEPEND" : "sys-apps/b"},
+			}
+
+		world = ["sys-apps/a", "sys-apps/b", "sys-apps/c", "sys-apps/d",
+			"sys-apps/e", "sys-apps/f", "sys-apps/g"]
+
+		test_cases = (
+				ResolverPlaygroundTestCase(
+					["sys-libs/x"],
+					options = {"--rebuild-if-unbuilt" : True,
+						"--rebuild-exclude" : ["sys-apps/b"]},
+					mergelist = ['sys-libs/x-2', 'sys-apps/a-2', 'sys-apps/e-2'],
+					ignore_mergelist_order = True,
+					success = True),
+
+				ResolverPlaygroundTestCase(
+					["sys-libs/x"],
+					options = {"--rebuild-if-unbuilt" : True},
+					mergelist = ['sys-libs/x-2', 'sys-apps/a-2', 'sys-apps/b-2',
+						'sys-apps/e-2', 'sys-apps/g-2'],
+					ignore_mergelist_order = True,
+					success = True),
+
+				ResolverPlaygroundTestCase(
+					["sys-libs/x"],
+					options = {"--rebuild-if-unbuilt" : True,
+						"--rebuild-ignore" : ["sys-libs/x"]},
+					mergelist = ['sys-libs/x-2'],
+					ignore_mergelist_order = True,
+					success = True),
+
+				ResolverPlaygroundTestCase(
+					["sys-libs/x"],
+					options = {"--rebuild-if-unbuilt" : True,
+						"--rebuild-ignore" : ["sys-apps/b"]},
+					mergelist = ['sys-libs/x-2', 'sys-apps/a-2', 'sys-apps/b-2',
+						'sys-apps/e-2'],
+					ignore_mergelist_order = True,
+					success = True),
+
+				ResolverPlaygroundTestCase(
+					["=sys-libs/x-1-r1"],
+					options = {"--rebuild-if-unbuilt" : True},
+					mergelist = ['sys-libs/x-1-r1', 'sys-apps/a-2',
+						'sys-apps/b-2', 'sys-apps/e-2', 'sys-apps/g-2'],
+					ignore_mergelist_order = True,
+					success = True),
+
+				ResolverPlaygroundTestCase(
+					["=sys-libs/x-1-r1"],
+					options = {"--rebuild-if-new-rev" : True},
+					mergelist = ['sys-libs/x-1-r1', 'sys-apps/a-2',
+						'sys-apps/b-2', 'sys-apps/e-2', 'sys-apps/g-2'],
+					ignore_mergelist_order = True,
+					success = True),
+
+				ResolverPlaygroundTestCase(
+					["=sys-libs/x-1-r1"],
+					options = {"--rebuild-if-new-ver" : True},
+					mergelist = ['sys-libs/x-1-r1'],
+					ignore_mergelist_order = True,
+					success = True),
+
+				ResolverPlaygroundTestCase(
+					["sys-libs/x"],
+					options = {"--rebuild-if-new-ver" : True},
+					mergelist = ['sys-libs/x-2', 'sys-apps/a-2',
+						'sys-apps/b-2', 'sys-apps/e-2', 'sys-apps/g-2'],
+					ignore_mergelist_order = True,
+					success = True),
+
+				ResolverPlaygroundTestCase(
+					["=sys-libs/x-1"],
+					options = {"--rebuild-if-new-rev" : True},
+					mergelist = ['sys-libs/x-1'],
+					ignore_mergelist_order = True,
+					success = True),
+
+				ResolverPlaygroundTestCase(
+					["=sys-libs/x-1"],
+					options = {"--rebuild-if-unbuilt" : True},
+					mergelist = ['sys-libs/x-1', 'sys-apps/a-2',
+						'sys-apps/b-2', 'sys-apps/e-2', 'sys-apps/g-2'],
+					ignore_mergelist_order = True,
+					success = True),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds,
+			installed=installed, world=world)
+
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_required_use.py b/portage_with_autodep/pym/portage/tests/resolver/test_required_use.py
new file mode 100644
index 0000000..c8810fa
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_required_use.py
@@ -0,0 +1,114 @@
+# Copyright 2010-2011 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 RequiredUSETestCase(TestCase):
+
+	def testRequiredUSE(self):
+		"""
+		Only simple REQUIRED_USE values here. The parser is tested under in dep/testCheckRequiredUse
+		"""
+
+		ebuilds = {
+			"dev-libs/A-1" : {"EAPI": "4", "IUSE": "foo bar",   "REQUIRED_USE": "|| ( foo bar )"},
+			"dev-libs/A-2" : {"EAPI": "4", "IUSE": "foo +bar",  "REQUIRED_USE": "|| ( foo bar )"},
+			"dev-libs/A-3" : {"EAPI": "4", "IUSE": "+foo bar",  "REQUIRED_USE": "|| ( foo bar )"},
+			"dev-libs/A-4" : {"EAPI": "4", "IUSE": "+foo +bar", "REQUIRED_USE": "|| ( foo bar )"},
+			"dev-libs/A-5" : {"EAPI": "4", "IUSE": "+foo +bar", "REQUIRED_USE": "|| ( )"},
+
+			"dev-libs/B-1" : {"EAPI": "4", "IUSE": "foo bar",   "REQUIRED_USE": "^^ ( foo bar )"},
+			"dev-libs/B-2" : {"EAPI": "4", "IUSE": "foo +bar",  "REQUIRED_USE": "^^ ( foo bar )"},
+			"dev-libs/B-3" : {"EAPI": "4", "IUSE": "+foo bar",  "REQUIRED_USE": "^^ ( foo bar )"},
+			"dev-libs/B-4" : {"EAPI": "4", "IUSE": "+foo +bar", "REQUIRED_USE": "^^ ( foo bar )"},
+			"dev-libs/B-5" : {"EAPI": "4", "IUSE": "+foo +bar", "REQUIRED_USE": "^^ ( )"},
+
+			"dev-libs/C-1" : {"EAPI": "4", "IUSE": "+foo bar",  "REQUIRED_USE": "foo? ( !bar )"},
+			"dev-libs/C-2" : {"EAPI": "4", "IUSE": "+foo +bar", "REQUIRED_USE": "foo? ( !bar )"},
+			"dev-libs/C-3" : {"EAPI": "4", "IUSE": "+foo +bar", "REQUIRED_USE": "foo? ( bar )"},
+			"dev-libs/C-4" : {"EAPI": "4", "IUSE": "+foo bar",  "REQUIRED_USE": "foo? ( bar )"},
+			"dev-libs/C-5" : {"EAPI": "4", "IUSE": "foo bar",   "REQUIRED_USE": "foo? ( bar )"},
+			"dev-libs/C-6" : {"EAPI": "4", "IUSE": "foo +bar",  "REQUIRED_USE": "foo? ( bar )"},
+			"dev-libs/C-7" : {"EAPI": "4", "IUSE": "foo +bar",  "REQUIRED_USE": "!foo? ( bar )"},
+			"dev-libs/C-8" : {"EAPI": "4", "IUSE": "+foo +bar", "REQUIRED_USE": "!foo? ( bar )"},
+			"dev-libs/C-9" : {"EAPI": "4", "IUSE": "+foo bar",  "REQUIRED_USE": "!foo? ( bar )"},
+			"dev-libs/C-10": {"EAPI": "4", "IUSE": "foo bar",   "REQUIRED_USE": "!foo? ( bar )"},
+			"dev-libs/C-11": {"EAPI": "4", "IUSE": "foo bar",   "REQUIRED_USE": "!foo? ( !bar )"},
+			"dev-libs/C-12": {"EAPI": "4", "IUSE": "foo +bar",  "REQUIRED_USE": "!foo? ( !bar )"},
+			"dev-libs/C-13": {"EAPI": "4", "IUSE": "+foo +bar", "REQUIRED_USE": "!foo? ( !bar )"},
+			"dev-libs/C-14": {"EAPI": "4", "IUSE": "+foo bar",  "REQUIRED_USE": "!foo? ( !bar )"},
+
+			"dev-libs/D-1" : {"EAPI": "4", "IUSE": "+w +x +y z",    "REQUIRED_USE": "w? ( x || ( y z ) )"},
+			"dev-libs/D-2" : {"EAPI": "4", "IUSE": "+w +x +y +z",   "REQUIRED_USE": "w? ( x || ( y z ) )"},
+			"dev-libs/D-3" : {"EAPI": "4", "IUSE": "+w +x y z",     "REQUIRED_USE": "w? ( x || ( y z ) )"},
+			"dev-libs/D-4" : {"EAPI": "4", "IUSE": "+w x +y +z",    "REQUIRED_USE": "w? ( x || ( y z ) )"},
+			"dev-libs/D-5" : {"EAPI": "4", "IUSE": "w x y z",       "REQUIRED_USE": "w? ( x || ( y z ) )"},
+			}
+
+		test_cases = (
+			ResolverPlaygroundTestCase(["=dev-libs/A-1"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/A-2"], success = True, mergelist=["dev-libs/A-2"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-3"], success = True, mergelist=["dev-libs/A-3"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-4"], success = True, mergelist=["dev-libs/A-4"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-5"], success = True, mergelist=["dev-libs/A-5"]),
+
+			ResolverPlaygroundTestCase(["=dev-libs/B-1"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/B-2"], success = True, mergelist=["dev-libs/B-2"]),
+			ResolverPlaygroundTestCase(["=dev-libs/B-3"], success = True, mergelist=["dev-libs/B-3"]),
+			ResolverPlaygroundTestCase(["=dev-libs/B-4"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/B-5"], success = True, mergelist=["dev-libs/B-5"]),
+
+			ResolverPlaygroundTestCase(["=dev-libs/C-1"],  success = True, mergelist=["dev-libs/C-1"]),
+			ResolverPlaygroundTestCase(["=dev-libs/C-2"],  success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/C-3"],  success = True, mergelist=["dev-libs/C-3"]),
+			ResolverPlaygroundTestCase(["=dev-libs/C-4"],  success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/C-5"],  success = True, mergelist=["dev-libs/C-5"]),
+			ResolverPlaygroundTestCase(["=dev-libs/C-6"],  success = True, mergelist=["dev-libs/C-6"]),
+			ResolverPlaygroundTestCase(["=dev-libs/C-7"],  success = True, mergelist=["dev-libs/C-7"]),
+			ResolverPlaygroundTestCase(["=dev-libs/C-8"],  success = True, mergelist=["dev-libs/C-8"]),
+			ResolverPlaygroundTestCase(["=dev-libs/C-9"],  success = True, mergelist=["dev-libs/C-9"]),
+			ResolverPlaygroundTestCase(["=dev-libs/C-10"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/C-11"], success = True, mergelist=["dev-libs/C-11"]),
+			ResolverPlaygroundTestCase(["=dev-libs/C-12"], success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/C-13"], success = True, mergelist=["dev-libs/C-13"]),
+			ResolverPlaygroundTestCase(["=dev-libs/C-14"], success = True, mergelist=["dev-libs/C-14"]),
+
+			ResolverPlaygroundTestCase(["=dev-libs/D-1"],  success = True, mergelist=["dev-libs/D-1"]),
+			ResolverPlaygroundTestCase(["=dev-libs/D-2"],  success = True, mergelist=["dev-libs/D-2"]),
+			ResolverPlaygroundTestCase(["=dev-libs/D-3"],  success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/D-4"],  success = False),
+			ResolverPlaygroundTestCase(["=dev-libs/D-5"],  success = True, mergelist=["dev-libs/D-5"]),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds)
+		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 testRequiredUseOrDeps(self):
+		
+		ebuilds = {
+			"dev-libs/A-1": { "IUSE": "+x +y", "REQUIRED_USE": "^^ ( x y )", "EAPI": "4" },
+			"dev-libs/B-1": { "IUSE": "+x +y", "REQUIRED_USE": "",           "EAPI": "4" },
+			"app-misc/p-1": { "RDEPEND": "|| ( =dev-libs/A-1 =dev-libs/B-1 )" },
+			}
+
+		test_cases = (
+				# This should fail and show a REQUIRED_USE error for
+				# dev-libs/A-1, since this choice it preferred.
+				ResolverPlaygroundTestCase(
+					["=app-misc/p-1"],
+					success = False),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_simple.py b/portage_with_autodep/pym/portage/tests/resolver/test_simple.py
new file mode 100644
index 0000000..0bcfc4b
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_simple.py
@@ -0,0 +1,57 @@
+# Copyright 2010-2011 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 SimpleResolverTestCase(TestCase):
+
+	def testSimple(self):
+		ebuilds = {
+			"dev-libs/A-1": { "KEYWORDS": "x86" }, 
+			"dev-libs/A-2": { "KEYWORDS": "~x86" },
+			"dev-libs/B-1.2": {},
+
+			"app-misc/Z-1": { "DEPEND": "|| ( app-misc/Y ( app-misc/X app-misc/W ) )", "RDEPEND": "" },
+			"app-misc/Y-1": { "KEYWORDS": "~x86" },
+			"app-misc/X-1": {},
+			"app-misc/W-1": {},
+			}
+		installed = {
+			"dev-libs/A-1": {},
+			"dev-libs/B-1.1": {},
+			}
+
+		test_cases = (
+			ResolverPlaygroundTestCase(["dev-libs/A"], success = True, mergelist = ["dev-libs/A-1"]),
+			ResolverPlaygroundTestCase(["=dev-libs/A-2"], options = { "--autounmask": 'n' }, success = False),
+
+			ResolverPlaygroundTestCase(
+				["dev-libs/A"],
+				options = {"--noreplace": True},
+				success = True,
+				mergelist = []),
+			ResolverPlaygroundTestCase(
+				["dev-libs/B"],
+				options = {"--noreplace": True},
+				success = True,
+				mergelist = []),
+			ResolverPlaygroundTestCase(
+				["dev-libs/B"],
+				options = {"--update": True},
+				success = True,
+				mergelist = ["dev-libs/B-1.2"]),
+
+			ResolverPlaygroundTestCase(
+				["app-misc/Z"],
+				success = True,
+				mergelist = ["app-misc/W-1", "app-misc/X-1", "app-misc/Z-1"]),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, installed=installed)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_slot_collisions.py b/portage_with_autodep/pym/portage/tests/resolver/test_slot_collisions.py
new file mode 100644
index 0000000..4867cea
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_slot_collisions.py
@@ -0,0 +1,143 @@
+# Copyright 2010-2011 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 SlotCollisionTestCase(TestCase):
+
+	def testSlotCollision(self):
+
+		ebuilds = {
+			"dev-libs/A-1": { "PDEPEND": "foo? ( dev-libs/B )", "IUSE": "foo" }, 
+			"dev-libs/B-1": { "IUSE": "foo" },
+			"dev-libs/C-1": { "DEPEND": "dev-libs/A[foo]", "EAPI": 2 },
+			"dev-libs/D-1": { "DEPEND": "dev-libs/A[foo=] dev-libs/B[foo=]", "IUSE": "foo", "EAPI": 2 },
+			"dev-libs/E-1": {  },
+			"dev-libs/E-2": { "IUSE": "foo" },
+
+			"app-misc/Z-1": { },
+			"app-misc/Z-2": { },
+			"app-misc/Y-1": { "DEPEND": "=app-misc/Z-1" },
+			"app-misc/Y-2": { "DEPEND": ">app-misc/Z-1" },
+			"app-misc/X-1": { "DEPEND": "=app-misc/Z-2" },
+			"app-misc/X-2": { "DEPEND": "<app-misc/Z-2" },
+
+			"sci-libs/K-1": { "IUSE": "+foo", "EAPI": 1 },
+			"sci-libs/L-1": { "DEPEND": "sci-libs/K[-foo]", "EAPI": 2 },
+			"sci-libs/M-1": { "DEPEND": "sci-libs/K[foo=]", "IUSE": "+foo", "EAPI": 2 },
+
+			"sci-libs/Q-1": { "SLOT": "1", "IUSE": "+bar foo", "EAPI": 1 },
+			"sci-libs/Q-2": { "SLOT": "2", "IUSE": "+bar +foo", "EAPI": 2, "PDEPEND": "sci-libs/Q:1[bar?,foo?]" },
+			"sci-libs/P-1": { "DEPEND": "sci-libs/Q:1[foo=]", "IUSE": "foo", "EAPI": 2 },
+
+			"sys-libs/A-1": { "RDEPEND": "foo? ( sys-libs/J[foo=] )", "IUSE": "+foo", "EAPI": "4" },
+			"sys-libs/B-1": { "RDEPEND": "bar? ( sys-libs/J[bar=] )", "IUSE": "+bar", "EAPI": "4" },
+			"sys-libs/C-1": { "RDEPEND": "sys-libs/J[bar]", "EAPI": "4" },
+			"sys-libs/D-1": { "RDEPEND": "sys-libs/J[bar?]", "IUSE": "bar", "EAPI": "4" },
+			"sys-libs/E-1": { "RDEPEND": "sys-libs/J[foo(+)?]", "IUSE": "+foo", "EAPI": "4" },
+			"sys-libs/F-1": { "RDEPEND": "sys-libs/J[foo(+)]", "EAPI": "4" },
+			"sys-libs/J-1": { "IUSE": "+foo", "EAPI": "4" },
+			"sys-libs/J-2": { "IUSE": "+bar", "EAPI": "4" },
+
+			"app-misc/A-1": { "IUSE": "foo +bar", "REQUIRED_USE": "^^ ( foo bar )", "EAPI": "4" },
+			"app-misc/B-1": { "DEPEND": "=app-misc/A-1[foo=]", "IUSE": "foo", "EAPI": 2 },
+			"app-misc/C-1": { "DEPEND": "=app-misc/A-1[foo]", "EAPI": 2 },
+			"app-misc/E-1": { "RDEPEND": "dev-libs/E[foo?]", "IUSE": "foo", "EAPI": "2" },
+			"app-misc/F-1": { "RDEPEND": "=dev-libs/E-1", "IUSE": "foo", "EAPI": "2" },
+			}
+		installed = {
+			"dev-libs/A-1": { "PDEPEND": "foo? ( dev-libs/B )", "IUSE": "foo", "USE": "foo" }, 
+			"dev-libs/B-1": { "IUSE": "foo", "USE": "foo" },
+			"dev-libs/C-1": { "DEPEND": "dev-libs/A[foo]", "EAPI": 2 },
+			"dev-libs/D-1": { "DEPEND": "dev-libs/A[foo=] dev-libs/B[foo=]", "IUSE": "foo", "USE": "foo", "EAPI": 2 },
+			
+			"sci-libs/K-1": { "IUSE": "foo", "USE": "" },
+			"sci-libs/L-1": { "DEPEND": "sci-libs/K[-foo]" },
+
+			"sci-libs/Q-1": { "SLOT": "1", "IUSE": "+bar +foo", "USE": "bar foo", "EAPI": 1 },
+			"sci-libs/Q-2": { "SLOT": "2", "IUSE": "+bar +foo", "USE": "bar foo", "EAPI": 2, "PDEPEND": "sci-libs/Q:1[bar?,foo?]" },
+
+			"app-misc/A-1": { "IUSE": "+foo bar", "USE": "foo", "REQUIRED_USE": "^^ ( foo bar )", "EAPI": "4" },
+			}
+
+		test_cases = (
+			#A qt-*[qt3support] like mess.
+			ResolverPlaygroundTestCase(
+				["dev-libs/A", "dev-libs/B", "dev-libs/C", "dev-libs/D"],
+				options = { "--autounmask": 'n' },
+				success = False,
+				mergelist = ["dev-libs/A-1", "dev-libs/B-1", "dev-libs/C-1", "dev-libs/D-1"],
+				ignore_mergelist_order = True,
+				slot_collision_solutions = [ {"dev-libs/A-1": {"foo": True}, "dev-libs/D-1": {"foo": True}} ]),
+
+			ResolverPlaygroundTestCase(
+				["sys-libs/A", "sys-libs/B", "sys-libs/C", "sys-libs/D", "sys-libs/E", "sys-libs/F"],
+				options = { "--autounmask": 'n' },
+				success = False,
+				ignore_mergelist_order = True,
+				slot_collision_solutions = [],
+				mergelist = ['sys-libs/J-2', 'sys-libs/J-1', 'sys-libs/A-1', 'sys-libs/B-1', 'sys-libs/C-1', 'sys-libs/D-1', 'sys-libs/E-1', 'sys-libs/F-1'],
+				),
+
+			#A version based conflicts, nothing we can do.
+			ResolverPlaygroundTestCase(
+				["=app-misc/X-1", "=app-misc/Y-1"],
+				success = False,
+				mergelist = ["app-misc/Z-1", "app-misc/Z-2", "app-misc/X-1", "app-misc/Y-1"],
+				ignore_mergelist_order = True,
+				slot_collision_solutions = []
+				),
+			ResolverPlaygroundTestCase(
+				["=app-misc/X-2", "=app-misc/Y-2"],
+				success = False,
+				mergelist = ["app-misc/Z-1", "app-misc/Z-2", "app-misc/X-2", "app-misc/Y-2"],
+				ignore_mergelist_order = True,
+				slot_collision_solutions = []
+				),
+
+			ResolverPlaygroundTestCase(
+				["=app-misc/E-1", "=app-misc/F-1"],
+				success = False,
+				mergelist = ["dev-libs/E-1", "dev-libs/E-2", "app-misc/E-1", "app-misc/F-1"],
+				ignore_mergelist_order = True,
+				slot_collision_solutions = []
+				),
+
+			#Simple cases.
+			ResolverPlaygroundTestCase(
+				["sci-libs/L", "sci-libs/M"],
+				success = False,
+				mergelist = ["sci-libs/L-1", "sci-libs/M-1", "sci-libs/K-1"],
+				ignore_mergelist_order = True,
+				slot_collision_solutions = [{"sci-libs/K-1": {"foo": False}, "sci-libs/M-1": {"foo": False}}]
+				),
+
+			#Avoid duplicates.
+			ResolverPlaygroundTestCase(
+				["sci-libs/P", "sci-libs/Q:2"],
+				success = False,
+				options = { "--update": True, "--complete-graph": True, "--autounmask": 'n' },
+				mergelist = ["sci-libs/P-1", "sci-libs/Q-1"],
+				ignore_mergelist_order = True,
+				all_permutations=True,
+				slot_collision_solutions = [{"sci-libs/Q-1": {"foo": True}, "sci-libs/P-1": {"foo": True}}]
+				),
+
+			#Conflict with REQUIRED_USE
+			ResolverPlaygroundTestCase(
+				["=app-misc/C-1", "=app-misc/B-1"],
+				all_permutations = True,
+				slot_collision_solutions = [],
+				mergelist = ["app-misc/A-1", "app-misc/C-1", "app-misc/B-1"],
+				ignore_mergelist_order = True,
+				success = False),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds, installed=installed)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/resolver/test_use_dep_defaults.py b/portage_with_autodep/pym/portage/tests/resolver/test_use_dep_defaults.py
new file mode 100644
index 0000000..7d17106
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/resolver/test_use_dep_defaults.py
@@ -0,0 +1,40 @@
+# 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 UseDepDefaultsTestCase(TestCase):
+
+	def testUseDepDefaultse(self):
+
+		ebuilds = {
+			"dev-libs/A-1": { "DEPEND": "dev-libs/B[foo]", "RDEPEND": "dev-libs/B[foo]", "EAPI": "2" },
+			"dev-libs/A-2": { "DEPEND": "dev-libs/B[foo(+)]", "RDEPEND": "dev-libs/B[foo(+)]", "EAPI": "4" },
+			"dev-libs/A-3": { "DEPEND": "dev-libs/B[foo(-)]", "RDEPEND": "dev-libs/B[foo(-)]", "EAPI": "4" },
+			"dev-libs/B-1": { "IUSE": "+foo", "EAPI": "1" },
+			"dev-libs/B-2": {},
+			}
+
+		test_cases = (
+			ResolverPlaygroundTestCase(
+				["=dev-libs/A-1"],
+				success = True,
+				mergelist = ["dev-libs/B-1", "dev-libs/A-1"]),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/A-2"],
+				success = True,
+				mergelist = ["dev-libs/B-2", "dev-libs/A-2"]),
+			ResolverPlaygroundTestCase(
+				["=dev-libs/A-3"],
+				success = True,
+				mergelist = ["dev-libs/B-1", "dev-libs/A-3"]),
+			)
+
+		playground = ResolverPlayground(ebuilds=ebuilds)
+		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()
diff --git a/portage_with_autodep/pym/portage/tests/runTests b/portage_with_autodep/pym/portage/tests/runTests
new file mode 100755
index 0000000..6b3311d
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/runTests
@@ -0,0 +1,46 @@
+#!/usr/bin/python
+# runTests.py -- Portage Unit Test Functionality
+# Copyright 2006 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import os, sys
+import os.path as osp
+import grp
+import pwd
+import signal
+
+def debug_signal(signum, frame):
+	import pdb
+	pdb.set_trace()
+signal.signal(signal.SIGUSR1, debug_signal)
+
+# Pretend that the current user's uid/gid are the 'portage' uid/gid,
+# so things go smoothly regardless of the current user and global
+# user/group configuration.
+os.environ["PORTAGE_USERNAME"] = pwd.getpwuid(os.getuid()).pw_name
+os.environ["PORTAGE_GRPNAME"] = grp.getgrgid(os.getgid()).gr_name
+
+# Insert our parent dir so we can do shiny import "tests"
+# This line courtesy of Marienz and Pkgcore ;)
+sys.path.insert(0, osp.dirname(osp.dirname(osp.dirname(osp.abspath(__file__)))))
+
+import portage
+
+# Ensure that we don't instantiate portage.settings, so that tests should
+# work the same regardless of global configuration file state/existence.
+portage._disable_legacy_globals()
+
+import portage.tests as tests
+from portage.const import PORTAGE_BIN_PATH
+path = os.environ.get("PATH", "").split(":")
+path = [x for x in path if x]
+if not path or not os.path.samefile(path[0], PORTAGE_BIN_PATH):
+	path.insert(0, PORTAGE_BIN_PATH)
+	os.environ["PATH"] = ":".join(path)
+del path
+
+
+if __name__ == "__main__":
+	result = tests.main()
+	if not result.wasSuccessful():
+		sys.exit(1)
diff --git a/portage_with_autodep/pym/portage/tests/sets/__init__.py b/portage_with_autodep/pym/portage/tests/sets/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/sets/__init__.py
diff --git a/portage_with_autodep/pym/portage/tests/sets/base/__init__.py b/portage_with_autodep/pym/portage/tests/sets/base/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/sets/base/__init__.py
diff --git a/portage_with_autodep/pym/portage/tests/sets/base/__test__ b/portage_with_autodep/pym/portage/tests/sets/base/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/sets/base/__test__
diff --git a/portage_with_autodep/pym/portage/tests/sets/base/testInternalPackageSet.py b/portage_with_autodep/pym/portage/tests/sets/base/testInternalPackageSet.py
new file mode 100644
index 0000000..e0a3478
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/sets/base/testInternalPackageSet.py
@@ -0,0 +1,61 @@
+# testConfigFileSet.py -- Portage Unit Testing Functionality
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.dep import Atom
+from portage.exception import InvalidAtom
+from portage.tests import TestCase
+from portage._sets.base import InternalPackageSet
+
+class InternalPackageSetTestCase(TestCase):
+	"""Simple Test Case for InternalPackageSet"""
+
+	def testInternalPackageSet(self):
+		i1_atoms = set(("dev-libs/A", ">=dev-libs/A-1", "dev-libs/B"))
+		i2_atoms = set(("dev-libs/A", "dev-libs/*", "dev-libs/C"))
+
+		i1 = InternalPackageSet(initial_atoms=i1_atoms)
+		i2 = InternalPackageSet(initial_atoms=i2_atoms, allow_wildcard=True)
+		self.assertRaises(InvalidAtom, InternalPackageSet, initial_atoms=i2_atoms)
+
+		self.assertEqual(i1.getAtoms(), i1_atoms)
+		self.assertEqual(i2.getAtoms(), i2_atoms)
+
+		new_atom = Atom("*/*", allow_wildcard=True)
+		self.assertRaises(InvalidAtom, i1.add, new_atom)
+		i2.add(new_atom)
+
+		i2_atoms.add(new_atom)
+
+		self.assertEqual(i1.getAtoms(), i1_atoms)
+		self.assertEqual(i2.getAtoms(), i2_atoms)
+
+		removed_atom = Atom("dev-libs/A")
+
+		i1.remove(removed_atom)
+		i2.remove(removed_atom)
+
+		i1_atoms.remove(removed_atom)
+		i2_atoms.remove(removed_atom)
+
+		self.assertEqual(i1.getAtoms(), i1_atoms)
+		self.assertEqual(i2.getAtoms(), i2_atoms)
+
+		update_atoms = [Atom("dev-libs/C"), Atom("dev-*/C", allow_wildcard=True)]
+
+		self.assertRaises(InvalidAtom, i1.update, update_atoms)
+		i2.update(update_atoms)
+
+		i2_atoms.update(update_atoms)
+
+		self.assertEqual(i1.getAtoms(), i1_atoms)
+		self.assertEqual(i2.getAtoms(), i2_atoms)
+
+		replace_atoms = [Atom("dev-libs/D"), Atom("*-libs/C", allow_wildcard=True)]
+
+		self.assertRaises(InvalidAtom, i1.replace, replace_atoms)
+		i2.replace(replace_atoms)
+
+		i2_atoms = set(replace_atoms)
+
+		self.assertEqual(i2.getAtoms(), i2_atoms)
diff --git a/portage_with_autodep/pym/portage/tests/sets/files/__init__.py b/portage_with_autodep/pym/portage/tests/sets/files/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/sets/files/__init__.py
diff --git a/portage_with_autodep/pym/portage/tests/sets/files/__test__ b/portage_with_autodep/pym/portage/tests/sets/files/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/sets/files/__test__
diff --git a/portage_with_autodep/pym/portage/tests/sets/files/testConfigFileSet.py b/portage_with_autodep/pym/portage/tests/sets/files/testConfigFileSet.py
new file mode 100644
index 0000000..3ec26a0
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/sets/files/testConfigFileSet.py
@@ -0,0 +1,32 @@
+# testConfigFileSet.py -- Portage Unit Testing Functionality
+# Copyright 2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import tempfile
+
+from portage import os
+from portage.tests import TestCase, test_cps
+from portage._sets.files import ConfigFileSet
+
+class ConfigFileSetTestCase(TestCase):
+	"""Simple Test Case for ConfigFileSet"""
+
+	def setUp(self):
+		fd, self.testfile = tempfile.mkstemp(suffix=".testdata", prefix=self.__class__.__name__, text=True)
+		f = os.fdopen(fd, 'w')
+		for i in range(0, len(test_cps)):
+			atom = test_cps[i]
+			if i % 2 == 0:
+				f.write(atom + ' abc def\n')
+			else:
+				f.write(atom + '\n')
+		f.close()
+
+	def tearDown(self):
+		os.unlink(self.testfile)
+
+	def testConfigStaticFileSet(self):
+		s = ConfigFileSet(self.testfile)
+		s.load()
+		self.assertEqual(set(test_cps), s.getAtoms())
+
diff --git a/portage_with_autodep/pym/portage/tests/sets/files/testStaticFileSet.py b/portage_with_autodep/pym/portage/tests/sets/files/testStaticFileSet.py
new file mode 100644
index 0000000..d515a67
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/sets/files/testStaticFileSet.py
@@ -0,0 +1,27 @@
+# testStaticFileSet.py -- Portage Unit Testing Functionality
+# Copyright 2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import tempfile
+
+from portage import os
+from portage.tests import TestCase, test_cps
+from portage._sets.files import StaticFileSet
+
+class StaticFileSetTestCase(TestCase):
+	"""Simple Test Case for StaticFileSet"""
+
+	def setUp(self):
+		fd, self.testfile = tempfile.mkstemp(suffix=".testdata", prefix=self.__class__.__name__, text=True)
+		f = os.fdopen(fd, 'w')
+		f.write("\n".join(test_cps))
+		f.close()
+
+	def tearDown(self):
+		os.unlink(self.testfile)
+
+	def testSampleStaticFileSet(self):
+		s = StaticFileSet(self.testfile)
+		s.load()
+		self.assertEqual(set(test_cps), s.getAtoms())
+
diff --git a/portage_with_autodep/pym/portage/tests/sets/shell/__init__.py b/portage_with_autodep/pym/portage/tests/sets/shell/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/sets/shell/__init__.py
diff --git a/portage_with_autodep/pym/portage/tests/sets/shell/__test__ b/portage_with_autodep/pym/portage/tests/sets/shell/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/sets/shell/__test__
diff --git a/portage_with_autodep/pym/portage/tests/sets/shell/testShell.py b/portage_with_autodep/pym/portage/tests/sets/shell/testShell.py
new file mode 100644
index 0000000..2cdd833
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/sets/shell/testShell.py
@@ -0,0 +1,28 @@
+# testCommandOututSet.py -- Portage Unit Testing Functionality
+# Copyright 2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.process import find_binary
+from portage.tests import TestCase, test_cps
+from portage._sets.shell import CommandOutputSet
+
+class CommandOutputSetTestCase(TestCase):
+	"""Simple Test Case for CommandOutputSet"""
+
+	def setUp(self):
+		pass
+
+	def tearDown(self):
+		pass
+
+	def testCommand(self):
+		
+		input = set(test_cps)
+		command = find_binary("bash")
+		command += " -c '"
+		for a in input:
+		  command += " echo -e \"%s\" ; " % a
+		command += "'"
+		s = CommandOutputSet(command)
+		atoms = s.getAtoms()
+		self.assertEqual(atoms, input)
diff --git a/portage_with_autodep/pym/portage/tests/unicode/__init__.py b/portage_with_autodep/pym/portage/tests/unicode/__init__.py
new file mode 100644
index 0000000..21a391a
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/unicode/__init__.py
@@ -0,0 +1,2 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
diff --git a/portage_with_autodep/pym/portage/tests/unicode/__test__ b/portage_with_autodep/pym/portage/tests/unicode/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/unicode/__test__
diff --git a/portage_with_autodep/pym/portage/tests/unicode/test_string_format.py b/portage_with_autodep/pym/portage/tests/unicode/test_string_format.py
new file mode 100644
index 0000000..fb6e8e0
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/unicode/test_string_format.py
@@ -0,0 +1,108 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+import sys
+
+from portage import _encodings, _unicode_decode
+from portage.exception import PortageException
+from portage.tests import TestCase
+from _emerge.DependencyArg import DependencyArg
+from _emerge.UseFlagDisplay import UseFlagDisplay
+
+if sys.hexversion >= 0x3000000:
+	basestring = str
+
+STR_IS_UNICODE = sys.hexversion >= 0x3000000
+
+class StringFormatTestCase(TestCase):
+	"""
+	Test that string formatting works correctly in the current interpretter,
+	which may be either python2 or python3.
+	"""
+
+	# In order to get some unicode test strings in a way that works in
+	# both python2 and python3, write them here as byte strings and
+	# decode them before use. This assumes _encodings['content'] is
+	# utf_8.
+
+	unicode_strings = (
+		b'\xE2\x80\x98',
+		b'\xE2\x80\x99',
+	)
+
+	def testDependencyArg(self):
+
+		self.assertEqual(_encodings['content'], 'utf_8')
+
+		for arg_bytes in self.unicode_strings:
+			arg_unicode = _unicode_decode(arg_bytes, encoding=_encodings['content'])
+			dependency_arg = DependencyArg(arg=arg_unicode)
+
+			# Force unicode format string so that __unicode__() is
+			# called in python2.
+			formatted_str = _unicode_decode("%s") % (dependency_arg,)
+			self.assertEqual(formatted_str, arg_unicode)
+
+			if STR_IS_UNICODE:
+
+				# Test the __str__ method which returns unicode in python3
+				formatted_str = "%s" % (dependency_arg,)
+				self.assertEqual(formatted_str, arg_unicode)
+
+			else:
+
+				# Test the __str__ method which returns encoded bytes in python2
+				formatted_bytes = "%s" % (dependency_arg,)
+				self.assertEqual(formatted_bytes, arg_bytes)
+
+	def testPortageException(self):
+
+		self.assertEqual(_encodings['content'], 'utf_8')
+
+		for arg_bytes in self.unicode_strings:
+			arg_unicode = _unicode_decode(arg_bytes, encoding=_encodings['content'])
+			e = PortageException(arg_unicode)
+
+			# Force unicode format string so that __unicode__() is
+			# called in python2.
+			formatted_str = _unicode_decode("%s") % (e,)
+			self.assertEqual(formatted_str, arg_unicode)
+
+			if STR_IS_UNICODE:
+
+				# Test the __str__ method which returns unicode in python3
+				formatted_str = "%s" % (e,)
+				self.assertEqual(formatted_str, arg_unicode)
+
+			else:
+
+				# Test the __str__ method which returns encoded bytes in python2
+				formatted_bytes = "%s" % (e,)
+				self.assertEqual(formatted_bytes, arg_bytes)
+
+	def testUseFlagDisplay(self):
+
+		self.assertEqual(_encodings['content'], 'utf_8')
+
+		for enabled in (True, False):
+			for forced in (True, False):
+				for arg_bytes in self.unicode_strings:
+					arg_unicode = _unicode_decode(arg_bytes, encoding=_encodings['content'])
+					e = UseFlagDisplay(arg_unicode, enabled, forced)
+
+					# Force unicode format string so that __unicode__() is
+					# called in python2.
+					formatted_str = _unicode_decode("%s") % (e,)
+					self.assertEqual(isinstance(formatted_str, basestring), True)
+
+					if STR_IS_UNICODE:
+
+						# Test the __str__ method which returns unicode in python3
+						formatted_str = "%s" % (e,)
+						self.assertEqual(isinstance(formatted_str, str), True)
+
+					else:
+
+						# Test the __str__ method which returns encoded bytes in python2
+						formatted_bytes = "%s" % (e,)
+						self.assertEqual(isinstance(formatted_bytes, bytes), True)
diff --git a/portage_with_autodep/pym/portage/tests/util/__init__.py b/portage_with_autodep/pym/portage/tests/util/__init__.py
new file mode 100644
index 0000000..69ce189
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/util/__init__.py
@@ -0,0 +1,4 @@
+# tests/portage.util/__init__.py -- Portage Unit Test functionality
+# Copyright 2006 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
diff --git a/portage_with_autodep/pym/portage/tests/util/__test__ b/portage_with_autodep/pym/portage/tests/util/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/util/__test__
diff --git a/portage_with_autodep/pym/portage/tests/util/test_digraph.py b/portage_with_autodep/pym/portage/tests/util/test_digraph.py
new file mode 100644
index 0000000..b65c0b1
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/util/test_digraph.py
@@ -0,0 +1,201 @@
+# Copyright 2010-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.util.digraph import digraph
+#~ from portage.util import noiselimit
+import portage.util
+
+class DigraphTest(TestCase):
+
+	def testBackwardCompatibility(self):
+		g = digraph()
+		f = g.copy()
+		g.addnode("A", None)
+		self.assertEqual("A" in g, True)
+		self.assertEqual(bool(g), True)
+		self.assertEqual(g.allnodes(), ["A"])
+		self.assertEqual(g.allzeros(), ["A"])
+		self.assertEqual(g.hasnode("A"), True)
+
+	def testDigraphEmptyGraph(self):
+		g = digraph()
+		f = g.clone()
+		for x in g, f:
+			self.assertEqual(bool(x), False)
+			self.assertEqual(x.contains("A"), False)
+			self.assertEqual(x.firstzero(), None)
+			self.assertRaises(KeyError, x.remove, "A")
+			x.delnode("A")
+			self.assertEqual(list(x), [])
+			self.assertEqual(x.get("A"), None)
+			self.assertEqual(x.get("A", "default"), "default")
+			self.assertEqual(x.all_nodes(), [])
+			self.assertEqual(x.leaf_nodes(), [])
+			self.assertEqual(x.root_nodes(), [])
+			self.assertRaises(KeyError, x.child_nodes, "A")
+			self.assertRaises(KeyError, x.parent_nodes, "A")
+			self.assertEqual(x.hasallzeros(), True)
+			self.assertRaises(KeyError, list, x.bfs("A"))
+			self.assertRaises(KeyError, x.shortest_path, "A", "B")
+			self.assertRaises(KeyError, x.remove_edge, "A", "B")
+			self.assertEqual(x.get_cycles(), [])
+			x.difference_update("A")
+			portage.util.noiselimit = -2
+			x.debug_print()
+			portage.util.noiselimit = 0
+
+	def testDigraphCircle(self):
+		g = digraph()
+		g.add("A", "B", -1)
+		g.add("B", "C", 0)
+		g.add("C", "D", 1)
+		g.add("D", "A", 2)
+
+		f = g.clone()
+		for x in g, f:
+			self.assertEqual(bool(x), True)
+			self.assertEqual(x.contains("A"), True)
+			self.assertEqual(x.firstzero(), None)
+			self.assertRaises(KeyError, x.remove, "Z")
+			x.delnode("Z")
+			self.assertEqual(list(x), ["A", "B", "C", "D"])
+			self.assertEqual(x.get("A"), "A")
+			self.assertEqual(x.get("A", "default"), "A")
+			self.assertEqual(x.all_nodes(), ["A", "B", "C", "D"])
+			self.assertEqual(x.leaf_nodes(), [])
+			self.assertEqual(x.root_nodes(), [])
+			self.assertEqual(x.child_nodes("A"), ["D"])
+			self.assertEqual(x.child_nodes("A", ignore_priority=2), [])
+			self.assertEqual(x.parent_nodes("A"), ["B"])
+			self.assertEqual(x.parent_nodes("A", ignore_priority=-2), ["B"])
+			self.assertEqual(x.parent_nodes("A", ignore_priority=-1), [])
+			self.assertEqual(x.hasallzeros(), False)
+			self.assertEqual(list(x.bfs("A")), [(None, "A"), ("A", "D"), ("D", "C"), ("C", "B")])
+			self.assertEqual(x.shortest_path("A", "D"), ["A", "D"])
+			self.assertEqual(x.shortest_path("D", "A"), ["D", "C", "B", "A"])
+			self.assertEqual(x.shortest_path("A", "D", ignore_priority=2), None)
+			self.assertEqual(x.shortest_path("D", "A", ignore_priority=-2), ["D", "C", "B", "A"])
+			cycles = set(tuple(y) for y in x.get_cycles())
+			self.assertEqual(cycles, set([("D", "C", "B", "A"), ("C", "B", "A", "D"), ("B", "A", "D", "C"), \
+				("A", "D", "C", "B")]))
+			x.remove_edge("A", "B")
+			self.assertEqual(x.get_cycles(), [])
+			x.difference_update(["D"])
+			self.assertEqual(x.all_nodes(), ["A", "B", "C"])
+			portage.util.noiselimit = -2
+			x.debug_print()
+			portage.util.noiselimit = 0
+
+	def testDigraphTree(self):
+		g = digraph()
+		g.add("B", "A", -1)
+		g.add("C", "A", 0)
+		g.add("D", "C", 1)
+		g.add("E", "C", 2)
+
+		f = g.clone()
+		for x in g, f:
+			self.assertEqual(bool(x), True)
+			self.assertEqual(x.contains("A"), True)
+			self.assertEqual(x.firstzero(), "B")
+			self.assertRaises(KeyError, x.remove, "Z")
+			x.delnode("Z")
+			self.assertEqual(set(x), set(["A", "B", "C", "D", "E"]))
+			self.assertEqual(x.get("A"), "A")
+			self.assertEqual(x.get("A", "default"), "A")
+			self.assertEqual(set(x.all_nodes()), set(["A", "B", "C", "D", "E"]))
+			self.assertEqual(set(x.leaf_nodes()), set(["B", "D", "E"]))
+			self.assertEqual(set(x.leaf_nodes(ignore_priority=0)), set(["A", "B", "D", "E"]))
+			self.assertEqual(x.root_nodes(), ["A"])
+			self.assertEqual(set(x.root_nodes(ignore_priority=0)), set(["A", "B", "C"]))
+			self.assertEqual(set(x.child_nodes("A")), set(["B", "C"]))
+			self.assertEqual(x.child_nodes("A", ignore_priority=2), [])
+			self.assertEqual(x.parent_nodes("B"), ["A"])
+			self.assertEqual(x.parent_nodes("B", ignore_priority=-2), ["A"])
+			self.assertEqual(x.parent_nodes("B", ignore_priority=-1), [])
+			self.assertEqual(x.hasallzeros(), False)
+			self.assertEqual(list(x.bfs("A")), [(None, "A"), ("A", "C"), ("A", "B"), ("C", "E"), ("C", "D")])
+			self.assertEqual(x.shortest_path("A", "D"), ["A", "C", "D"])
+			self.assertEqual(x.shortest_path("D", "A"), None)
+			self.assertEqual(x.shortest_path("A", "D", ignore_priority=2), None)
+			cycles = set(tuple(y) for y in x.get_cycles())
+			self.assertEqual(cycles, set())
+			x.remove("D")
+			self.assertEqual(set(x.all_nodes()), set(["A", "B", "C", "E"]))
+			x.remove("C")
+			self.assertEqual(set(x.all_nodes()), set(["A", "B", "E"]))
+			portage.util.noiselimit = -2
+			x.debug_print()
+			portage.util.noiselimit = 0
+			self.assertRaises(KeyError, x.remove_edge, "A", "E")
+
+	def testDigraphCompleteGraph(self):
+		g = digraph()
+		g.add("A", "B", -1)
+		g.add("B", "A", 1)
+		g.add("A", "C", 1)
+		g.add("C", "A", -1)
+		g.add("C", "B", 1)
+		g.add("B", "C", 1)
+
+		f = g.clone()
+		for x in g, f:
+			self.assertEqual(bool(x), True)
+			self.assertEqual(x.contains("A"), True)
+			self.assertEqual(x.firstzero(), None)
+			self.assertRaises(KeyError, x.remove, "Z")
+			x.delnode("Z")
+			self.assertEqual(list(x), ["A", "B", "C"])
+			self.assertEqual(x.get("A"), "A")
+			self.assertEqual(x.get("A", "default"), "A")
+			self.assertEqual(x.all_nodes(), ["A", "B", "C"])
+			self.assertEqual(x.leaf_nodes(), [])
+			self.assertEqual(x.root_nodes(), [])
+			self.assertEqual(set(x.child_nodes("A")), set(["B", "C"]))
+			self.assertEqual(x.child_nodes("A", ignore_priority=0), ["B"])
+			self.assertEqual(set(x.parent_nodes("A")), set(["B", "C"]))
+			self.assertEqual(x.parent_nodes("A", ignore_priority=0), ["C"])
+			self.assertEqual(x.parent_nodes("A", ignore_priority=1), [])
+			self.assertEqual(x.hasallzeros(), False)
+			self.assertEqual(list(x.bfs("A")), [(None, "A"), ("A", "C"), ("A", "B")])
+			self.assertEqual(x.shortest_path("A", "C"), ["A", "C"])
+			self.assertEqual(x.shortest_path("C", "A"), ["C", "A"])
+			self.assertEqual(x.shortest_path("A", "C", ignore_priority=0), ["A", "B", "C"])
+			self.assertEqual(x.shortest_path("C", "A", ignore_priority=0), ["C", "A"])
+			cycles = set(tuple(y) for y in x.get_cycles())
+			self.assertEqual(cycles, set([("C", "A"), ("A", "B"), ("A", "C")]))
+			x.remove_edge("A", "B")
+			self.assertEqual(x.get_cycles(), [["C", "A"], ["A", "C"], ["C", "B"]])
+			x.difference_update(["C"])
+			self.assertEqual(x.all_nodes(), ["A", "B"])
+			portage.util.noiselimit = -2
+			x.debug_print()
+			portage.util.noiselimit = 0
+
+	def testDigraphIgnorePriority(self):
+
+		def always_true(dummy):
+			return True
+
+		def always_false(dummy):
+			return False
+
+		g = digraph()
+		g.add("A", "B")
+
+		self.assertEqual(g.parent_nodes("A"), ["B"])
+		self.assertEqual(g.parent_nodes("A", ignore_priority=always_false), ["B"])
+		self.assertEqual(g.parent_nodes("A", ignore_priority=always_true), [])
+
+		self.assertEqual(g.child_nodes("B"), ["A"])
+		self.assertEqual(g.child_nodes("B", ignore_priority=always_false), ["A"])
+		self.assertEqual(g.child_nodes("B", ignore_priority=always_true), [])
+
+		self.assertEqual(g.leaf_nodes(), ["A"])
+		self.assertEqual(g.leaf_nodes(ignore_priority=always_false), ["A"])
+		self.assertEqual(g.leaf_nodes(ignore_priority=always_true), ["A", "B"])
+
+		self.assertEqual(g.root_nodes(), ["B"])
+		self.assertEqual(g.root_nodes(ignore_priority=always_false), ["B"])
+		self.assertEqual(g.root_nodes(ignore_priority=always_true), ["A", "B"])
diff --git a/portage_with_autodep/pym/portage/tests/util/test_getconfig.py b/portage_with_autodep/pym/portage/tests/util/test_getconfig.py
new file mode 100644
index 0000000..22e0bfc
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/util/test_getconfig.py
@@ -0,0 +1,29 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage import os
+from portage.const import PORTAGE_BASE_PATH
+from portage.tests import TestCase
+from portage.util import getconfig
+
+class GetConfigTestCase(TestCase):
+	"""
+	Test that getconfig() produces that same result as bash would when
+	sourcing the same input.
+	"""
+
+	_cases = {
+		'FETCHCOMMAND'             : '/usr/bin/wget -t 3 -T 60 --passive-ftp -O "${DISTDIR}/${FILE}" "${URI}"',
+		'FETCHCOMMAND_RSYNC'       : 'rsync -avP "${URI}" "${DISTDIR}/${FILE}"',
+		'FETCHCOMMAND_SFTP'        : 'bash -c "x=\\${2#sftp://} ; host=\\${x%%/*} ; port=\\${host##*:} ; host=\\${host%:*} ; [[ \\${host} = \\${port} ]] && port=22 ; exec sftp -P \\${port} \\"\\${host}:/\\${x#*/}\\" \\"\\$1\\"" sftp "${DISTDIR}/${FILE}" "${URI}"',
+		'FETCHCOMMAND_SSH'         : 'bash -c "x=\\${2#ssh://} ; host=\\${x%%/*} ; port=\\${host##*:} ; host=\\${host%:*} ; [[ \\${host} = \\${port} ]] && port=22 ; exec rsync --rsh=\\"ssh -p\\${port}\\" -avP \\"\\${host}:/\\${x#*/}\\" \\"\\$1\\"" rsync "${DISTDIR}/${FILE}" "${URI}"',
+		'PORTAGE_ELOG_MAILSUBJECT' : '[portage] ebuild log for ${PACKAGE} on ${HOST}'
+	}
+
+	def testGetConfig(self):
+
+		make_globals_file = os.path.join(PORTAGE_BASE_PATH,
+			'cnf', 'make.globals')
+		d = getconfig(make_globals_file)
+		for k, v in self._cases.items():
+			self.assertEqual(d[k], v)
diff --git a/portage_with_autodep/pym/portage/tests/util/test_grabdict.py b/portage_with_autodep/pym/portage/tests/util/test_grabdict.py
new file mode 100644
index 0000000..e62a75d
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/util/test_grabdict.py
@@ -0,0 +1,11 @@
+# test_grabDict.py -- Portage Unit Testing Functionality
+# Copyright 2006-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+#from portage.util import grabdict
+
+class GrabDictTestCase(TestCase):
+	
+	def testGrabDictPass(self):
+		pass
diff --git a/portage_with_autodep/pym/portage/tests/util/test_normalizedPath.py b/portage_with_autodep/pym/portage/tests/util/test_normalizedPath.py
new file mode 100644
index 0000000..f993886
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/util/test_normalizedPath.py
@@ -0,0 +1,14 @@
+# test_normalizePath.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
+
+class NormalizePathTestCase(TestCase):
+	
+	def testNormalizePath(self):
+		
+		from portage.util import normalize_path
+		path = "///foo/bar/baz"
+		good = "/foo/bar/baz"
+		self.assertEqual(normalize_path(path), good)
diff --git a/portage_with_autodep/pym/portage/tests/util/test_stackDictList.py b/portage_with_autodep/pym/portage/tests/util/test_stackDictList.py
new file mode 100644
index 0000000..678001c
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/util/test_stackDictList.py
@@ -0,0 +1,17 @@
+# test_stackDictList.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
+
+class StackDictListTestCase(TestCase):
+
+	def testStackDictList(self):
+		from portage.util import stack_dictlist
+		
+		tests = [ ({'a':'b'},{'x':'y'},False,{'a':['b'],'x':['y']}) ]
+		tests.append(( {'KEYWORDS':['alpha','x86']},{'KEYWORDS':['-*']},True,{} ))
+		tests.append(( {'KEYWORDS':['alpha','x86']},{'KEYWORDS':['-x86']},True,{'KEYWORDS':['alpha']} ))
+		for test in tests:
+			self.assertEqual(
+			stack_dictlist([test[0],test[1]],incremental=test[2]), test[3] )
diff --git a/portage_with_autodep/pym/portage/tests/util/test_stackDicts.py b/portage_with_autodep/pym/portage/tests/util/test_stackDicts.py
new file mode 100644
index 0000000..0d2cadd
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/util/test_stackDicts.py
@@ -0,0 +1,36 @@
+# test_stackDicts.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.util import stack_dicts
+
+
+class StackDictsTestCase(TestCase):
+	
+	def testStackDictsPass(self):
+		
+		tests = [ ( [ { "a":"b" }, { "b":"c" } ], { "a":"b", "b":"c" },
+			  False, [], False ),
+			  ( [ { "a":"b" }, { "a":"c" } ], { "a":"b c" },
+			  True, [], False ),
+			  ( [ { "a":"b" }, { "a":"c" } ], { "a":"b c" },
+			  False, ["a"], False ),
+			  ( [ { "a":"b" }, None ], { "a":"b" },
+			  False, [], True ),
+			  ( [ None ], {}, False, [], False ),
+			  ( [ None, {}], {}, False, [], True ) ]
+
+
+		for test in tests:
+			result = stack_dicts( test[0], test[2], test[3], test[4] )
+			self.assertEqual( result, test[1] )
+	
+	def testStackDictsFail(self):
+		
+		tests = [ ( [ None, {} ], None, False, [], True ),
+			  ( [ { "a":"b"}, {"a":"c" } ], { "a":"b c" },
+				False, [], False ) ]
+		for test in tests:
+			result = stack_dicts( test[0], test[2], test[3], test[4] )
+			self.assertNotEqual( result , test[1] )
diff --git a/portage_with_autodep/pym/portage/tests/util/test_stackLists.py b/portage_with_autodep/pym/portage/tests/util/test_stackLists.py
new file mode 100644
index 0000000..8d01ea5
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/util/test_stackLists.py
@@ -0,0 +1,19 @@
+# test_stackLists.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.util import stack_lists
+
+class StackListsTestCase(TestCase):
+	
+	def testStackLists(self):
+		
+		tests = [ ( [ ['a','b','c'], ['d','e','f'] ], ['a','c','b','e','d','f'], False ),
+			  ( [ ['a','x'], ['b','x'] ], ['a','x','b'], False ),
+			  ( [ ['a','b','c'], ['-*'] ], [], True ),
+			  ( [ ['a'], ['-a'] ], [], True ) ]
+
+		for test in tests:
+			result = stack_lists( test[0], test[2] )
+			self.assertEqual( result , test[1] )
diff --git a/portage_with_autodep/pym/portage/tests/util/test_uniqueArray.py b/portage_with_autodep/pym/portage/tests/util/test_uniqueArray.py
new file mode 100644
index 0000000..2a1a209
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/util/test_uniqueArray.py
@@ -0,0 +1,24 @@
+# test_uniqueArray.py -- Portage Unit Testing Functionality
+# Copyright 2006 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage import os
+from portage.tests import TestCase
+from portage.util import unique_array
+
+class UniqueArrayTestCase(TestCase):
+	
+	def testUniqueArrayPass(self):
+		"""
+		test portage.util.uniqueArray()
+		"""
+
+		tests = [ ( ["a","a","a",os,os,[],[],[]], ['a',os,[]] ), 
+			  ( [1,1,1,2,3,4,4] , [1,2,3,4]) ]
+
+		for test in tests:
+			result = unique_array( test[0] )
+			for item in test[1]:
+				number = result.count(item)
+				self.assertFalse( number is not 1, msg="%s contains %s of %s, \
+					should be only 1" % (result, number, item) )
diff --git a/portage_with_autodep/pym/portage/tests/util/test_varExpand.py b/portage_with_autodep/pym/portage/tests/util/test_varExpand.py
new file mode 100644
index 0000000..7b528d6
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/util/test_varExpand.py
@@ -0,0 +1,92 @@
+# test_varExpand.py -- Portage Unit Testing Functionality
+# Copyright 2006-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.util import varexpand
+
+class VarExpandTestCase(TestCase):
+	
+	def testVarExpandPass(self):
+
+		varDict = { "a":"5", "b":"7", "c":"-5" }
+		for key in varDict:
+			result = varexpand( "$%s" % key, varDict )
+			
+			self.assertFalse( result != varDict[key],
+				msg="Got %s != %s, from varexpand( %s, %s )" % \
+					( result, varDict[key], "$%s" % key, varDict ) )
+			result = varexpand( "${%s}" % key, varDict )
+			self.assertFalse( result != varDict[key],
+				msg="Got %s != %s, from varexpand( %s, %s )" % \
+					( result, varDict[key], "${%s}" % key, varDict ) )
+
+	def testVarExpandBackslashes(self):
+		"""
+		We want to behave like bash does when expanding a variable
+		assignment in a sourced file, in which case it performs
+		backslash removal for \\ and \$ but nothing more. It also
+		removes escaped newline characters. Note that we don't
+		handle escaped quotes here, since getconfig() uses shlex
+		to handle that earlier.
+		"""
+
+		varDict = {}
+		tests = [
+			("\\", "\\"),
+			("\\\\", "\\"),
+			("\\\\\\", "\\\\"),
+			("\\\\\\\\", "\\\\"),
+			("\\$", "$"),
+			("\\\\$", "\\$"),
+			("\\a", "\\a"),
+			("\\b", "\\b"),
+			("\\n", "\\n"),
+			("\\r", "\\r"),
+			("\\t", "\\t"),
+			("\\\n", ""),
+			("\\\"", "\\\""),
+			("\\'", "\\'"),
+		]
+		for test in tests:
+			result = varexpand( test[0], varDict )
+			self.assertFalse( result != test[1],
+				msg="Got %s != %s from varexpand( %s, %s )" \
+				% ( result, test[1], test[0], varDict ) )
+
+	def testVarExpandDoubleQuotes(self):
+		
+		varDict = { "a":"5" }
+		tests = [ ("\"${a}\"", "\"5\"") ]
+		for test in tests:
+			result = varexpand( test[0], varDict )
+			self.assertFalse( result != test[1],
+				msg="Got %s != %s from varexpand( %s, %s )" \
+				% ( result, test[1], test[0], varDict ) )
+
+	def testVarExpandSingleQuotes(self):
+		
+		varDict = { "a":"5" }
+		tests = [ ("\'${a}\'", "\'${a}\'") ]
+		for test in tests:
+			result = varexpand( test[0], varDict )
+			self.assertFalse( result != test[1],
+				msg="Got %s != %s from varexpand( %s, %s )" \
+				% ( result, test[1], test[0], varDict ) )
+
+	def testVarExpandFail(self):
+
+		varDict = { "a":"5", "b":"7", "c":"15" }
+
+		testVars = [ "fail" ]
+
+		for var in testVars:
+			result = varexpand( "$%s" % var, varDict )
+			self.assertFalse( len(result),
+				msg="Got %s == %s, from varexpand( %s, %s )" \
+					% ( result, var, "$%s" % var, varDict ) )
+
+			result = varexpand( "${%s}" % var, varDict )
+			self.assertFalse( len(result),
+				msg="Got %s == %s, from varexpand( %s, %s )" \
+					% ( result, var, "${%s}" % var, varDict ) )
diff --git a/portage_with_autodep/pym/portage/tests/versions/__init__.py b/portage_with_autodep/pym/portage/tests/versions/__init__.py
new file mode 100644
index 0000000..2b14180
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/versions/__init__.py
@@ -0,0 +1,3 @@
+# tests/portage.versions/__init__.py -- Portage Unit Test functionality
+# Copyright 2006 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
diff --git a/portage_with_autodep/pym/portage/tests/versions/__test__ b/portage_with_autodep/pym/portage/tests/versions/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/versions/__test__
diff --git a/portage_with_autodep/pym/portage/tests/versions/test_cpv_sort_key.py b/portage_with_autodep/pym/portage/tests/versions/test_cpv_sort_key.py
new file mode 100644
index 0000000..a223d78
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/versions/test_cpv_sort_key.py
@@ -0,0 +1,16 @@
+# Copyright 2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.versions import cpv_sort_key
+
+class CpvSortKeyTestCase(TestCase):
+
+	def testCpvSortKey(self):
+
+		tests = [ (("a/b-2_alpha", "a", "b", "a/b-2", "a/a-1", "a/b-1"),
+			( "a", "a/a-1", "a/b-1", "a/b-2_alpha", "a/b-2", "b")),
+		]
+
+		for test in tests:
+			self.assertEqual( tuple(sorted(test[0], key=cpv_sort_key())), test[1] )
diff --git a/portage_with_autodep/pym/portage/tests/versions/test_vercmp.py b/portage_with_autodep/pym/portage/tests/versions/test_vercmp.py
new file mode 100644
index 0000000..aa7969c
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/versions/test_vercmp.py
@@ -0,0 +1,80 @@
+# test_vercmp.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.versions import vercmp
+
+class VerCmpTestCase(TestCase):
+	""" A simple testCase for portage.versions.vercmp()
+	"""
+	
+	def testVerCmpGreater(self):
+		
+		tests = [ ( "6.0", "5.0"), ("5.0","5"),
+			("1.0-r1", "1.0-r0"),
+			("1.0-r1", "1.0"),
+			("cvs.9999", "9999"),
+			("999999999999999999999999999999", "999999999999999999999999999998"),
+			("1.0.0", "1.0"),
+			("1.0.0", "1.0b"),
+			("1b", "1"),
+			("1b_p1", "1_p1"),
+			("1.1b", "1.1"),
+			("12.2.5", "12.2b"),
+		]
+		for test in tests:
+			self.assertFalse( vercmp( test[0], test[1] ) <= 0, msg="%s < %s? Wrong!" % (test[0],test[1]) )
+
+	def testVerCmpLess(self):
+		"""
+		pre < alpha < beta < rc < p -> test each of these, they are inductive (or should be..)
+		"""
+		tests = [ ( "4.0", "5.0"), ("5", "5.0"), ("1.0_pre2","1.0_p2"),
+			("1.0_alpha2", "1.0_p2"),("1.0_alpha1", "1.0_beta1"),("1.0_beta3","1.0_rc3"),
+			("1.001000000000000000001", "1.001000000000000000002"),
+			("1.00100000000", "1.0010000000000000001"),
+			("9999", "cvs.9999"),
+			("999999999999999999999999999998", "999999999999999999999999999999"),
+			("1.01", "1.1"),
+			("1.0-r0", "1.0-r1"),
+			("1.0", "1.0-r1"),
+			("1.0", "1.0.0"),
+			("1.0b", "1.0.0"),
+			("1_p1", "1b_p1"),
+			("1", "1b"),
+			("1.1", "1.1b"),
+			("12.2b", "12.2.5"),
+		]
+		for test in tests:
+			self.assertFalse( vercmp( test[0], test[1]) >= 0, msg="%s > %s? Wrong!" % (test[0],test[1]))
+	
+	
+	def testVerCmpEqual(self):
+		
+		tests = [ ("4.0", "4.0"),
+			("1.0", "1.0"),
+			("1.0-r0", "1.0"),
+			("1.0", "1.0-r0"),
+			("1.0-r0", "1.0-r0"),
+			("1.0-r1", "1.0-r1")]
+		for test in tests:
+			self.assertFalse( vercmp( test[0], test[1]) != 0, msg="%s != %s? Wrong!" % (test[0],test[1]))
+			
+	def testVerNotEqual(self):
+		
+		tests = [ ("1","2"),("1.0_alpha","1.0_pre"),("1.0_beta","1.0_alpha"),
+			("0", "0.0"),
+			("cvs.9999", "9999"),
+			("1.0-r0", "1.0-r1"),
+			("1.0-r1", "1.0-r0"),
+			("1.0", "1.0-r1"),
+			("1.0-r1", "1.0"),
+			("1.0", "1.0.0"),
+			("1_p1", "1b_p1"),
+			("1b", "1"),
+			("1.1b", "1.1"),
+			("12.2b", "12.2"),
+		]
+		for test in tests:
+			self.assertFalse( vercmp( test[0], test[1]) == 0, msg="%s == %s? Wrong!" % (test[0],test[1]))
diff --git a/portage_with_autodep/pym/portage/tests/xpak/__init__.py b/portage_with_autodep/pym/portage/tests/xpak/__init__.py
new file mode 100644
index 0000000..9c3f524
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/xpak/__init__.py
@@ -0,0 +1,3 @@
+# tests/portage.dep/__init__.py -- Portage Unit Test functionality
+# Copyright 2006 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
diff --git a/portage_with_autodep/pym/portage/tests/xpak/__test__ b/portage_with_autodep/pym/portage/tests/xpak/__test__
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/xpak/__test__
diff --git a/portage_with_autodep/pym/portage/tests/xpak/test_decodeint.py b/portage_with_autodep/pym/portage/tests/xpak/test_decodeint.py
new file mode 100644
index 0000000..2da5735
--- /dev/null
+++ b/portage_with_autodep/pym/portage/tests/xpak/test_decodeint.py
@@ -0,0 +1,16 @@
+# xpak/test_decodeint.py
+# Copright Gentoo Foundation 2006
+# Portage Unit Testing Functionality
+
+from portage.tests import TestCase
+from portage.xpak import decodeint, encodeint
+
+class testDecodeIntTestCase(TestCase):
+
+	def testDecodeInt(self):
+		
+		for n in range(1000):
+			self.assertEqual(decodeint(encodeint(n)), n)
+
+		for n in (2 ** 32 - 1,):
+			self.assertEqual(decodeint(encodeint(n)), n)