import os
import sys
import string
import platform
import itertools

import pytest
from pkg_resources.extern import packaging

import pkg_resources
from pkg_resources import (
 parse_requirements, VersionConflict, parse_version,
 Distribution, EntryPoint, Requirement, safe_version, safe_name,
 WorkingSet)


# from Python 3.6 docs.
def pairwise(iterable):
 "s -> (s0,s1), (s1,s2), (s2, s3), ..."
 a, b = itertools.tee(iterable)
 next(b, None)
 return zip(a, b)


class Metadata(pkg_resources.EmptyProvider):
 """Mock object to return metadata as if from an on-disk distribution"""

 def __init__(self, *pairs):
 self.metadata = dict(pairs)

 def has_metadata(self, name):
 return name in self.metadata

 def get_metadata(self, name):
 return self.metadata[name]

 def get_metadata_lines(self, name):
 return pkg_resources.yield_lines(self.get_metadata(name))


dist_from_fn = pkg_resources.Distribution.from_filename


class TestDistro:
 def testCollection(self):
 # empty path should produce no distributions
 ad = pkg_resources.Environment([], platform=None, python=None)
 assert list(ad) == []
 assert ad['FooPkg'] == []
 ad.add(dist_from_fn("FooPkg-1.3_1.egg"))
 ad.add(dist_from_fn("FooPkg-1.4-py2.4-win32.egg"))
 ad.add(dist_from_fn("FooPkg-1.2-py2.4.egg"))

 # Name is in there now
 assert ad['FooPkg']
 # But only 1 package
 assert list(ad) == ['foopkg']

 # Distributions sort by version
 expected = ['1.4', '1.3-1', '1.2']
 assert [dist.version for dist in ad['FooPkg']] == expected

 # Removing a distribution leaves sequence alone
 ad.remove(ad['FooPkg'][1])
 assert [dist.version for dist in ad['FooPkg']] == ['1.4', '1.2']

 # And inserting adds them in order
 ad.add(dist_from_fn("FooPkg-1.9.egg"))
 assert [dist.version for dist in ad['FooPkg']] == ['1.9', '1.4', '1.2']

 ws = WorkingSet([])
 foo12 = dist_from_fn("FooPkg-1.2-py2.4.egg")
 foo14 = dist_from_fn("FooPkg-1.4-py2.4-win32.egg")
 req, = parse_requirements("FooPkg>=1.3")

 # Nominal case: no distros on path, should yield all applicable
 assert ad.best_match(req, ws).version == '1.9'
 # If a matching distro is already installed, should return only that
 ws.add(foo14)
 assert ad.best_match(req, ws).version == '1.4'

 # If the first matching distro is unsuitable, it's a version conflict
 ws = WorkingSet([])
 ws.add(foo12)
 ws.add(foo14)
 with pytest.raises(VersionConflict):
 ad.best_match(req, ws)

 # If more than one match on the path, the first one takes precedence
 ws = WorkingSet([])
 ws.add(foo14)
 ws.add(foo12)
 ws.add(foo14)
 assert ad.best_match(req, ws).version == '1.4'

 def checkFooPkg(self, d):
 assert d.project_name == "FooPkg"
 assert d.key == "foopkg"
 assert d.version == "1.3.post1"
 assert d.py_version == "2.4"
 assert d.platform == "win32"
 assert d.parsed_version == parse_version("1.3-1")

 def testDistroBasics(self):
 d = Distribution(
 "/some/path",
 project_name="FooPkg",
 version="1.3-1",
 py_version="2.4",
 platform="win32",
 )
 self.checkFooPkg(d)

 d = Distribution("/some/path")
 assert d.py_version == '{}.{}'.format(*sys.version_info)
 assert d.platform is None

 def testDistroParse(self):
 d = dist_from_fn("FooPkg-1.3.post1-py2.4-win32.egg")
 self.checkFooPkg(d)
 d = dist_from_fn("FooPkg-1.3.post1-py2.4-win32.egg-info")
 self.checkFooPkg(d)

 def testDistroMetadata(self):
 d = Distribution(
 "/some/path", project_name="FooPkg",
 py_version="2.4", platform="win32",
 metadata=Metadata(
 ('PKG-INFO', "Metadata-Version: 1.0\nVersion: 1.3-1\n")
 ),
 )
 self.checkFooPkg(d)

 def distRequires(self, txt):
 return Distribution("/foo", metadata=Metadata(('depends.txt', txt)))

 def checkRequires(self, dist, txt, extras=()):
 assert list(dist.requires(extras)) == list(parse_requirements(txt))

 def testDistroDependsSimple(self):
 for v in "Twisted>=1.5", "Twisted>=1.5\nZConfig>=2.0":
 self.checkRequires(self.distRequires(v), v)

 needs_object_dir = pytest.mark.skipif(
 not hasattr(object, '__dir__'),
 reason='object.__dir__ necessary for self.__dir__ implementation',
 )

 def test_distribution_dir(self):
 d = pkg_resources.Distribution()
 dir(d)

 @needs_object_dir
 def test_distribution_dir_includes_provider_dir(self):
 d = pkg_resources.Distribution()
 before = d.__dir__()
 assert 'test_attr' not in before
 d._provider.test_attr = None
 after = d.__dir__()
 assert len(after) == len(before) + 1
 assert 'test_attr' in after

 @needs_object_dir
 def test_distribution_dir_ignores_provider_dir_leading_underscore(self):
 d = pkg_resources.Distribution()
 before = d.__dir__()
 assert '_test_attr' not in before
 d._provider._test_attr = None
 after = d.__dir__()
 assert len(after) == len(before)
 assert '_test_attr' not in after

 def testResolve(self):
 ad = pkg_resources.Environment([])
 ws = WorkingSet([])
 # Resolving no requirements -> nothing to install
 assert list(ws.resolve([], ad)) == []
 # Request something not in the collection -> DistributionNotFound
 with pytest.raises(pkg_resources.DistributionNotFound):
 ws.resolve(parse_requirements("Foo"), ad)

 Foo = Distribution.from_filename(
 "/foo_dir/Foo-1.2.egg",
 metadata=Metadata(('depends.txt', "[bar]\nBaz>=2.0"))
 )
 ad.add(Foo)
 ad.add(Distribution.from_filename("Foo-0.9.egg"))

 # Request thing(s) that are available -> list to activate
 for i in range(3):
 targets = list(ws.resolve(parse_requirements("Foo"), ad))
 assert targets == [Foo]
 list(map(ws.add, targets))
 with pytest.raises(VersionConflict):
 ws.resolve(parse_requirements("Foo==0.9"), ad)
 ws = WorkingSet([]) # reset

 # Request an extra that causes an unresolved dependency for "Baz"
 with pytest.raises(pkg_resources.DistributionNotFound):
 ws.resolve(parse_requirements("Foo[bar]"), ad)
 Baz = Distribution.from_filename(
 "/foo_dir/Baz-2.1.egg", metadata=Metadata(('depends.txt', "Foo"))
 )
 ad.add(Baz)

 # Activation list now includes resolved dependency
 assert (
 list(ws.resolve(parse_requirements("Foo[bar]"), ad))
 == [Foo, Baz]
 )
 # Requests for conflicting versions produce VersionConflict
 with pytest.raises(VersionConflict) as vc:
 ws.resolve(parse_requirements("Foo==1.2\nFoo!=1.2"), ad)

 msg = 'Foo 0.9 is installed but Foo==1.2 is required'
 assert vc.value.report() == msg

 def test_environment_marker_evaluation_negative(self):
 """Environment markers are evaluated at resolution time."""
 ad = pkg_resources.Environment([])
 ws = WorkingSet([])
 res = ws.resolve(parse_requirements("Foo;python_version<'2'"), ad)
 assert list(res) == []

 def test_environment_marker_evaluation_positive(self):
 ad = pkg_resources.Environment([])
 ws = WorkingSet([])
 Foo = Distribution.from_filename("/foo_dir/Foo-1.2.dist-info")
 ad.add(Foo)
 res = ws.resolve(parse_requirements("Foo;python_version>='2'"), ad)
 assert list(res) == [Foo]

 def test_environment_marker_evaluation_called(self):
 """
 If one package foo requires bar without any extras,
 markers should pass for bar without extras.
 """
 parent_req, = parse_requirements("foo")
 req, = parse_requirements("bar;python_version>='2'")
 req_extras = pkg_resources._ReqExtras({req: parent_req.extras})
 assert req_extras.markers_pass(req)

 parent_req, = parse_requirements("foo[]")
 req, = parse_requirements("bar;python_version>='2'")
 req_extras = pkg_resources._ReqExtras({req: parent_req.extras})
 assert req_extras.markers_pass(req)

 def test_marker_evaluation_with_extras(self):
 """Extras are also evaluated as markers at resolution time."""
 ad = pkg_resources.Environment([])
 ws = WorkingSet([])
 Foo = Distribution.from_filename(
 "/foo_dir/Foo-1.2.dist-info",
 metadata=Metadata(("METADATA", "Provides-Extra: baz\n"
 "Requires-Dist: quux; extra=='baz'"))
 )
 ad.add(Foo)
 assert list(ws.resolve(parse_requirements("Foo"), ad)) == [Foo]
 quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
 ad.add(quux)
 res = list(ws.resolve(parse_requirements("Foo[baz]"), ad))
 assert res == [Foo, quux]

 def test_marker_evaluation_with_extras_normlized(self):
 """Extras are also evaluated as markers at resolution time."""
 ad = pkg_resources.Environment([])
 ws = WorkingSet([])
 Foo = Distribution.from_filename(
 "/foo_dir/Foo-1.2.dist-info",
 metadata=Metadata(("METADATA", "Provides-Extra: baz-lightyear\n"
 "Requires-Dist: quux; extra=='baz-lightyear'"))
 )
 ad.add(Foo)
 assert list(ws.resolve(parse_requirements("Foo"), ad)) == [Foo]
 quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
 ad.add(quux)
 res = list(ws.resolve(parse_requirements("Foo[baz-lightyear]"), ad))
 assert res == [Foo, quux]

 def test_marker_evaluation_with_multiple_extras(self):
 ad = pkg_resources.Environment([])
 ws = WorkingSet([])
 Foo = Distribution.from_filename(
 "/foo_dir/Foo-1.2.dist-info",
 metadata=Metadata(("METADATA", "Provides-Extra: baz\n"
 "Requires-Dist: quux; extra=='baz'\n"
 "Provides-Extra: bar\n"
 "Requires-Dist: fred; extra=='bar'\n"))
 )
 ad.add(Foo)
 quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
 ad.add(quux)
 fred = Distribution.from_filename("/foo_dir/fred-0.1.dist-info")
 ad.add(fred)
 res = list(ws.resolve(parse_requirements("Foo[baz,bar]"), ad))
 assert sorted(res) == [fred, quux, Foo]

 def test_marker_evaluation_with_extras_loop(self):
 ad = pkg_resources.Environment([])
 ws = WorkingSet([])
 a = Distribution.from_filename(
 "/foo_dir/a-0.2.dist-info",
 metadata=Metadata(("METADATA", "Requires-Dist: c[a]"))
 )
 b = Distribution.from_filename(
 "/foo_dir/b-0.3.dist-info",
 metadata=Metadata(("METADATA", "Requires-Dist: c[b]"))
 )
 c = Distribution.from_filename(
 "/foo_dir/c-1.0.dist-info",
 metadata=Metadata(("METADATA", "Provides-Extra: a\n"
 "Requires-Dist: b;extra=='a'\n"
 "Provides-Extra: b\n"
 "Requires-Dist: foo;extra=='b'"))
 )
 foo = Distribution.from_filename("/foo_dir/foo-0.1.dist-info")
 for dist in (a, b, c, foo):
 ad.add(dist)
 res = list(ws.resolve(parse_requirements("a"), ad))
 assert res == [a, c, b, foo]

 @pytest.mark.xfail(
 sys.version_info[:2] == (3, 12) and sys.version_info.releaselevel != 'final',
 reason="https://github.com/python/cpython/issues/103632",
 )
 def testDistroDependsOptions(self):
 d = self.distRequires("""
 Twisted>=1.5
 [docgen]
 ZConfig>=2.0
 docutils>=0.3
 [fastcgi]
 fcgiapp>=0.1""")
 self.checkRequires(d, "Twisted>=1.5")
 self.checkRequires(
 d, "Twisted>=1.5 ZConfig>=2.0 docutils>=0.3".split(), ["docgen"]
 )
 self.checkRequires(
 d, "Twisted>=1.5 fcgiapp>=0.1".split(), ["fastcgi"]
 )
 self.checkRequires(
 d, "Twisted>=1.5 ZConfig>=2.0 docutils>=0.3 fcgiapp>=0.1".split(),
 ["docgen", "fastcgi"]
 )
 self.checkRequires(
 d, "Twisted>=1.5 fcgiapp>=0.1 ZConfig>=2.0 docutils>=0.3".split(),
 ["fastcgi", "docgen"]
 )
 with pytest.raises(pkg_resources.UnknownExtra):
 d.requires(["foo"])


class TestWorkingSet:
 def test_find_conflicting(self):
 ws = WorkingSet([])
 Foo = Distribution.from_filename("/foo_dir/Foo-1.2.egg")
 ws.add(Foo)

 # create a requirement that conflicts with Foo 1.2
 req = next(parse_requirements("Foo<1.2"))

 with pytest.raises(VersionConflict) as vc:
 ws.find(req)

 msg = 'Foo 1.2 is installed but Foo<1.2 is required'
 assert vc.value.report() == msg

 def test_resolve_conflicts_with_prior(self):
 """
 A ContextualVersionConflict should be raised when a requirement
 conflicts with a prior requirement for a different package.
 """
 # Create installation where Foo depends on Baz 1.0 and Bar depends on
 # Baz 2.0.
 ws = WorkingSet([])
 md = Metadata(('depends.txt', "Baz==1.0"))
 Foo = Distribution.from_filename("/foo_dir/Foo-1.0.egg", metadata=md)
 ws.add(Foo)
 md = Metadata(('depends.txt', "Baz==2.0"))
 Bar = Distribution.from_filename("/foo_dir/Bar-1.0.egg", metadata=md)
 ws.add(Bar)
 Baz = Distribution.from_filename("/foo_dir/Baz-1.0.egg")
 ws.add(Baz)
 Baz = Distribution.from_filename("/foo_dir/Baz-2.0.egg")
 ws.add(Baz)

 with pytest.raises(VersionConflict) as vc:
 ws.resolve(parse_requirements("Foo\nBar\n"))

 msg = "Baz 1.0 is installed but Baz==2.0 is required by "
 msg += repr(set(['Bar']))
 assert vc.value.report() == msg


class TestEntryPoints:
 def assertfields(self, ep):
 assert ep.name == "foo"
 assert ep.module_name == "pkg_resources.tests.test_resources"
 assert ep.attrs == ("TestEntryPoints",)
 assert ep.extras == ("x",)
 assert ep.load() is TestEntryPoints
 expect = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]"
 assert str(ep) == expect

 def setup_method(self, method):
 self.dist = Distribution.from_filename(
 "FooPkg-1.2-py2.4.egg", metadata=Metadata(('requires.txt', '[x]')))

 def testBasics(self):
 ep = EntryPoint(
 "foo", "pkg_resources.tests.test_resources", ["TestEntryPoints"],
 ["x"], self.dist
 )
 self.assertfields(ep)

 def testParse(self):
 s = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]"
 ep = EntryPoint.parse(s, self.dist)
 self.assertfields(ep)

 ep = EntryPoint.parse("bar baz= spammity[PING]")
 assert ep.name == "bar baz"
 assert ep.module_name == "spammity"
 assert ep.attrs == ()
 assert ep.extras == ("ping",)

 ep = EntryPoint.parse(" fizzly = wocka:foo")
 assert ep.name == "fizzly"
 assert ep.module_name == "wocka"
 assert ep.attrs == ("foo",)
 assert ep.extras == ()

 # plus in the name
 spec = "html+mako = mako.ext.pygmentplugin:MakoHtmlLexer"
 ep = EntryPoint.parse(spec)
 assert ep.name == 'html+mako'

 reject_specs = "foo", "x=a:b:c", "q=x/na", "fez=pish:tush-z", "x=f[a]>2"

 @pytest.mark.parametrize("reject_spec", reject_specs)
 def test_reject_spec(self, reject_spec):
 with pytest.raises(ValueError):
 EntryPoint.parse(reject_spec)

 def test_printable_name(self):
 """
 Allow any printable character in the name.
 """
 # Create a name with all printable characters; strip the whitespace.
 name = string.printable.strip()
 spec = "{name} = module:attr".format(**locals())
 ep = EntryPoint.parse(spec)
 assert ep.name == name

 def checkSubMap(self, m):
 assert len(m) == len(self.submap_expect)
 for key, ep in self.submap_expect.items():
 assert m.get(key).name == ep.name
 assert m.get(key).module_name == ep.module_name
 assert sorted(m.get(key).attrs) == sorted(ep.attrs)
 assert sorted(m.get(key).extras) == sorted(ep.extras)

 submap_expect = dict(
 feature1=EntryPoint('feature1', 'somemodule', ['somefunction']),
 feature2=EntryPoint(
 'feature2', 'another.module', ['SomeClass'], ['extra1', 'extra2']),
 feature3=EntryPoint('feature3', 'this.module', extras=['something'])
 )
 submap_str = """
 # define features for blah blah
 feature1 = somemodule:somefunction
 feature2 = another.module:SomeClass [extra1,extra2]
 feature3 = this.module [something]
 """

 def testParseList(self):
 self.checkSubMap(EntryPoint.parse_group("xyz", self.submap_str))
 with pytest.raises(ValueError):
 EntryPoint.parse_group("x a", "foo=bar")
 with pytest.raises(ValueError):
 EntryPoint.parse_group("x", ["foo=baz", "foo=bar"])

 def testParseMap(self):
 m = EntryPoint.parse_map({'xyz': self.submap_str})
 self.checkSubMap(m['xyz'])
 assert list(m.keys()) == ['xyz']
 m = EntryPoint.parse_map("[xyz]\n" + self.submap_str)
 self.checkSubMap(m['xyz'])
 assert list(m.keys()) == ['xyz']
 with pytest.raises(ValueError):
 EntryPoint.parse_map(["[xyz]", "[xyz]"])
 with pytest.raises(ValueError):
 EntryPoint.parse_map(self.submap_str)

 def testDeprecationWarnings(self):
 ep = EntryPoint(
 "foo", "pkg_resources.tests.test_resources", ["TestEntryPoints"],
 ["x"]
 )
 with pytest.warns(pkg_resources.PkgResourcesDeprecationWarning):
 ep.load(require=False)


class TestRequirements:
 def testBasics(self):
 r = Requirement.parse("Twisted>=1.2")
 assert str(r) == "Twisted>=1.2"
 assert repr(r) == "Requirement.parse('Twisted>=1.2')"
 assert r == Requirement("Twisted>=1.2")
 assert r == Requirement("twisTed>=1.2")
 assert r != Requirement("Twisted>=2.0")
 assert r != Requirement("Zope>=1.2")
 assert r != Requirement("Zope>=3.0")
 assert r != Requirement("Twisted[extras]>=1.2")

 def testOrdering(self):
 r1 = Requirement("Twisted==1.2c1,>=1.2")
 r2 = Requirement("Twisted>=1.2,==1.2c1")
 assert r1 == r2
 assert str(r1) == str(r2)
 assert str(r2) == "Twisted==1.2c1,>=1.2"
 assert (
 Requirement("Twisted")
 !=
 Requirement("Twisted @ https://localhost/twisted.zip")
 )

 def testBasicContains(self):
 r = Requirement("Twisted>=1.2")
 foo_dist = Distribution.from_filename("FooPkg-1.3_1.egg")
 twist11 = Distribution.from_filename("Twisted-1.1.egg")
 twist12 = Distribution.from_filename("Twisted-1.2.egg")
 assert parse_version('1.2') in r
 assert parse_version('1.1') not in r
 assert '1.2' in r
 assert '1.1' not in r
 assert foo_dist not in r
 assert twist11 not in r
 assert twist12 in r

 def testOptionsAndHashing(self):
 r1 = Requirement.parse("Twisted[foo,bar]>=1.2")
 r2 = Requirement.parse("Twisted[bar,FOO]>=1.2")
 assert r1 == r2
 assert set(r1.extras) == set(("foo", "bar"))
 assert set(r2.extras) == set(("foo", "bar"))
 assert hash(r1) == hash(r2)
 assert (
 hash(r1)
 ==
 hash((
 "twisted",
 None,
 packaging.specifiers.SpecifierSet(">=1.2"),
 frozenset(["foo", "bar"]),
 None
 ))
 )
 assert (
 hash(Requirement.parse("Twisted @ https://localhost/twisted.zip"))
 ==
 hash((
 "twisted",
 "https://localhost/twisted.zip",
 packaging.specifiers.SpecifierSet(),
 frozenset(),
 None
 ))
 )

 def testVersionEquality(self):
 r1 = Requirement.parse("foo==0.3a2")
 r2 = Requirement.parse("foo!=0.3a4")
 d = Distribution.from_filename

 assert d("foo-0.3a4.egg") not in r1
 assert d("foo-0.3a1.egg") not in r1
 assert d("foo-0.3a4.egg") not in r2

 assert d("foo-0.3a2.egg") in r1
 assert d("foo-0.3a2.egg") in r2
 assert d("foo-0.3a3.egg") in r2
 assert d("foo-0.3a5.egg") in r2

 def testSetuptoolsProjectName(self):
 """
 The setuptools project should implement the setuptools package.
 """

 assert (
 Requirement.parse('setuptools').project_name == 'setuptools')
 # setuptools 0.7 and higher means setuptools.
 assert (
 Requirement.parse('setuptools == 0.7').project_name
 == 'setuptools'
 )
 assert (
 Requirement.parse('setuptools == 0.7a1').project_name
 == 'setuptools'
 )
 assert (
 Requirement.parse('setuptools >= 0.7').project_name
 == 'setuptools'
 )


class TestParsing:
 def testEmptyParse(self):
 assert list(parse_requirements('')) == []

 def testYielding(self):
 for inp, out in [
 ([], []), ('x', ['x']), ([[]], []), (' x\n y', ['x', 'y']),
 (['x\n\n', 'y'], ['x', 'y']),
 ]:
 assert list(pkg_resources.yield_lines(inp)) == out

 def testSplitting(self):
 sample = """
 x
 [Y]
 z

 a
 [b ]
 # foo
 c
 [ d]
 [q]
 v
 """
 assert (
 list(pkg_resources.split_sections(sample))
 ==
 [
 (None, ["x"]),
 ("Y", ["z", "a"]),
 ("b", ["c"]),
 ("d", []),
 ("q", ["v"]),
 ]
 )
 with pytest.raises(ValueError):
 list(pkg_resources.split_sections("[foo"))

 def testSafeName(self):
 assert safe_name("adns-python") == "adns-python"
 assert safe_name("WSGI Utils") == "WSGI-Utils"
 assert safe_name("WSGI Utils") == "WSGI-Utils"
 assert safe_name("Money$$$Maker") == "Money-Maker"
 assert safe_name("peak.web") != "peak-web"

 def testSafeVersion(self):
 assert safe_version("1.2-1") == "1.2.post1"
 assert safe_version("1.2 alpha") == "1.2.alpha"
 assert safe_version("2.3.4 20050521") == "2.3.4.20050521"
 assert safe_version("Money$$$Maker") == "Money-Maker"
 assert safe_version("peak.web") == "peak.web"

 def testSimpleRequirements(self):
 assert (
 list(parse_requirements('Twis-Ted>=1.2-1'))
 ==
 [Requirement('Twis-Ted>=1.2-1')]
 )
 assert (
 list(parse_requirements('Twisted >=1.2, \\ # more\n<2.0'))
 ==
 [Requirement('Twisted>=1.2,<2.0')]
 )
 assert (
 Requirement.parse("FooBar==1.99a3")
 ==
 Requirement("FooBar==1.99a3")
 )
 with pytest.raises(ValueError):
 Requirement.parse(">=2.3")
 with pytest.raises(ValueError):
 Requirement.parse("x\\")
 with pytest.raises(ValueError):
 Requirement.parse("x==2 q")
 with pytest.raises(ValueError):
 Requirement.parse("X==1\nY==2")
 with pytest.raises(ValueError):
 Requirement.parse("#")

 def test_requirements_with_markers(self):
 assert (
 Requirement.parse("foobar;os_name=='a'")
 ==
 Requirement.parse("foobar;os_name=='a'")
 )
 assert (
 Requirement.parse("name==1.1;python_version=='2.7'")
 !=
 Requirement.parse("name==1.1;python_version=='3.6'")
 )
 assert (
 Requirement.parse("name==1.0;python_version=='2.7'")
 !=
 Requirement.parse("name==1.2;python_version=='2.7'")
 )
 assert (
 Requirement.parse("name[foo]==1.0;python_version=='3.6'")
 !=
 Requirement.parse("name[foo,bar]==1.0;python_version=='3.6'")
 )

 def test_local_version(self):
 req, = parse_requirements('foo==1.0+org1')

 def test_spaces_between_multiple_versions(self):
 req, = parse_requirements('foo>=1.0, <3')
 req, = parse_requirements('foo >= 1.0, < 3')

 @pytest.mark.parametrize(
 ['lower', 'upper'],
 [
 ('1.2-rc1', '1.2rc1'),
 ('0.4', '0.4.0'),
 ('0.4.0.0', '0.4.0'),
 ('0.4.0-0', '0.4-0'),
 ('0post1', '0.0post1'),
 ('0pre1', '0.0c1'),
 ('0.0.0preview1', '0c1'),
 ('0.0c1', '0-rc1'),
 ('1.2a1', '1.2.a.1'),
 ('1.2.a', '1.2a'),
 ],
 )
 def testVersionEquality(self, lower, upper):
 assert parse_version(lower) == parse_version(upper)

 torture = """
 0.80.1-3 0.80.1-2 0.80.1-1 0.79.9999+0.80.0pre4-1
 0.79.9999+0.80.0pre2-3 0.79.9999+0.80.0pre2-2
 0.77.2-1 0.77.1-1 0.77.0-1
 """

 @pytest.mark.parametrize(
 ['lower', 'upper'],
 [
 ('2.1', '2.1.1'),
 ('2a1', '2b0'),
 ('2a1', '2.1'),
 ('2.3a1', '2.3'),
 ('2.1-1', '2.1-2'),
 ('2.1-1', '2.1.1'),
 ('2.1', '2.1post4'),
 ('2.1a0-20040501', '2.1'),
 ('1.1', '02.1'),
 ('3.2', '3.2.post0'),
 ('3.2post1', '3.2post2'),
 ('0.4', '4.0'),
 ('0.0.4', '0.4.0'),
 ('0post1', '0.4post1'),
 ('2.1.0-rc1', '2.1.0'),
 ('2.1dev', '2.1a0'),
 ] + list(pairwise(reversed(torture.split()))),
 )
 def testVersionOrdering(self, lower, upper):
 assert parse_version(lower) < parse_version(upper)

 def testVersionHashable(self):
 """
 Ensure that our versions stay hashable even though we've subclassed
 them and added some shim code to them.
 """
 assert (
 hash(parse_version("1.0"))
 ==
 hash(parse_version("1.0"))
 )


class TestNamespaces:

 ns_str = "__import__('pkg_resources').declare_namespace(__name__)\n"

 @pytest.fixture
 def symlinked_tmpdir(self, tmpdir):
 """
 Where available, return the tempdir as a symlink,
 which as revealed in #231 is more fragile than
 a natural tempdir.
 """
 if not hasattr(os, 'symlink'):
 yield str(tmpdir)
 return

 link_name = str(tmpdir) + '-linked'
 os.symlink(str(tmpdir), link_name)
 try:
 yield type(tmpdir)(link_name)
 finally:
 os.unlink(link_name)

 @pytest.fixture(autouse=True)
 def patched_path(self, tmpdir):
 """
 Patch sys.path to include the 'site-pkgs' dir. Also
 restore pkg_resources._namespace_packages to its
 former state.
 """
 saved_ns_pkgs = pkg_resources._namespace_packages.copy()
 saved_sys_path = sys.path[:]
 site_pkgs = tmpdir.mkdir('site-pkgs')
 sys.path.append(str(site_pkgs))
 try:
 yield
 finally:
 pkg_resources._namespace_packages = saved_ns_pkgs
 sys.path = saved_sys_path

 issue591 = pytest.mark.xfail(platform.system() == 'Windows', reason="#591")

 @issue591
 def test_two_levels_deep(self, symlinked_tmpdir):
 """
 Test nested namespace packages
 Create namespace packages in the following tree :
 site-packages-1/pkg1/pkg2
 site-packages-2/pkg1/pkg2
 Check both are in the _namespace_packages dict and that their __path__
 is correct
 """
 real_tmpdir = symlinked_tmpdir.realpath()
 tmpdir = symlinked_tmpdir
 sys.path.append(str(tmpdir / 'site-pkgs2'))
 site_dirs = tmpdir / 'site-pkgs', tmpdir / 'site-pkgs2'
 for site in site_dirs:
 pkg1 = site / 'pkg1'
 pkg2 = pkg1 / 'pkg2'
 pkg2.ensure_dir()
 (pkg1 / '__init__.py').write_text(self.ns_str, encoding='utf-8')
 (pkg2 / '__init__.py').write_text(self.ns_str, encoding='utf-8')
 with pytest.warns(DeprecationWarning, match="pkg_resources.declare_namespace"):
 import pkg1
 assert "pkg1" in pkg_resources._namespace_packages
 # attempt to import pkg2 from site-pkgs2
 with pytest.warns(DeprecationWarning, match="pkg_resources.declare_namespace"):
 import pkg1.pkg2
 # check the _namespace_packages dict
 assert "pkg1.pkg2" in pkg_resources._namespace_packages
 assert pkg_resources._namespace_packages["pkg1"] == ["pkg1.pkg2"]
 # check the __path__ attribute contains both paths
 expected = [
 str(real_tmpdir / "site-pkgs" / "pkg1" / "pkg2"),
 str(real_tmpdir / "site-pkgs2" / "pkg1" / "pkg2"),
 ]
 assert pkg1.pkg2.__path__ == expected

 @issue591
 def test_path_order(self, symlinked_tmpdir):
 """
 Test that if multiple versions of the same namespace package subpackage
 are on different sys.path entries, that only the one earliest on
 sys.path is imported, and that the namespace package's __path__ is in
 the correct order.

 Regression test for https://github.com/pypa/setuptools/issues/207
 """

 tmpdir = symlinked_tmpdir
 site_dirs = (
 tmpdir / "site-pkgs",
 tmpdir / "site-pkgs2",
 tmpdir / "site-pkgs3",
 )

 vers_str = "__version__ = %r"

 for number, site in enumerate(site_dirs, 1):
 if number > 1:
 sys.path.append(str(site))
 nspkg = site / 'nspkg'
 subpkg = nspkg / 'subpkg'
 subpkg.ensure_dir()
 (nspkg / '__init__.py').write_text(self.ns_str, encoding='utf-8')
 (subpkg / '__init__.py').write_text(
 vers_str % number, encoding='utf-8')

 with pytest.warns(DeprecationWarning, match="pkg_resources.declare_namespace"):
 import nspkg.subpkg
 import nspkg
 expected = [
 str(site.realpath() / 'nspkg')
 for site in site_dirs
 ]
 assert nspkg.__path__ == expected
 assert nspkg.subpkg.__version__ == 1