From 6eacfa12740b65d0f805316f58821cf01a4886d3 Mon Sep 17 00:00:00 2001 From: Lasote Date: Tue, 1 Dec 2015 14:18:01 +0100 Subject: [PATCH 01/78] Initial commit --- conans/errors.py | 81 +++++++++++++++++++++++++++++++++++++++++ conans/model/version.py | 65 +++++++++++++++++++++++++++++++++ 2 files changed, 146 insertions(+) create mode 100644 conans/errors.py create mode 100644 conans/model/version.py diff --git a/conans/errors.py b/conans/errors.py new file mode 100644 index 00000000..2bbdf449 --- /dev/null +++ b/conans/errors.py @@ -0,0 +1,81 @@ +''' + Exceptions raised and handled in Conan server. + These exceptions are mapped between server (as an HTTP response) and client + through the REST API. When an error happens in server its translated to an HTTP + error code that its sent to client. Client reads the server code and raise the + matching exception. + + see return_plugin.py + +''' + + +class ConanException(Exception): + """ + Generic conans exception + """ + pass + + +class InvalidNameException(ConanException): + pass + + +class ConanConnectionError(ConanException): + pass + + +class ConanOutdatedClient(ConanException): + pass + + +# Remote exceptions # + +class InternalErrorException(ConanException): + """ + Generic 500 error + """ + pass + + +class RequestErrorException(ConanException): + """ + Generic 400 error + """ + pass + + +class AuthenticationException(ConanException): # 401 + """ + 401 error + """ + pass + + +class ForbiddenException(ConanException): # 403 + """ + 403 error + """ + pass + + +class NotFoundException(ConanException): # 404 + """ + 404 error + """ + pass + + +class UserInterfaceErrorException(RequestErrorException): + """ + 420 error + """ + pass + + +EXCEPTION_CODE_MAPPING = {InternalErrorException: 500, + RequestErrorException: 400, + AuthenticationException: 401, + ForbiddenException: 403, + NotFoundException: 404, + UserInterfaceErrorException: 420} diff --git a/conans/model/version.py b/conans/model/version.py new file mode 100644 index 00000000..8d1f289f --- /dev/null +++ b/conans/model/version.py @@ -0,0 +1,65 @@ +class Version(str): + SEP = '.' + + def __new__(cls, content): + return str.__new__(cls, content.strip()) + + @property + def as_list(self): + result = [] + for item in self.split(Version.SEP): + result.append(int(item) if item.isdigit() else item) + return result + + def major(self, fill=True): + self_list = self.as_list + v = str(self_list[0]) if self_list else "0" + if fill: + return Version(".".join([v, 'Y', 'Z'])) + return Version(v) + + def stable(self): + """ same as major, but as semver, 0.Y.Z is not considered + stable, so return it as is + """ + if self.as_list[0] == 0: + return self + return self.major() + + def minor(self, fill=True): + self_list = self.as_list + v0 = str(self_list[0]) if len(self_list) > 0 else "0" + v1 = str(self_list[1]) if len(self_list) > 1 else "0" + if fill: + return Version(".".join([v0, v1, 'Z'])) + return Version(".".join([v0, v1])) + + def compatible(self, other): + if not isinstance(other, Version): + other = Version(other) + for v1, v2 in zip(self.as_list, other.as_list): + if v1 in ["X", "Y", "Z"] or v2 in ["X", "Y", "Z"]: + return True + if v1 != v2: + return False + return True + + def __cmp__(self, other): + if other is None: + return cmp(self.as_list, None) + if not isinstance(other, Version): + other = Version(other) + + return cmp(self.as_list, other.as_list) + + def __gt__(self, other): + return self.__cmp__(other) == 1 + + def __lt__(self, other): + return self.__cmp__(other) == -1 + + def __le__(self, other): + return self.__cmp__(other) in [0, -1] + + def __ge__(self, other): + return self.__cmp__(other) in [0, 1] From c7862b56b6fb610aa62d0cf56daed854af07f638 Mon Sep 17 00:00:00 2001 From: Lasote Date: Fri, 18 Mar 2016 18:10:34 +0100 Subject: [PATCH 02/78] Python 3 support and CI --- conans/model/version.py | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index 8d1f289f..4c9c39c4 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -46,12 +46,25 @@ def compatible(self, other): def __cmp__(self, other): if other is None: - return cmp(self.as_list, None) + return 1 if not isinstance(other, Version): other = Version(other) - return cmp(self.as_list, other.as_list) - + for ind, el in enumerate(self.as_list): + if ind +1 > len(other.as_list): + return 1 + elif el == other.as_list[ind]: + continue + elif el > other.as_list[ind]: + return 1 + else: + return -1 + + if len(other.as_list) > len(self.as_list): + return -1 + else: + return 0 + def __gt__(self, other): return self.__cmp__(other) == 1 From 1d8e4b1d5a884611b2e1a83bd9b3c7981ded28ff Mon Sep 17 00:00:00 2001 From: Luis Martinez Date: Mon, 21 Mar 2016 13:59:17 +0100 Subject: [PATCH 03/78] Versin compare fix --- conans/model/version.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index 4c9c39c4..a754fac5 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -51,20 +51,20 @@ def __cmp__(self, other): other = Version(other) for ind, el in enumerate(self.as_list): - if ind +1 > len(other.as_list): + if ind + 1 > len(other.as_list): return 1 - elif el == other.as_list[ind]: + elif str(el) == str(other.as_list[ind]): continue - elif el > other.as_list[ind]: + elif str(el) > str(other.as_list[ind]): return 1 else: return -1 - + if len(other.as_list) > len(self.as_list): return -1 else: return 0 - + def __gt__(self, other): return self.__cmp__(other) == 1 From ab3e41e311db164ca1d4fc1dace81f3a368470a0 Mon Sep 17 00:00:00 2001 From: Luis Martinez Date: Mon, 21 Mar 2016 14:09:39 +0100 Subject: [PATCH 04/78] Reverted version check --- conans/model/version.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index a754fac5..ba57d849 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -53,13 +53,12 @@ def __cmp__(self, other): for ind, el in enumerate(self.as_list): if ind + 1 > len(other.as_list): return 1 - elif str(el) == str(other.as_list[ind]): + elif el == other.as_list[ind]: continue - elif str(el) > str(other.as_list[ind]): + elif el > other.as_list[ind]: return 1 else: return -1 - if len(other.as_list) > len(self.as_list): return -1 else: From faca80612ab41479f577e83fed8d15352c6e855d Mon Sep 17 00:00:00 2001 From: Luis Martinez Date: Mon, 21 Mar 2016 19:29:59 +0100 Subject: [PATCH 05/78] Fixed output testing issues and improved version detection --- conans/model/version.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/conans/model/version.py b/conans/model/version.py index ba57d849..e2c847ef 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -53,6 +53,11 @@ def __cmp__(self, other): for ind, el in enumerate(self.as_list): if ind + 1 > len(other.as_list): return 1 + if not isinstance(el, int) and isinstance(other.as_list[ind], int): + # Version compare with 1.4.rc2 + return -1 + elif not isinstance(other.as_list[ind], int) and isinstance(el, int): + return 1 elif el == other.as_list[ind]: continue elif el > other.as_list[ind]: From fa1f2a7edfc380a4b99a7672e0abe02534fd3b34 Mon Sep 17 00:00:00 2001 From: memsharded Date: Sat, 27 Aug 2016 12:58:43 +0200 Subject: [PATCH 06/78] capturing traceback for offending line report --- conans/errors.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/conans/errors.py b/conans/errors.py index 2bbdf449..b095010d 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -10,6 +10,20 @@ ''' +def format_conanfile_exception(scope, method, exception): + import sys + import traceback + msg = "%s: Error in %s() method" % (scope, method) + try: + tb = sys.exc_info()[2] + _, line, _, contents = traceback.extract_tb(tb, 2)[1] + msg += ", line %d\n\t%s" % (line, contents) + except: + pass + msg += "\n\t%s" % str(exception) + return msg + + class ConanException(Exception): """ Generic conans exception From b2ec8ae270569240da66ab8c1d4675e1bb55a0f7 Mon Sep 17 00:00:00 2001 From: James Date: Wed, 14 Sep 2016 13:32:38 +0200 Subject: [PATCH 07/78] fixing migrations with no settings.yml. Fixing Version parsing and compare (#484) --- conans/model/version.py | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index e2c847ef..e3d25746 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -1,5 +1,10 @@ +import re + + class Version(str): - SEP = '.' + """ This is NOT an implementation of semver, as users may use any pattern in their versions. + It is just a helper to parse .-, and compare taking into account integers when possible + """ def __new__(cls, content): return str.__new__(cls, content.strip()) @@ -7,7 +12,8 @@ def __new__(cls, content): @property def as_list(self): result = [] - for item in self.split(Version.SEP): + tokens = re.split('[.-]', self) + for item in tokens: result.append(int(item) if item.isdigit() else item) return result @@ -50,21 +56,24 @@ def __cmp__(self, other): if not isinstance(other, Version): other = Version(other) + other_list = other.as_list for ind, el in enumerate(self.as_list): - if ind + 1 > len(other.as_list): - return 1 - if not isinstance(el, int) and isinstance(other.as_list[ind], int): + if ind + 1 > len(other_list): + if isinstance(el, int): + return 1 + return -1 + if not isinstance(el, int) and isinstance(other_list[ind], int): # Version compare with 1.4.rc2 return -1 - elif not isinstance(other.as_list[ind], int) and isinstance(el, int): + elif not isinstance(other_list[ind], int) and isinstance(el, int): return 1 - elif el == other.as_list[ind]: + elif el == other_list[ind]: continue - elif el > other.as_list[ind]: + elif el > other_list[ind]: return 1 else: return -1 - if len(other.as_list) > len(self.as_list): + if len(other_list) > len(self.as_list): return -1 else: return 0 From d529ee15f6a8158a24f02512067e77cd3d26d167 Mon Sep 17 00:00:00 2001 From: Luis Date: Tue, 20 Sep 2016 09:56:11 +0200 Subject: [PATCH 08/78] Better version compare in order to allow a 0.12.1-dev0 client operate against current 0.12.0 server (#498) --- conans/model/version.py | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index e2c847ef..e3d25746 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -1,5 +1,10 @@ +import re + + class Version(str): - SEP = '.' + """ This is NOT an implementation of semver, as users may use any pattern in their versions. + It is just a helper to parse .-, and compare taking into account integers when possible + """ def __new__(cls, content): return str.__new__(cls, content.strip()) @@ -7,7 +12,8 @@ def __new__(cls, content): @property def as_list(self): result = [] - for item in self.split(Version.SEP): + tokens = re.split('[.-]', self) + for item in tokens: result.append(int(item) if item.isdigit() else item) return result @@ -50,21 +56,24 @@ def __cmp__(self, other): if not isinstance(other, Version): other = Version(other) + other_list = other.as_list for ind, el in enumerate(self.as_list): - if ind + 1 > len(other.as_list): - return 1 - if not isinstance(el, int) and isinstance(other.as_list[ind], int): + if ind + 1 > len(other_list): + if isinstance(el, int): + return 1 + return -1 + if not isinstance(el, int) and isinstance(other_list[ind], int): # Version compare with 1.4.rc2 return -1 - elif not isinstance(other.as_list[ind], int) and isinstance(el, int): + elif not isinstance(other_list[ind], int) and isinstance(el, int): return 1 - elif el == other.as_list[ind]: + elif el == other_list[ind]: continue - elif el > other.as_list[ind]: + elif el > other_list[ind]: return 1 else: return -1 - if len(other.as_list) > len(self.as_list): + if len(other_list) > len(self.as_list): return -1 else: return 0 From 346774850d2866f50f7de4951a48696045fcf396 Mon Sep 17 00:00:00 2001 From: Luis Date: Tue, 27 Dec 2016 14:28:57 +0000 Subject: [PATCH 09/78] Feature/better upload (#795) * Upload/Download retries + upload errors + wilcard upload * Remove xrange * Py3 exception message removed * Upload url * failing test with order in py3 * Revision memsharded * Not retry when a 404 or other controlled error happen --- conans/errors.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/conans/errors.py b/conans/errors.py index b095010d..7990a3d8 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -87,6 +87,9 @@ class UserInterfaceErrorException(RequestErrorException): pass +class UploadException(ConanException): + pass + EXCEPTION_CODE_MAPPING = {InternalErrorException: 500, RequestErrorException: 400, AuthenticationException: 401, From 43f96b39fdccde185218f061ab01f3d57f9df3a6 Mon Sep 17 00:00:00 2001 From: Lasote Date: Tue, 3 Jan 2017 11:19:26 +0100 Subject: [PATCH 10/78] Moved retry to uploader_downloader, removed UploadException, changed error message with remotes --- conans/errors.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 7990a3d8..b095010d 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -87,9 +87,6 @@ class UserInterfaceErrorException(RequestErrorException): pass -class UploadException(ConanException): - pass - EXCEPTION_CODE_MAPPING = {InternalErrorException: 500, RequestErrorException: 400, AuthenticationException: 401, From 5296756cc58f9a3301841b950a64b0c3da0e2860 Mon Sep 17 00:00:00 2001 From: Luis Date: Tue, 3 Jan 2017 11:34:55 +0000 Subject: [PATCH 11/78] Release/0.18 better retries and exception handling (#828) * Fixes sums with pyc and output error with non ascii. Also added messages to retry commands * Removed log * Exclude pyc from packages and manifests * New test, exclude pyc in loads * New test, exclude pyc in loads * Moved retry to uploader_downloader, removed UploadException, changed error message with remotes --- conans/errors.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 7990a3d8..b095010d 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -87,9 +87,6 @@ class UserInterfaceErrorException(RequestErrorException): pass -class UploadException(ConanException): - pass - EXCEPTION_CODE_MAPPING = {InternalErrorException: 500, RequestErrorException: 400, AuthenticationException: 401, From d58ef71292285c5094fc57557219cfc962f91338 Mon Sep 17 00:00:00 2001 From: James Date: Tue, 31 Jan 2017 09:36:48 +0100 Subject: [PATCH 12/78] Feature/improve semver (#927) * patch, pre, build to Version * patch, pre, build to Version * reverted to default stable() behavior * fixed broken Version() test --- conans/model/version.py | 43 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 38 insertions(+), 5 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index e3d25746..4d36d120 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -5,17 +5,27 @@ class Version(str): """ This is NOT an implementation of semver, as users may use any pattern in their versions. It is just a helper to parse .-, and compare taking into account integers when possible """ + version_pattern = re.compile('[.-]') def __new__(cls, content): return str.__new__(cls, content.strip()) @property def as_list(self): - result = [] - tokens = re.split('[.-]', self) - for item in tokens: - result.append(int(item) if item.isdigit() else item) - return result + if not hasattr(self, "_cached_list"): + self._cached_list = [] + tokens = Version.version_pattern.split(self) + for item in tokens: + self._cached_list.append(int(item) if item.isdigit() else item) + try: + tokens = self._cached_list[-1].split('+') + except AttributeError: + pass + else: + if len(tokens) == 2: + self._cached_list[-1] = tokens[0] + self._build = tokens[1] + return self._cached_list def major(self, fill=True): self_list = self.as_list @@ -40,6 +50,29 @@ def minor(self, fill=True): return Version(".".join([v0, v1, 'Z'])) return Version(".".join([v0, v1])) + def patch(self): + self_list = self.as_list + v0 = str(self_list[0]) if len(self_list) > 0 else "0" + v1 = str(self_list[1]) if len(self_list) > 1 else "0" + v2 = str(self_list[2]) if len(self_list) > 2 else "0" + return Version(".".join([v0, v1, v2])) + + def pre(self): + self_list = self.as_list + v0 = str(self_list[0]) if len(self_list) > 0 else "0" + v1 = str(self_list[1]) if len(self_list) > 1 else "0" + v2 = str(self_list[2]) if len(self_list) > 2 else "0" + v = ".".join([v0, v1, v2]) + if len(self_list) > 3: + v += "-%s" % self_list[3] + return Version(v) + + @property + def build(self): + if hasattr(self, "_build"): + return self._build + return "" + def compatible(self, other): if not isinstance(other, Version): other = Version(other) From c5e05b220a9761ee677e6e162fc084f9cbe07ccb Mon Sep 17 00:00:00 2001 From: James Date: Thu, 16 Mar 2017 10:01:40 +0100 Subject: [PATCH 13/78] added new version modes, fixed string versions (#1108) --- conans/model/version.py | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index 4d36d120..1fe681fd 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -13,22 +13,20 @@ def __new__(cls, content): @property def as_list(self): if not hasattr(self, "_cached_list"): + tokens = self.rsplit('+', 1) + self._base = tokens[0] + if len(tokens) == 2: + self._build = tokens[1] self._cached_list = [] - tokens = Version.version_pattern.split(self) + tokens = Version.version_pattern.split(tokens[0]) for item in tokens: self._cached_list.append(int(item) if item.isdigit() else item) - try: - tokens = self._cached_list[-1].split('+') - except AttributeError: - pass - else: - if len(tokens) == 2: - self._cached_list[-1] = tokens[0] - self._build = tokens[1] return self._cached_list def major(self, fill=True): self_list = self.as_list + if not isinstance(self_list[0], int): + return self._base v = str(self_list[0]) if self_list else "0" if fill: return Version(".".join([v, 'Y', 'Z'])) @@ -44,6 +42,8 @@ def stable(self): def minor(self, fill=True): self_list = self.as_list + if not isinstance(self_list[0], int): + return self._base v0 = str(self_list[0]) if len(self_list) > 0 else "0" v1 = str(self_list[1]) if len(self_list) > 1 else "0" if fill: @@ -52,6 +52,8 @@ def minor(self, fill=True): def patch(self): self_list = self.as_list + if not isinstance(self_list[0], int): + return self._base v0 = str(self_list[0]) if len(self_list) > 0 else "0" v1 = str(self_list[1]) if len(self_list) > 1 else "0" v2 = str(self_list[2]) if len(self_list) > 2 else "0" @@ -59,6 +61,8 @@ def patch(self): def pre(self): self_list = self.as_list + if not isinstance(self_list[0], int): + return self._base v0 = str(self_list[0]) if len(self_list) > 0 else "0" v1 = str(self_list[1]) if len(self_list) > 1 else "0" v2 = str(self_list[2]) if len(self_list) > 2 else "0" @@ -73,6 +77,11 @@ def build(self): return self._build return "" + @property + def base(self): + self.as_list + return Version(self._base) + def compatible(self, other): if not isinstance(other, Version): other = Version(other) From 628c471ff35e76b08623dfd61228853165f10e75 Mon Sep 17 00:00:00 2001 From: Luis Martinez de Bartolome Izquierdo Date: Fri, 19 May 2017 12:27:54 +0200 Subject: [PATCH 14/78] Feature/exception messages (#1301) * build_requires in recipes * decoupling source folder * tests for local edition and no_copy_sources * fixed broken py3 test * fixed broken py3 test * fixed issue with local package build_folder nested * Ok * Fixed tests * PR: Revision --- conans/errors.py | 39 +++++++++++++++++++++++++++++++++------ 1 file changed, 33 insertions(+), 6 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index b095010d..66d717dc 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -1,4 +1,4 @@ -''' +""" Exceptions raised and handled in Conan server. These exceptions are mapped between server (as an HTTP response) and client through the REST API. When an error happens in server its translated to an HTTP @@ -7,20 +7,44 @@ see return_plugin.py -''' +""" +from contextlib import contextmanager -def format_conanfile_exception(scope, method, exception): + +@contextmanager +def conanfile_exception_formatter(conanfile_name, func_name): + """ + Decorator to throw an exception formatted with the line of the conanfile where the error ocurrs. + :param reference: Reference of the conanfile + :return: + """ + try: + yield + except Exception as exc: + msg = _format_conanfile_exception(conanfile_name, func_name, exc) + raise ConanExceptionInUserConanfileMethod(msg) + + +def _format_conanfile_exception(scope, method, exception): import sys import traceback msg = "%s: Error in %s() method" % (scope, method) try: tb = sys.exc_info()[2] - _, line, _, contents = traceback.extract_tb(tb, 2)[1] - msg += ", line %d\n\t%s" % (line, contents) + index = -1 + while True: # If out of index will raise and will be captured later + filepath, line, name, contents = traceback.extract_tb(tb, 40)[index] # 40 levels of nested functions max, get the latest + if not "conanfile.py" in filepath: # Avoid show trace from internal conan source code + index -= 1 + else: + break + if name != method: + msg += ", while calling '%s'" % name + msg += ", line %d\n\t%s" % (line, contents) if line else "\n\t%s" % contents except: pass - msg += "\n\t%s" % str(exception) + msg += "\n\t%s: %s" % (exception.__class__.__name__, str(exception)) return msg @@ -43,6 +67,9 @@ class ConanOutdatedClient(ConanException): pass +class ConanExceptionInUserConanfileMethod(ConanException): + pass + # Remote exceptions # class InternalErrorException(ConanException): From ec59d46ebd2f819ef306e003d090cf30ee646c66 Mon Sep 17 00:00:00 2001 From: James Date: Mon, 4 Sep 2017 08:44:06 +0200 Subject: [PATCH 15/78] minor style fixes (#1698) --- conans/errors.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 66d717dc..70cf7327 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -35,7 +35,7 @@ def _format_conanfile_exception(scope, method, exception): index = -1 while True: # If out of index will raise and will be captured later filepath, line, name, contents = traceback.extract_tb(tb, 40)[index] # 40 levels of nested functions max, get the latest - if not "conanfile.py" in filepath: # Avoid show trace from internal conan source code + if "conanfile.py" not in filepath: # Avoid show trace from internal conan source code index -= 1 else: break @@ -70,8 +70,8 @@ class ConanOutdatedClient(ConanException): class ConanExceptionInUserConanfileMethod(ConanException): pass -# Remote exceptions # +# Remote exceptions # class InternalErrorException(ConanException): """ Generic 500 error From 52d16ccbe0a1b0068b3a291fbf4adb01cff04c46 Mon Sep 17 00:00:00 2001 From: Luis Martinez de Bartolome Izquierdo Date: Mon, 11 Sep 2017 22:17:51 +0200 Subject: [PATCH 16/78] Feature/full traceback (#1703) * Progress not fully valid, missing external module dection and classic format * Review --- conans/errors.py | 36 ++++++++++++++++++++++++++---------- 1 file changed, 26 insertions(+), 10 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 70cf7327..0fcbadff 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -8,9 +8,10 @@ see return_plugin.py """ - from contextlib import contextmanager +from conans.util.env_reader import get_env + @contextmanager def conanfile_exception_formatter(conanfile_name, func_name): @@ -27,25 +28,40 @@ def conanfile_exception_formatter(conanfile_name, func_name): def _format_conanfile_exception(scope, method, exception): + """ + It will iterate the traceback lines, when it finds that the source code is inside the users + conanfile it "start recording" the messages, when the trace exits the conanfile we return + the traces. + """ import sys import traceback - msg = "%s: Error in %s() method" % (scope, method) + if get_env("CONAN_VERBOSE_TRACEBACK", False): + return traceback.format_exc() try: + conanfile_reached = False tb = sys.exc_info()[2] - index = -1 + index = 0 + content_lines = [] + while True: # If out of index will raise and will be captured later filepath, line, name, contents = traceback.extract_tb(tb, 40)[index] # 40 levels of nested functions max, get the latest if "conanfile.py" not in filepath: # Avoid show trace from internal conan source code - index -= 1 + if conanfile_reached: # The error goes to internal code, exit print + break else: - break - if name != method: - msg += ", while calling '%s'" % name - msg += ", line %d\n\t%s" % (line, contents) if line else "\n\t%s" % contents + if not conanfile_reached: # First line + msg = "%s: Error in %s() method" % (scope, method) + msg += ", line %d\n\t%s" % (line, contents) + else: + msg = "while calling '%s', line %d\n\t%s" % (name, line, contents) if line else "\n\t%s" % contents + content_lines.append(msg) + conanfile_reached = True + index += 1 except: pass - msg += "\n\t%s: %s" % (exception.__class__.__name__, str(exception)) - return msg + ret = "\n".join(content_lines) + ret += "\n\t%s: %s" % (exception.__class__.__name__, str(exception)) + return ret class ConanException(Exception): From 8e54ad0d575bd97567e4dd60ccb68828944b2502 Mon Sep 17 00:00:00 2001 From: Luis Martinez de Bartolome Date: Mon, 29 Jan 2018 15:45:57 +0100 Subject: [PATCH 17/78] Better catches --- conans/errors.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/conans/errors.py b/conans/errors.py index 0fcbadff..256f20a3 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -71,6 +71,12 @@ class ConanException(Exception): pass +class NoRemoteAvailable(ConanException): + """ No default remote configured or the specified remote do not exists + """ + pass + + class InvalidNameException(ConanException): pass From ce6b5b2e5850da6add1a0caf4ee758ae001f4465 Mon Sep 17 00:00:00 2001 From: James Date: Tue, 27 Mar 2018 13:05:46 +0200 Subject: [PATCH 18/78] improved messages, fix manifest exceptions (#2665) --- conans/errors.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/conans/errors.py b/conans/errors.py index 256f20a3..9ed68724 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -71,6 +71,10 @@ class ConanException(Exception): pass +class ConanManifestException(ConanException): + pass + + class NoRemoteAvailable(ConanException): """ No default remote configured or the specified remote do not exists """ From aa3ea869819d2431b4bf030d3ef9e6768ee4fda1 Mon Sep 17 00:00:00 2001 From: James Date: Mon, 16 Apr 2018 13:33:18 +0200 Subject: [PATCH 19/78] Feature/refactor get package (#2722) * refactor big get_package * working * test passing * reviewed * more tests * need to force outdated times * minor change --- conans/errors.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 9ed68724..256f20a3 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -71,10 +71,6 @@ class ConanException(Exception): pass -class ConanManifestException(ConanException): - pass - - class NoRemoteAvailable(ConanException): """ No default remote configured or the specified remote do not exists """ From e3aea9052e2f8c7896f762427f5e09e8f7d3296a Mon Sep 17 00:00:00 2001 From: Luis Martinez de Bartolome Izquierdo Date: Mon, 23 Apr 2018 10:24:43 +0200 Subject: [PATCH 20/78] Feature/improve output (#2728) * Timeout * review * Better testing framework, review fix * Removed print * 60 sec max * dependency flag in install info * Ref in conan api * Review PR --- conans/errors.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/conans/errors.py b/conans/errors.py index 256f20a3..e5b73a08 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -68,7 +68,9 @@ class ConanException(Exception): """ Generic conans exception """ - pass + def __init__(self, *args, **kwargs): + self.info = None + super(ConanException, self).__init__(*args, **kwargs) class NoRemoteAvailable(ConanException): From 429da798d017fad224cf2a603867b7b691663e5b Mon Sep 17 00:00:00 2001 From: Daniel Date: Fri, 25 May 2018 16:21:15 +0200 Subject: [PATCH 21/78] Fix version class for greater than comparison (#2927) * Fix version class for greater than comparison * added eq an ne to version class * integrated comparison and test * Added hash function to version class * new code * review --- conans/model/version.py | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index 1fe681fd..ce5bb8db 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -98,6 +98,18 @@ def __cmp__(self, other): if not isinstance(other, Version): other = Version(other) + # Check equals + def get_el(a_list, index): + if len(a_list) - 1 < index: + return 0 # out of range, 4 == 4.0 == 4.0.0 + return a_list[index] + + equals = all(get_el(other.as_list, ind) == get_el(self.as_list, ind) + for ind in range(0, max(len(other.as_list), len(self.as_list)))) + if equals: + return 0 + + # Check greater than or less than other_list = other.as_list for ind, el in enumerate(self.as_list): if ind + 1 > len(other_list): @@ -117,8 +129,6 @@ def __cmp__(self, other): return -1 if len(other_list) > len(self.as_list): return -1 - else: - return 0 def __gt__(self, other): return self.__cmp__(other) == 1 @@ -131,3 +141,12 @@ def __le__(self, other): def __ge__(self, other): return self.__cmp__(other) in [0, 1] + + def __eq__(self, other): + return self.__cmp__(other) == 0 + + def __ne__(self, other): + return not self.__eq__(other) + + def __hash__(self): + return str.__hash__(self) From 636886cda61a99b7157d5789ee22926f2213cbd4 Mon Sep 17 00:00:00 2001 From: Daniel Date: Mon, 16 Jul 2018 14:13:05 +0200 Subject: [PATCH 22/78] Fixed build property in Version class (#3219) --- conans/model/version.py | 1 + 1 file changed, 1 insertion(+) diff --git a/conans/model/version.py b/conans/model/version.py index ce5bb8db..ed9a2af0 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -73,6 +73,7 @@ def pre(self): @property def build(self): + self.as_list if hasattr(self, "_build"): return self._build return "" From 22e143da0d0ae18d5b3d610900ff7127aaf246c4 Mon Sep 17 00:00:00 2001 From: "Javier G. Sogo" Date: Mon, 24 Sep 2018 11:58:05 +0200 Subject: [PATCH 23/78] Add ConanInvalidConfiguration exception and handle error codes. (#3517) * add exception * test for command line * move exit codes to global scope --- conans/errors.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/conans/errors.py b/conans/errors.py index e5b73a08..2f04de35 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -22,6 +22,9 @@ def conanfile_exception_formatter(conanfile_name, func_name): """ try: yield + except ConanInvalidConfiguration as exc: + msg = "{}: Invalid configuration: {}".format(conanfile_name, exc) # TODO: Move from here? + raise ConanInvalidConfiguration(msg) except Exception as exc: msg = _format_conanfile_exception(conanfile_name, func_name, exc) raise ConanExceptionInUserConanfileMethod(msg) @@ -95,6 +98,10 @@ class ConanExceptionInUserConanfileMethod(ConanException): pass +class ConanInvalidConfiguration(ConanExceptionInUserConanfileMethod): + pass + + # Remote exceptions # class InternalErrorException(ConanException): """ From 524251dd98c3ff85437ee3bdfddec3b60005d5c4 Mon Sep 17 00:00:00 2001 From: Luis Martinez de Bartolome Izquierdo Date: Fri, 15 Feb 2019 16:18:13 +0100 Subject: [PATCH 24/78] v2 refactor (#4512) * WIP * layout of dev * wip * Removed versions * working but not tested * local * Local, package failing because of none timestamp in PREV * WIP * search tests ok * Fixing tests and small refactor * renamed module * review * ISO in client, reviewed * Fixing tests * Fixing tests * New tests about metadata being updated * Review * Time cleared on export/package * Fix revisions list * fixed test * Unused import * WIP * Review * Fixed test message assert * Use env var instead of test client * Cool testing framework and a lot of remove with revisions tests * Remove tests revisions * Drafting tests * Test passing, a lot missing yet * PENDING MANY TESTS * some more tests * Pending many tests * Added more tests * No revisions tests passing * Tests passing, only about 10 to complete * Finished tests * Upload package id not reference * One more test * SVN test * IOError * Fixing tests * Fixing windows test with export package and package revisions * Fixed test * Pending migration * Migration OK * Revisioning the revisions pull request * CONAN_REVISIONS_ENABLED * WIP * Safer migration * No revisions test * V2 WIP * WIP * Review * WIP * Rest routes * Refactor routes * Passing wihout revisions * Removed time from metadata * Passing tests * Fixed more tests * Self review * Imports * Fixed rest api test * Fixed slows * Fixed py2 issue with exception translation with http codes * rest api prepared revisions * Dani and Diego review * Fixing tests * Review * Imports --- conans/errors.py | 56 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) diff --git a/conans/errors.py b/conans/errors.py index 2f04de35..b4677b1c 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -73,8 +73,26 @@ class ConanException(Exception): """ def __init__(self, *args, **kwargs): self.info = None + self.remote = kwargs.pop("remote", None) super(ConanException, self).__init__(*args, **kwargs) + def remote_message(self): + if self.remote: + return " [Remote: {}]".format(self.remote.name) + return "" + + def __str__(self): + from conans.util.files import exception_message_safe + msg = super(ConanException, self).__str__() + if self.remote: + return "{}.{}".format(exception_message_safe(msg), self.remote_message()) + + return exception_message_safe(msg) + + +class NoRestV2Available(ConanException): + pass + class NoRemoteAvailable(ConanException): """ No default remote configured or the specified remote do not exists @@ -135,7 +153,41 @@ class NotFoundException(ConanException): # 404 """ 404 error """ - pass + + def __init__(self, *args, **kwargs): + self.remote = kwargs.pop("remote", None) + super(NotFoundException, self).__init__(*args, **kwargs) + + +class RecipeNotFoundException(NotFoundException): + + def __init__(self, ref, remote=None, print_rev=False): + from conans.model.ref import ConanFileReference + assert isinstance(ref, ConanFileReference), "RecipeNotFoundException requires a " \ + "ConanFileReference" + self.ref = ref + self.print_rev = print_rev + super(RecipeNotFoundException, self).__init__(remote=remote) + + def __str__(self): + tmp = self.ref.full_repr() if self.print_rev else str(self.ref) + return "Recipe not found: '{}'".format(tmp, self.remote_message()) + + +class PackageNotFoundException(NotFoundException): + + def __init__(self, pref, remote=None, print_rev=False): + from conans.model.ref import PackageReference + assert isinstance(pref, PackageReference), "PackageNotFoundException requires a " \ + "PackageReference" + self.pref = pref + self.print_rev = print_rev + + super(PackageNotFoundException, self).__init__(remote=remote) + + def __str__(self): + tmp = self.pref.full_repr() if self.print_rev else str(self.pref) + return "Binary package not found: '{}'%s".format(tmp, self.remote_message()) class UserInterfaceErrorException(RequestErrorException): @@ -150,4 +202,6 @@ class UserInterfaceErrorException(RequestErrorException): AuthenticationException: 401, ForbiddenException: 403, NotFoundException: 404, + RecipeNotFoundException: 404, + PackageNotFoundException: 404, UserInterfaceErrorException: 420} From d8f5b23a292fb62ae2e4bb708fe2becd2613f787 Mon Sep 17 00:00:00 2001 From: "Javier G. Sogo" Date: Mon, 18 Feb 2019 10:46:43 +0100 Subject: [PATCH 25/78] [CLI] Accept a PackageReference in the command 'get' (preferred) (#4494) * allow full pck reference in 'get' command * remove colon at the end of copy command if files are omitted * compare the full line (otherwise the colon could appear without noticing * sort the lines * get_path seems to be a member of package_layout * path is required argument * remove block from finally (let an unhandled exception to propagate) * do not allow package id in the reference and using the argument * argument with show in the help, add deprecation notice * modify argument help message * make tests again * fix typo in #4512 --- conans/errors.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/conans/errors.py b/conans/errors.py index b4677b1c..8333b58b 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -187,7 +187,7 @@ def __init__(self, pref, remote=None, print_rev=False): def __str__(self): tmp = self.pref.full_repr() if self.print_rev else str(self.pref) - return "Binary package not found: '{}'%s".format(tmp, self.remote_message()) + return "Binary package not found: '{}'{}".format(tmp, self.remote_message()) class UserInterfaceErrorException(RequestErrorException): From 1dd75f101c090376b175609fe9ce9861649ccaf7 Mon Sep 17 00:00:00 2001 From: James Date: Tue, 19 Feb 2019 00:15:42 +0100 Subject: [PATCH 26/78] fix develop (#4560) --- conans/errors.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 8333b58b..c18025d7 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -47,7 +47,8 @@ def _format_conanfile_exception(scope, method, exception): content_lines = [] while True: # If out of index will raise and will be captured later - filepath, line, name, contents = traceback.extract_tb(tb, 40)[index] # 40 levels of nested functions max, get the latest + # 40 levels of nested functions max, get the latest + filepath, line, name, contents = traceback.extract_tb(tb, 40)[index] if "conanfile.py" not in filepath: # Avoid show trace from internal conan source code if conanfile_reached: # The error goes to internal code, exit print break @@ -56,11 +57,12 @@ def _format_conanfile_exception(scope, method, exception): msg = "%s: Error in %s() method" % (scope, method) msg += ", line %d\n\t%s" % (line, contents) else: - msg = "while calling '%s', line %d\n\t%s" % (name, line, contents) if line else "\n\t%s" % contents + msg = ("while calling '%s', line %d\n\t%s" % (name, line, contents) + if line else "\n\t%s" % contents) content_lines.append(msg) conanfile_reached = True index += 1 - except: + except Exception: pass ret = "\n".join(content_lines) ret += "\n\t%s: %s" % (exception.__class__.__name__, str(exception)) From ef577a459a0a3e0c766858f13cf14f60ba544c27 Mon Sep 17 00:00:00 2001 From: Luis Martinez de Bartolome Izquierdo Date: Wed, 6 Mar 2019 11:33:13 +0100 Subject: [PATCH 27/78] Fail nicely without revisions and only_v2 (#4663) --- conans/errors.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/conans/errors.py b/conans/errors.py index c18025d7..c630fa0f 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -92,6 +92,15 @@ def __str__(self): return exception_message_safe(msg) +class OnlyV2Available(ConanException): + + def __init__(self, remote_url): + msg = "The remote at '%s' only works with revisions enabled. " \ + "Set CONAN_REVISIONS_ENABLED=1 " \ + "or set 'general.revisions_enabled = 1' at the 'conan.conf'" % remote_url + super(OnlyV2Available, self).__init__(msg) + + class NoRestV2Available(ConanException): pass From 20f770a7d0c62ccc3af69af1fe7ebd97a200bff9 Mon Sep 17 00:00:00 2001 From: "Javier G. Sogo" Date: Sun, 31 Mar 2019 09:31:08 +0200 Subject: [PATCH 28/78] print a message for unknown errors building the API (#4869) --- conans/errors.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/conans/errors.py b/conans/errors.py index c630fa0f..17901c72 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -131,6 +131,10 @@ class ConanInvalidConfiguration(ConanExceptionInUserConanfileMethod): pass +class ConanMigrationError(ConanException): + pass + + # Remote exceptions # class InternalErrorException(ConanException): """ From 0fbc8975bbe278df0ba130b6f26998d21ee16772 Mon Sep 17 00:00:00 2001 From: Daniel Date: Tue, 2 Apr 2019 08:40:41 +0200 Subject: [PATCH 29/78] Some docstrings for version class (#4274) * Added docstrings to version class * Review docstring * Make Version class importable from conans * improved description and more checks * Fix sentence * alias short paths copy test * Removed import * Revert "alias short paths copy test" This reverts commit ce82eb8867bf9198dca8899751b986c17b75f4dd. --- conans/model/version.py | 43 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 39 insertions(+), 4 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index ed9a2af0..015a5f3d 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -2,8 +2,9 @@ class Version(str): - """ This is NOT an implementation of semver, as users may use any pattern in their versions. - It is just a helper to parse .-, and compare taking into account integers when possible + """ + This is NOT an implementation of semver, as users may use any pattern in their versions. + It is just a helper to parse "." or "-" and compare taking into account integers when possible """ version_pattern = re.compile('[.-]') @@ -12,6 +13,10 @@ def __new__(cls, content): @property def as_list(self): + """ + Return version as a list of items + :return: list with version items + """ if not hasattr(self, "_cached_list"): tokens = self.rsplit('+', 1) self._base = tokens[0] @@ -24,6 +29,11 @@ def as_list(self): return self._cached_list def major(self, fill=True): + """ + Get the major item from the version string + :param fill: Fill full version format with major.Y.Z + :return: version class + """ self_list = self.as_list if not isinstance(self_list[0], int): return self._base @@ -33,14 +43,21 @@ def major(self, fill=True): return Version(v) def stable(self): - """ same as major, but as semver, 0.Y.Z is not considered - stable, so return it as is + """ + Get the stable version in a .Y.Z format, otherwise return the version (semver 0.Y.Z + is not considered stable) + :return: version class with .Y.Z as ending """ if self.as_list[0] == 0: return self return self.major() def minor(self, fill=True): + """ + Get the minor item from the version string + :param fill: Fill full version format with major.minor.Z + :return: version class + """ self_list = self.as_list if not isinstance(self_list[0], int): return self._base @@ -51,6 +68,10 @@ def minor(self, fill=True): return Version(".".join([v0, v1])) def patch(self): + """ + Get the patch item from the version string + :return: version class + """ self_list = self.as_list if not isinstance(self_list[0], int): return self._base @@ -73,6 +94,10 @@ def pre(self): @property def build(self): + """ + Return the build item from version string if any + :return: build item string if present, otherwise return an empty string + """ self.as_list if hasattr(self, "_build"): return self._build @@ -80,10 +105,20 @@ def build(self): @property def base(self): + """ + Return the base item from the version string + :return: version class + """ self.as_list return Version(self._base) def compatible(self, other): + """ + Determine if one version is compatible to other regarding to semver. + Useful to check compatibility with major/minor versions with `.Y.Z` format. + :param other: version to compare to (string or version class) + :return: compatible true or false + """ if not isinstance(other, Version): other = Version(other) for v1, v2 in zip(self.as_list, other.as_list): From 8dc9d51dabc4fa13ba1607eed3b53568e9a2304d Mon Sep 17 00:00:00 2001 From: Luis Martinez de Bartolome Izquierdo Date: Fri, 19 Jul 2019 11:01:48 +0200 Subject: [PATCH 30/78] Better ref representation (#5509) * Passing tests * Review --- conans/errors.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 17901c72..bf8686cb 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -185,7 +185,7 @@ def __init__(self, ref, remote=None, print_rev=False): super(RecipeNotFoundException, self).__init__(remote=remote) def __str__(self): - tmp = self.ref.full_repr() if self.print_rev else str(self.ref) + tmp = repr(self.ref) if self.print_rev else str(self.ref) return "Recipe not found: '{}'".format(tmp, self.remote_message()) @@ -201,7 +201,7 @@ def __init__(self, pref, remote=None, print_rev=False): super(PackageNotFoundException, self).__init__(remote=remote) def __str__(self): - tmp = self.pref.full_repr() if self.print_rev else str(self.pref) + tmp = self.pref.full_str() if self.print_rev else str(self.pref) return "Binary package not found: '{}'{}".format(tmp, self.remote_message()) From 9d9f5cdf8ffe1ce304e6a56944ae9acbca44960c Mon Sep 17 00:00:00 2001 From: Luis Martinez de Bartolome Izquierdo Date: Wed, 24 Jul 2019 11:00:54 +0200 Subject: [PATCH 31/78] Optional user/channel (#5381) * all failing * Simplifying * WIP * Making progress * wip * Not bad * Fix cmp * none * Reverted tests changes * some good test failing * Some tests still failing but not bad * WIP * Passing tests * Using None * Simplifying diff * Review * Less changes * Some improvements * Simplifying more * dead code * Simplified more * More * And more * Add test for requires * Cleaning the house * Fixing tests * Simplify search code * simplified remove * Review * Added test not user channel in conaninfo * Fixed test regression 1.17.1 * Recovered line --- conans/errors.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/conans/errors.py b/conans/errors.py index bf8686cb..f7ae1e68 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -185,7 +185,7 @@ def __init__(self, ref, remote=None, print_rev=False): super(RecipeNotFoundException, self).__init__(remote=remote) def __str__(self): - tmp = repr(self.ref) if self.print_rev else str(self.ref) + tmp = self.ref.full_str() if self.print_rev else str(self.ref) return "Recipe not found: '{}'".format(tmp, self.remote_message()) From df259428f72f3945896766bab7c971e499f1f5fd Mon Sep 17 00:00:00 2001 From: Luis Martinez de Bartolome Izquierdo Date: Mon, 29 Jul 2019 15:46:13 +0200 Subject: [PATCH 32/78] Fix print stderr on failure at `check_output` tool. (#5548) * Print stderr * Use output, stderr is not py27 --- conans/errors.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/conans/errors.py b/conans/errors.py index f7ae1e68..994842b5 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -9,8 +9,18 @@ """ from contextlib import contextmanager +from subprocess import CalledProcessError from conans.util.env_reader import get_env +from conans.util.files import decode_text + + +class CalledProcessErrorWithStderr(CalledProcessError): + def __str__(self): + ret = super(CalledProcessErrorWithStderr, self).__str__() + if self.output: + ret += "\n" + decode_text(self.output) + return ret @contextmanager From 9d5161dfee8a163f5078f992f48fefbf75a5d3d1 Mon Sep 17 00:00:00 2001 From: Luis Martinez de Bartolome Izquierdo Date: Tue, 15 Oct 2019 10:02:56 +0200 Subject: [PATCH 33/78] Requirement override using build metadata (#5903) --- conans/model/version.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/conans/model/version.py b/conans/model/version.py index 015a5f3d..96370274 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -143,7 +143,12 @@ def get_el(a_list, index): equals = all(get_el(other.as_list, ind) == get_el(self.as_list, ind) for ind in range(0, max(len(other.as_list), len(self.as_list)))) if equals: - return 0 + if self.build == other.build: + return 0 + if self.build > other.build: + return -1 + else: + return 1 # Check greater than or less than other_list = other.as_list From 5f7d7b2982972b8b695eddb601bbd5d6c8f94ee4 Mon Sep 17 00:00:00 2001 From: James Date: Wed, 4 Mar 2020 22:40:19 +0100 Subject: [PATCH 34/78] Add 'CONAN_V2_MODE' to start testing Conan v2 deprecated features (#6490) * example of testing for Conan v2 compatibility mode * if provided the v1_fallback, just pass the 'msg' * revisions_enabled by default * default for v2 is revisions_enabled=1 * only set revisions value if explicit (user input over environment) * use 'revisions_enabled' branch from CI repo * basic config tests * create folder if not exists * function not available in older pythons * use new ABI for gcc * check the conf * need to know a value * pass the branch name * use the new ABI only if available * branch is used for the python code too * settings are different for Conan v2 * behavior is different: if the settings are inherited from previous versions * reorder imports * wait for xbuilding to be merged, it will deprecate some bits * using 'master' it should work the same way * revert deprecateds for xbuild (wait until new feature is merged) * we need different branch from CI * warn for old python_requires * default_options required to be a dictionary * cppflags is deprecated * use config from the Config object * deprecate legacy windows tools * start with conanfile items * capture deprecation warning * reraise only ConanV2Exception * remove dead code * show deprecation warning (v2 will raise) for self.settings/options in source() * 'info' access in 'self.package()' * protect self.cpp_info in package_id() * deprecate config * new line in win * warn profile loader with 'scopes' * use master branch * Update conans/client/conf/__init__.py Co-Authored-By: Carlos Zoido * review * conan_v2_property is noop for V1 Co-authored-by: Carlos Zoido --- conans/errors.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/conans/errors.py b/conans/errors.py index 994842b5..7df260b8 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -102,6 +102,13 @@ def __str__(self): return exception_message_safe(msg) +class ConanV2Exception(ConanException): + def __str__(self): + msg = super(ConanV2Exception, self).__str__() + # TODO: Add a link to a public webpage with Conan roadmap to v2 + return "Conan v2 incompatible: {}".format(msg) + + class OnlyV2Available(ConanException): def __init__(self, remote_url): From 7ec660e0212fa1dc4db166c542f245afd663d619 Mon Sep 17 00:00:00 2001 From: Carlos Zoido Date: Tue, 2 Feb 2021 10:11:50 +0100 Subject: [PATCH 35/78] Remove disabled_revisions mode from 2.0: Remove support api v1 (#8412) * remove apiv1 * remove OnlyV2Available * change error message * add revisions cap * change test to test incompatible v1 * add caps * ignore capabilities * revert changes * remove test * revert changes * wip * fix test * add revisions * add rrev * update rest tests * clean * update for revs * minor changes * remove test --- conans/errors.py | 9 --------- 1 file changed, 9 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 7df260b8..30d3938f 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -109,15 +109,6 @@ def __str__(self): return "Conan v2 incompatible: {}".format(msg) -class OnlyV2Available(ConanException): - - def __init__(self, remote_url): - msg = "The remote at '%s' only works with revisions enabled. " \ - "Set CONAN_REVISIONS_ENABLED=1 " \ - "or set 'general.revisions_enabled = 1' at the 'conan.conf'" % remote_url - super(OnlyV2Available, self).__init__(msg) - - class NoRestV2Available(ConanException): pass From 01a0e0e1fd03b31c713e7e2a0250c4407b8a4b2e Mon Sep 17 00:00:00 2001 From: Carlos Zoido Date: Fri, 5 Feb 2021 11:45:58 +0100 Subject: [PATCH 36/78] Remove disabled_revisions mode from 2.0: Clean enabled_revisions (#8428) * remove property * remove from graphlock * wip * wip * wip * raise if not revisions cap * add rev cap * fix tests * fix test * wip * wip * wip * fix test * remove unused * wip * wip * wip * wip * wip * remove more DEFAULT_REVISION_V1 * remove more DEFAULT_REVISION_V1 * assert rev * fix test * not needed test * fix test --- conans/errors.py | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 30d3938f..9e0eb8d6 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -109,10 +109,6 @@ def __str__(self): return "Conan v2 incompatible: {}".format(msg) -class NoRestV2Available(ConanException): - pass - - class NoRemoteAvailable(ConanException): """ No default remote configured or the specified remote do not exists """ @@ -184,32 +180,30 @@ def __init__(self, *args, **kwargs): class RecipeNotFoundException(NotFoundException): - def __init__(self, ref, remote=None, print_rev=False): + def __init__(self, ref, remote=None): from conans.model.ref import ConanFileReference assert isinstance(ref, ConanFileReference), "RecipeNotFoundException requires a " \ "ConanFileReference" self.ref = ref - self.print_rev = print_rev super(RecipeNotFoundException, self).__init__(remote=remote) def __str__(self): - tmp = self.ref.full_str() if self.print_rev else str(self.ref) + tmp = self.ref.full_str() return "Recipe not found: '{}'".format(tmp, self.remote_message()) class PackageNotFoundException(NotFoundException): - def __init__(self, pref, remote=None, print_rev=False): + def __init__(self, pref, remote=None): from conans.model.ref import PackageReference assert isinstance(pref, PackageReference), "PackageNotFoundException requires a " \ "PackageReference" self.pref = pref - self.print_rev = print_rev super(PackageNotFoundException, self).__init__(remote=remote) def __str__(self): - tmp = self.pref.full_str() if self.print_rev else str(self.pref) + tmp = self.pref.full_str() return "Binary package not found: '{}'{}".format(tmp, self.remote_message()) From 1720db1e808bc399a21ca0af1df83d6ac58f49d2 Mon Sep 17 00:00:00 2001 From: James Date: Wed, 21 Jul 2021 12:48:41 +0200 Subject: [PATCH 37/78] Introducing ConanErrorConfiguration exception (#9268) * Add test cases for build require invalid configuration * rename file and add more cases * update tests * fix pacakge id for compatible packages tests * trying new exception * proposal * add test * fix test * wip * wip * wip * wip * wip * fix tests Co-authored-by: danimtb --- conans/errors.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/conans/errors.py b/conans/errors.py index 9e0eb8d6..6e17d34d 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -132,6 +132,16 @@ class ConanExceptionInUserConanfileMethod(ConanException): class ConanInvalidConfiguration(ConanExceptionInUserConanfileMethod): + """ + This binary, for the requested configuration and package-id cannot be built + """ + pass + + +class ConanErrorConfiguration(ConanExceptionInUserConanfileMethod): + """ + The binary might exist, and have a valid package-id, but can't be used with current config + """ pass From 90a509772c14c324ec7ad00e0f118ae743c5c2d0 Mon Sep 17 00:00:00 2001 From: Carlos Zoido Date: Mon, 30 Aug 2021 13:38:03 +0200 Subject: [PATCH 38/78] Implement --update flows for revisions in conan cache 2.0 (#9191) * add first test * wip * wip * wip * wip * wip * remove test * xfail * wip * update test * wip * remove unused arg * fix duplicated * remove unused * fix call * wip * wip * fix tests * wip * wip * fix ordering * fix get results * update test * wip * xfail * minor changes * WIP * update test * wip * fix set timestamp * wip * wip * add RECIPE_DATE_UPDATED * minor changes * wip * minor changes * update test * remove old metadata * wip * fix tests * remove test * fix method * wip * update tests * minor changes * add message * add rev to list_ref * update tests * wip * update tests * fix tests * update tests * update test * update test * update test * minor changes * fix tests * add make-latest argument * fix tests * remove comments * un-xfail * add arg * minor refactor * refactor * use timestamps better * wip * wip * minor changes * minor changes * try to fix test * remove make-latest * update flow * simplify db use with autocommit * remove unused * change output message * hide date conversion * add fixme * fix times * fix times * fix message * update flows * fix test * update test * add note * wip * fix resolve ranges check range in remote * --update implementation with version ranges * update tests * update tests * fix resolve ranges check range in remote * --update implementation with version ranges * fix resolution when cached * update tests * minor changes * minor changes * improve caching * add all remotes to cache, consider update * remove import * minor changes * fix dict * add test * minor changes * add get_latest_recipe_revision_with_time * simplify code * remove select remote * remove message * fix test * remove redundant * change method name * fix exception name * fix name * move try except to cache * fix typo * remove old comment * take correct remote from recipe * fix remote assignment * xfail test * fix test Co-authored-by: James --- conans/errors.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/conans/errors.py b/conans/errors.py index 6e17d34d..96c0c28e 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -102,6 +102,16 @@ def __str__(self): return exception_message_safe(msg) +class ConanReferenceDoesNotExistInDB(ConanException): + """ Reference does not exist in cache db """ + pass + + +class ConanReferenceAlreadyExistsInDB(ConanException): + """ Reference already exists in cache db """ + pass + + class ConanV2Exception(ConanException): def __str__(self): msg = super(ConanV2Exception, self).__str__() From 8730046b23e4134ec87c119b7eb50dd5ddf099eb Mon Sep 17 00:00:00 2001 From: Carlos Zoido Date: Fri, 15 Oct 2021 18:45:51 +0200 Subject: [PATCH 39/78] Remove CppInfo and update to NewCppInfo (#9657) * update msbuilddeps * remove DepCppInfo * remove import * fix path * remove from cmakedeps * update env * use new cpp_info * fix import * wip * wip * wip * wip * remove var * add layout * wip * wip * remove rootpathh * wip * wip * wip * revert changes * wip * wip * change logic of editables * wip * update test * wip * wip * wip * wip * wip * modify editables layout test * wip * minor changes * revert * wip * wip * add set_defaults * back to prev behavior * wip * wip * wip * update test * revert changes * may fix test * update tests * wip * wip * wip * xfail cmake file api test * update name * wip * wip * wip * update tests * add error modify uninitialized * fix raise * wip * minor changes * return cpp.package * wip * wip * change module name * wip * remove test * update test * update test to new behaviour * wip * wip * use properties for Nones * wip * fix vars * fix test * revert append changes * revert changes * remove unused imports * remove unwanted changes * add objects * fixing broken tests Co-authored-by: memsharded --- conans/errors.py | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 96c0c28e..66c26f7b 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -30,14 +30,27 @@ def conanfile_exception_formatter(conanfile_name, func_name): :param reference: Reference of the conanfile :return: """ + + def _raise_conanfile_exc(exc): + msg = _format_conanfile_exception(conanfile_name, func_name, exc) + raise ConanExceptionInUserConanfileMethod(msg) + try: yield except ConanInvalidConfiguration as exc: msg = "{}: Invalid configuration: {}".format(conanfile_name, exc) # TODO: Move from here? raise ConanInvalidConfiguration(msg) + except AttributeError as exc: + list_methods = [m for m in dir(list) if not m.startswith('__')] + if "NoneType" in str(exc) and func_name in ['layout', 'package_info'] and \ + any(method in str(exc) for method in list_methods): + raise ConanException("{}: {}. No default values are set for components. You are probably " + "trying to manipulate a component attribute in the '{}' method " + "without defining it previously".format(conanfile_name, exc, func_name)) + else: + _raise_conanfile_exc(exc) except Exception as exc: - msg = _format_conanfile_exception(conanfile_name, func_name, exc) - raise ConanExceptionInUserConanfileMethod(msg) + _raise_conanfile_exc(exc) def _format_conanfile_exception(scope, method, exception): From 77c20f765ef3929d714648a732ebd8ff68c4e145 Mon Sep 17 00:00:00 2001 From: n-bes Date: Tue, 2 Nov 2021 10:39:48 +0300 Subject: [PATCH 40/78] Add return code 7 (Invalid system requirements) (#9905) * Respect error code 6 with wrong environment * add 'ERROR_INVALID_SYSTEM_REQUIREMENTS' return code * add 'ConanInvalidSystemRequirements' exception * handle 'ConanInvalidSystemRequirements' exception * raise 'ConanInvalidSystemRequirements' instead of 'ConanInvalidConfiguration' * init 'InvalidSystemRequirementsTest' * test create method on raise 'ConanInvalidSystemRequirements' --- conans/errors.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/conans/errors.py b/conans/errors.py index 7df260b8..9a07b128 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -32,8 +32,12 @@ def conanfile_exception_formatter(conanfile_name, func_name): """ try: yield + # TODO: Move ConanInvalidSystemRequirements, ConanInvalidConfiguration from here? + except ConanInvalidSystemRequirements as exc: + msg = "{}: Invalid system requirements: {}".format(conanfile_name, exc) + raise ConanInvalidSystemRequirements(msg) except ConanInvalidConfiguration as exc: - msg = "{}: Invalid configuration: {}".format(conanfile_name, exc) # TODO: Move from here? + msg = "{}: Invalid configuration: {}".format(conanfile_name, exc) raise ConanInvalidConfiguration(msg) except Exception as exc: msg = _format_conanfile_exception(conanfile_name, func_name, exc) @@ -144,6 +148,10 @@ class ConanExceptionInUserConanfileMethod(ConanException): pass +class ConanInvalidSystemRequirements(ConanException): + pass + + class ConanInvalidConfiguration(ConanExceptionInUserConanfileMethod): pass From 553c652ed6a10b4fbd4bdee5762adf778db9c35d Mon Sep 17 00:00:00 2001 From: James Date: Wed, 3 Nov 2021 15:55:48 +0100 Subject: [PATCH 41/78] removing python 2 legacy (#9927) * removing python 2 legacy * fix test * fix test --- conans/model/version.py | 1 + 1 file changed, 1 insertion(+) diff --git a/conans/model/version.py b/conans/model/version.py index 96370274..899ca3ea 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -187,6 +187,7 @@ def __eq__(self, other): return self.__cmp__(other) == 0 def __ne__(self, other): + # This one CANNOT BE REMOVED without breaking return not self.__eq__(other) def __hash__(self): From f5555f81c7c04101e025a680c66b0b2da9e8a906 Mon Sep 17 00:00:00 2001 From: Luis Martinez Date: Wed, 3 Nov 2021 16:27:30 +0100 Subject: [PATCH 42/78] Removed PackageReference in favor of PkgReference (#9933) * little tests passing * Fixing stuff * Removed dead code and enabled comparisson of PkgReferences * Fixed hash * Simplified hash * review --- conans/errors.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index aba1d651..a926b686 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -236,15 +236,15 @@ def __str__(self): class PackageNotFoundException(NotFoundException): def __init__(self, pref, remote=None): - from conans.model.ref import PackageReference - assert isinstance(pref, PackageReference), "PackageNotFoundException requires a " \ - "PackageReference" + from conans.model.package_ref import PkgReference + assert isinstance(pref, PkgReference), "PackageNotFoundException requires a " \ + "PkgReference" self.pref = pref super(PackageNotFoundException, self).__init__(remote=remote) def __str__(self): - tmp = self.pref.full_str() + tmp = repr(self.pref) return "Binary package not found: '{}'{}".format(tmp, self.remote_message()) From 4a81db5c670f838c302bcb6ed028f8c64300db90 Mon Sep 17 00:00:00 2001 From: James Date: Wed, 3 Nov 2021 18:47:20 +0100 Subject: [PATCH 43/78] some new Version improvements for build and pre-releases (#9930) --- .../test/unittests/model/version/__init__.py | 0 .../model/version/test_version_comparison.py | 42 +++++++++++++++++++ 2 files changed, 42 insertions(+) create mode 100644 conans/test/unittests/model/version/__init__.py create mode 100644 conans/test/unittests/model/version/test_version_comparison.py diff --git a/conans/test/unittests/model/version/__init__.py b/conans/test/unittests/model/version/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/conans/test/unittests/model/version/test_version_comparison.py b/conans/test/unittests/model/version/test_version_comparison.py new file mode 100644 index 00000000..538e9f05 --- /dev/null +++ b/conans/test/unittests/model/version/test_version_comparison.py @@ -0,0 +1,42 @@ +import pytest + +from conans.model.recipe_ref import Version + +v = [("1", "2"), + ("1.0", "1.1"), + ("1.1", "1.1.0"), # generic 1.1 is earlier than 1.1.0 + ("1.0.2", "1.1.0"), + ("1.3", "1.22"), + ("1.1.3", "1.1.22"), + ("1.1.1.3", "1.1.1.22"), + ("1.1.1.1.3", "1.1.1.1.22"), + # Different lengths + ("1.0", "2"), + ("1.2", "1.3.1"), + ("1.0.2", "1.1"), + # Now with letters + ("1.1.a", "1.1.b"), + ("1.1.1.abc", "1.1.1.abz"), + ("a.b.c", "b.c"), + # build is easy + ("1.1+b1", "1.1+b2"), + ("1.1+b.3", "1.1+b.22"), + # pre-release is challenging + ("1.1-pre1", "1.1-pre2"), + ("1.1-alpha.3", "1.1-alpha.22"), + ("1.1-alpha.3+b1", "1.1-alpha.3+b2"), + ("1.1-alpha.1", "1.1"), + ("1.1", "1.2-alpha1"), + ("1.1-alpha.1", "1.1.0"), # pre to the generic 1.1 is earlier than 1.1.0 + ] + + +@pytest.mark.parametrize("v1, v2", v) +def test_comparison(v1, v2): + v1 = Version(v1) + v2 = Version(v2) + assert v1 < v2 + assert v2 > v1 + assert v1 != v2 + assert v1 <= v2 + assert v2 >= v1 From c769b3aef5a3e22b417e717715c09984dc2a780c Mon Sep 17 00:00:00 2001 From: Luis Martinez Date: Mon, 8 Nov 2021 17:05:31 +0100 Subject: [PATCH 44/78] RecipeReference + Interfaces renaming and improving (#9982) * little tests passing * Fixing stuff * Removed dead code and enabled comparisson of PkgReferences * Fixed hash * Simplified hash * review * wip * Broken list because of the remote manager returning only references * monkey job * some tests still failing * Fix couple issues with version * Integration passing * Unittests * repr_notime * Fix linux test, missing import --- conans/errors.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index a926b686..248d4480 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -8,6 +8,7 @@ see return_plugin.py """ +import copy from contextlib import contextmanager from subprocess import CalledProcessError @@ -222,14 +223,14 @@ def __init__(self, *args, **kwargs): class RecipeNotFoundException(NotFoundException): def __init__(self, ref, remote=None): - from conans.model.ref import ConanFileReference - assert isinstance(ref, ConanFileReference), "RecipeNotFoundException requires a " \ - "ConanFileReference" + from conans.model.recipe_ref import RecipeReference + assert isinstance(ref, RecipeReference), "RecipeNotFoundException requires a " \ + "RecipeReference" self.ref = ref super(RecipeNotFoundException, self).__init__(remote=remote) def __str__(self): - tmp = self.ref.full_str() + tmp = repr(self.ref) return "Recipe not found: '{}'".format(tmp, self.remote_message()) @@ -244,8 +245,8 @@ def __init__(self, pref, remote=None): super(PackageNotFoundException, self).__init__(remote=remote) def __str__(self): - tmp = repr(self.pref) - return "Binary package not found: '{}'{}".format(tmp, self.remote_message()) + return "Binary package not found: '{}'{}".format(self.pref.repr_notime(), + self.remote_message()) class UserInterfaceErrorException(RequestErrorException): From 1edbc9c7f8e0dd13a957b1518814ff67b8242940 Mon Sep 17 00:00:00 2001 From: James Date: Mon, 15 Nov 2021 18:23:09 +0100 Subject: [PATCH 45/78] Remove legacy activation of environment (#10007) * wip * wip * wip * wip * fix test * wip * wip * removed tools.get_env * restored env_reader.py name to reduce diff * restored environment_append * wip * wip * wip * wip * wip * wip * wip * wip * wip * wip * fix win * added gzip compresslevel * Update conans/cli/api/subapi/__init__.py Co-authored-by: Luis Martinez Co-authored-by: Luis Martinez --- conans/errors.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/conans/errors.py b/conans/errors.py index 248d4480..7a20e99b 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -12,7 +12,7 @@ from contextlib import contextmanager from subprocess import CalledProcessError -from conans.util.env_reader import get_env +from conans.util.env import get_env from conans.util.files import decode_text From 83d76db6e9ae9b83fab99ef0e975f330afb23eaf Mon Sep 17 00:00:00 2001 From: James Date: Tue, 16 Nov 2021 14:42:55 +0100 Subject: [PATCH 46/78] introducing new version_range model (#9970) * introducing new version_range * added tilde and caret * Update conans/model/recipe_ref.py Co-authored-by: Luis Martinez * Update conans/model/recipe_ref.py Co-authored-by: Luis Martinez * Remove legacy activation of environment (#10007) * wip * wip * wip * wip * fix test * wip * wip * removed tools.get_env * restored env_reader.py name to reduce diff * restored environment_append * wip * wip * wip * wip * wip * wip * wip * wip * wip * wip * fix win * added gzip compresslevel * Update conans/cli/api/subapi/__init__.py Co-authored-by: Luis Martinez Co-authored-by: Luis Martinez * Improved: Search + List API and [list+search] commands (#10014) * All broken, trying to desing better API in list/search to be used in other commands like remove and upload * Keep remove to later * Still working on search and list API * Testing apis * Passing tests * small fixes * references back to list and moved get configurations to list * Feature/develop2 all lowercase (#9985) * wip * wip * wip * fixing tests * wip * wip * fix tets * fix tests * remove virtual-envs auto-use (#10011) * remove circular imports * removing dead new -t files (#10003) * merged upstream Co-authored-by: Luis Martinez --- conans/model/version_range.py | 61 +++++++++++++++++++ .../model/version/test_version_bump.py | 18 ++++++ .../model/version/test_version_range.py | 39 ++++++++++++ 3 files changed, 118 insertions(+) create mode 100644 conans/model/version_range.py create mode 100644 conans/test/unittests/model/version/test_version_bump.py create mode 100644 conans/test/unittests/model/version/test_version_range.py diff --git a/conans/model/version_range.py b/conans/model/version_range.py new file mode 100644 index 00000000..13592ad0 --- /dev/null +++ b/conans/model/version_range.py @@ -0,0 +1,61 @@ +from collections import namedtuple + +from conans.errors import ConanException +from conans.model.recipe_ref import Version + + +_Condition = namedtuple("_Condition", ["operator", "version"]) + + +def _parse_expression(expression): + operator = expression[0] + if operator not in (">", "<", "^", "~"): + raise ConanException(f"Invalid version range {expression}") + index = 1 + if operator in (">", "<"): + if expression[1] == "=": + operator += "=" + index = 2 + version = expression[index:] + if operator == "~": # tilde minor + v = Version(version) + return [_Condition(">=", v), _Condition("<", v.bump(1))] + elif operator == "^": # caret major + v = Version(version) + + def first_non_zero(main): + for i, m in enumerate(main): + if m != 0: + return i + return len(main) + + initial_index = first_non_zero(v.main) + return [_Condition(">=", v), _Condition("<", v.bump(initial_index))] + else: + return [_Condition(operator, Version(version))] + + +class VersionRange: + def __init__(self, expression): + self._expression = expression + expressions = expression.split() + self.conditions = [] + for expression in expressions: + self.conditions.extend(_parse_expression(expression)) + + def __contains__(self, version): + assert isinstance(version, Version) + for condition in self.conditions: + if condition.operator == ">": + if not version > condition.version: + return False + elif condition.operator == "<": + if not version < condition.version: + return False + elif condition.operator == ">=": + if not version >= condition.version: + return False + elif condition.operator == "<=": + if not version <= condition.version: + return False + return True diff --git a/conans/test/unittests/model/version/test_version_bump.py b/conans/test/unittests/model/version/test_version_bump.py new file mode 100644 index 00000000..43b2e7cd --- /dev/null +++ b/conans/test/unittests/model/version/test_version_bump.py @@ -0,0 +1,18 @@ +import pytest + +from conans.model.recipe_ref import Version + +values = [ + ['1.0.0', 0, "2.0.0"], + ['1.1.0', 0, "2.0.0"], + ['1.1.1-pre', 0, "2.0.0"], + ['1.1.1', 1, "1.2.0"], + ['1.1.1', 2, "1.1.2"], +] + + +@pytest.mark.parametrize("version, index, result", values) +def test_version_bump(version, index, result): + r = Version(version) + bumped = r.bump(index) + assert bumped == result diff --git a/conans/test/unittests/model/version/test_version_range.py b/conans/test/unittests/model/version/test_version_range.py new file mode 100644 index 00000000..7bf9dcab --- /dev/null +++ b/conans/test/unittests/model/version/test_version_range.py @@ -0,0 +1,39 @@ +import pytest + +from conans.errors import ConanException +from conans.model.recipe_ref import Version +from conans.model.version_range import VersionRange + +values = [ + ['>1.0.0', [['>', '1.0.0']], ["1.0.1"], ["0.1"]], + ['<2.0', [['<', '2.0']], ["1.0.1"], ["2.1"]], + ['>1 <2.0', [['>', '1'], ['<', '2.0']], ["1.5.1"], ["0.1", "2.1"]], + ['~2.5', [['>=', '2.5'], ['<', '2.6']], ["2.5.0", "2.5.3"], ["2.7", "2.6.1"]], + ['~2.5.1', [['>=', '2.5.1'], ['<', '2.6.0']], ["2.5.1", "2.5.3"], ["2.5", "2.6.1"]], + ['^1.2', [['>=', '1.2'], ['<', '2.0']], ["1.2.1", "1.51"], ["1", "2.1", "2.0.1"]], + ['^0.1.2', [['>=', '0.1.2'], ['<', '0.2.0']], ["0.1.3", "0.1.44"], ["1", "0.3", "0.2.1"]], +] + + +@pytest.mark.parametrize("version_range, conditions, versions_in, versions_out", values) +def test_range(version_range, conditions, versions_in, versions_out): + r = VersionRange(version_range) + for result, expected in zip(r.conditions, conditions): + assert result.operator == expected[0] + assert result.version == expected[1] + + for v in versions_in: + assert Version(v) in r + + for v in versions_out: + assert Version(v) not in r + + +invalid = ["1.2", "-2.0", "?2.1"] + + +@pytest.mark.parametrize("version_range", invalid) +def test_invalid_range(version_range): + with pytest.raises(ConanException) as e: + VersionRange(version_range) + assert "Invalid version range" in str(e.value) From f5fd9e64aefbbaf7cb71151a0ab8d12b5aed7b48 Mon Sep 17 00:00:00 2001 From: James Date: Thu, 18 Nov 2021 14:05:12 +0100 Subject: [PATCH 47/78] fixing version equality (#10036) * fixing version equality * fix tests * fix tests with 0.0 * more fixes --- .../model/version/test_version_comparison.py | 29 ++++++++++++++++++- .../model/version/test_version_range.py | 3 +- 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/conans/test/unittests/model/version/test_version_comparison.py b/conans/test/unittests/model/version/test_version_comparison.py index 538e9f05..9f79101e 100644 --- a/conans/test/unittests/model/version/test_version_comparison.py +++ b/conans/test/unittests/model/version/test_version_comparison.py @@ -4,7 +4,6 @@ v = [("1", "2"), ("1.0", "1.1"), - ("1.1", "1.1.0"), # generic 1.1 is earlier than 1.1.0 ("1.0.2", "1.1.0"), ("1.3", "1.22"), ("1.1.3", "1.1.22"), @@ -20,6 +19,8 @@ ("a.b.c", "b.c"), # build is easy ("1.1+b1", "1.1+b2"), + ("1.1", "1.1+b2"), + ("1.1+b1", "1.2"), ("1.1+b.3", "1.1+b.22"), # pre-release is challenging ("1.1-pre1", "1.1-pre2"), @@ -40,3 +41,29 @@ def test_comparison(v1, v2): assert v1 != v2 assert v1 <= v2 assert v2 >= v1 + + +e = [("1", "1.0"), + ("1", "1.0.0"), + ("1.0", "1.0.0"), + ("1.0", "1.0.0.0"), + ("1-pre1", "1.0-pre1"), + ("1-pre1", "1.0.0-pre1"), + ("1.0-pre1", "1.0.0-pre1"), + ("1.0-pre1.0", "1.0.0-pre1"), + ("1-pre1+b1", "1.0-pre1+b1"), + ("1-pre1+b1", "1.0.0-pre1+b1"), + ("1.0-pre1+b1", "1.0.0-pre1+b1"), + ("1+b1", "1.0+b1"), + ("1+b1", "1.0+b1.0"), + ("1+b1", "1.0.0+b1"), + ("1.0+b1", "1.0.0+b1"), + ] + + +@pytest.mark.parametrize("v1, v2", e) +def test_equality(v1, v2): + v1 = Version(v1) + v2 = Version(v2) + assert v1 == v2 + assert not v1 != v2 diff --git a/conans/test/unittests/model/version/test_version_range.py b/conans/test/unittests/model/version/test_version_range.py index 7bf9dcab..fe6566d1 100644 --- a/conans/test/unittests/model/version/test_version_range.py +++ b/conans/test/unittests/model/version/test_version_range.py @@ -10,7 +10,8 @@ ['>1 <2.0', [['>', '1'], ['<', '2.0']], ["1.5.1"], ["0.1", "2.1"]], ['~2.5', [['>=', '2.5'], ['<', '2.6']], ["2.5.0", "2.5.3"], ["2.7", "2.6.1"]], ['~2.5.1', [['>=', '2.5.1'], ['<', '2.6.0']], ["2.5.1", "2.5.3"], ["2.5", "2.6.1"]], - ['^1.2', [['>=', '1.2'], ['<', '2.0']], ["1.2.1", "1.51"], ["1", "2.1", "2.0.1"]], + ['^1.2', [['>=', '1.2'], ['<', '2.0']], ["1.2.1", "1.51"], ["1", "2", "2.1", "2.0.1"]], + ['^1.2.3', [['>=', '1.2.3'], ["<", '2.0.0']], ["1.2.3", "1.2.4"], ["2", "2.1", "2.0.1"]], ['^0.1.2', [['>=', '0.1.2'], ['<', '0.2.0']], ["0.1.3", "0.1.44"], ["1", "0.3", "0.2.1"]], ] From 3c9c947a3d1f139c448c143c5109d8d7a4eb1a90 Mon Sep 17 00:00:00 2001 From: James Date: Fri, 19 Nov 2021 15:47:03 +0100 Subject: [PATCH 48/78] Fixing some comparisons in new Version model (#10051) * wip * new version fixes --- .../model/version/test_version_comparison.py | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/conans/test/unittests/model/version/test_version_comparison.py b/conans/test/unittests/model/version/test_version_comparison.py index 9f79101e..12341147 100644 --- a/conans/test/unittests/model/version/test_version_comparison.py +++ b/conans/test/unittests/model/version/test_version_comparison.py @@ -17,6 +17,15 @@ ("1.1.a", "1.1.b"), ("1.1.1.abc", "1.1.1.abz"), ("a.b.c", "b.c"), + ("1.1", "1.a"), + ("1.1", "1.1a"), + ("1.1", "1.1.a"), + ("1.1.a", "1.2"), + # Arterisk are before digits + ("1.1*", "1.20"), + ("1.1.*", "1.20"), + ("1.2.2", "1.3.*"), + ("1.2.2", "1.2.3*"), # build is easy ("1.1+b1", "1.1+b2"), ("1.1", "1.1+b2"), @@ -67,3 +76,24 @@ def test_equality(v1, v2): v2 = Version(v2) assert v1 == v2 assert not v1 != v2 + + +def test_elem_comparison(): + v1 = Version("1.2.3b.4-pre.1.2b+build.1.1b") + major = v1.major + assert major < 2 + assert major < "2" + assert major == 1 + assert major != 3 + assert major > 0 + assert str(major) == "1" + patch = v1.patch + assert patch < 4 + assert patch > 2 + assert patch < "3c" + assert patch > "3a" + assert patch == "3b" + micro = v1.micro + assert micro > 3 + assert micro < 5 + assert micro == 4 From 523433fe73a933029a6c39102c75cc48ab5f4c87 Mon Sep 17 00:00:00 2001 From: James Date: Mon, 22 Nov 2021 22:41:32 +0100 Subject: [PATCH 49/78] remove legacy Version classes, use new one (#10052) * remove legacy versions * fixing detect * Update conans/client/tools/oss.py Co-authored-by: Anonymous Maarten * Update conans/client/tools/oss.py Co-authored-by: Anonymous Maarten * Update conans/client/tools/oss.py Co-authored-by: Anonymous Maarten * fix test * remove tools.Version * added = identity range * added conditions sets with OR operations and * * fix tilde with 1 elem * review Co-authored-by: Anonymous Maarten --- conans/model/version.py | 323 +++++++++--------- conans/model/version_range.py | 92 +++-- .../model/version/test_version_range.py | 47 +-- 3 files changed, 237 insertions(+), 225 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index 899ca3ea..da2a78c5 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -1,194 +1,181 @@ -import re +from functools import total_ordering +from conans.errors import ConanException -class Version(str): - """ - This is NOT an implementation of semver, as users may use any pattern in their versions. - It is just a helper to parse "." or "-" and compare taking into account integers when possible - """ - version_pattern = re.compile('[.-]') - def __new__(cls, content): - return str.__new__(cls, content.strip()) +@total_ordering +class _VersionItem: + """ a single "digit" in a version, like X.Y.Z all X and Y and Z are VersionItems + They can be int or strings + """ + def __init__(self, item): + try: + self._v = int(item) + except ValueError: + self._v = item @property - def as_list(self): - """ - Return version as a list of items - :return: list with version items - """ - if not hasattr(self, "_cached_list"): - tokens = self.rsplit('+', 1) - self._base = tokens[0] - if len(tokens) == 2: - self._build = tokens[1] - self._cached_list = [] - tokens = Version.version_pattern.split(tokens[0]) - for item in tokens: - self._cached_list.append(int(item) if item.isdigit() else item) - return self._cached_list - - def major(self, fill=True): - """ - Get the major item from the version string - :param fill: Fill full version format with major.Y.Z - :return: version class - """ - self_list = self.as_list - if not isinstance(self_list[0], int): - return self._base - v = str(self_list[0]) if self_list else "0" - if fill: - return Version(".".join([v, 'Y', 'Z'])) - return Version(v) - - def stable(self): - """ - Get the stable version in a .Y.Z format, otherwise return the version (semver 0.Y.Z - is not considered stable) - :return: version class with .Y.Z as ending - """ - if self.as_list[0] == 0: - return self - return self.major() + def value(self): + return self._v - def minor(self, fill=True): - """ - Get the minor item from the version string - :param fill: Fill full version format with major.minor.Z - :return: version class - """ - self_list = self.as_list - if not isinstance(self_list[0], int): - return self._base - v0 = str(self_list[0]) if len(self_list) > 0 else "0" - v1 = str(self_list[1]) if len(self_list) > 1 else "0" - if fill: - return Version(".".join([v0, v1, 'Z'])) - return Version(".".join([v0, v1])) + def __str__(self): + return str(self._v) - def patch(self): + def __add__(self, other): + # necessary for the "bump()" functionality. Other aritmetic operations are missing + return self._v + other + + def __eq__(self, other): + if not isinstance(other, _VersionItem): + other = _VersionItem(other) + return self._v == other._v + + def __hash__(self): + return hash(self._v) + + def __lt__(self, other): """ - Get the patch item from the version string - :return: version class + @type other: _VersionItem """ - self_list = self.as_list - if not isinstance(self_list[0], int): - return self._base - v0 = str(self_list[0]) if len(self_list) > 0 else "0" - v1 = str(self_list[1]) if len(self_list) > 1 else "0" - v2 = str(self_list[2]) if len(self_list) > 2 else "0" - return Version(".".join([v0, v1, v2])) + if not isinstance(other, _VersionItem): + other = _VersionItem(other) + try: + return self._v < other._v + except TypeError: + return str(self._v) < str(other._v) + +@total_ordering +class Version: + """ + This is NOT an implementation of semver, as users may use any pattern in their versions. + It is just a helper to parse "." or "-" and compare taking into account integers when possible + """ + def __init__(self, value): + assert isinstance(value, str) + self._value = value + + items = value.rsplit("+", 1) # split for build + if len(items) == 2: + value, build = items + self._build = Version(build) # This is a nested version by itself + else: + value = items[0] + self._build = None + + items = value.rsplit("-", 1) # split for pre-release + if len(items) == 2: + value, pre = items + self._pre = Version(pre) # This is a nested version by itself + else: + value = items[0] + self._pre = None + items = value.split(".") + items = [_VersionItem(item) for item in items] + self._items = tuple(items) + while items and items[-1].value == 0: + del items[-1] + self._nonzero_items = tuple(items) + + def bump(self, index): + """ + Increments by 1 the version field at the specified index, setting to 0 the fields + on the right. + 2.5 => bump(1) => 2.6 + 1.5.7 => bump(0) => 2.0.0 + """ + # this method is used to compute version ranges from tilde ~1.2 and caret ^1.2.1 ranges + # TODO: at this moment it only works for digits, cannot increment pre-release or builds + # better not make it public yet, keep it internal + items = list(self._items[:index]) + try: + items.append(self._items[index]+1) + except TypeError: + raise ConanException(f"Cannot bump '{self._value} version index {index}, not an int") + items.extend([0] * (len(items) - index - 1)) + v = ".".join(str(i) for i in items) + # prerelease and build are dropped while bumping digits + result = Version(v) + return result + + @property def pre(self): - self_list = self.as_list - if not isinstance(self_list[0], int): - return self._base - v0 = str(self_list[0]) if len(self_list) > 0 else "0" - v1 = str(self_list[1]) if len(self_list) > 1 else "0" - v2 = str(self_list[2]) if len(self_list) > 2 else "0" - v = ".".join([v0, v1, v2]) - if len(self_list) > 3: - v += "-%s" % self_list[3] - return Version(v) + return self._pre @property def build(self): - """ - Return the build item from version string if any - :return: build item string if present, otherwise return an empty string - """ - self.as_list - if hasattr(self, "_build"): - return self._build - return "" + return self._build @property - def base(self): - """ - Return the base item from the version string - :return: version class - """ - self.as_list - return Version(self._base) + def main(self): + return self._items - def compatible(self, other): - """ - Determine if one version is compatible to other regarding to semver. - Useful to check compatibility with major/minor versions with `.Y.Z` format. - :param other: version to compare to (string or version class) - :return: compatible true or false - """ - if not isinstance(other, Version): - other = Version(other) - for v1, v2 in zip(self.as_list, other.as_list): - if v1 in ["X", "Y", "Z"] or v2 in ["X", "Y", "Z"]: - return True - if v1 != v2: - return False - return True - - def __cmp__(self, other): - if other is None: - return 1 - if not isinstance(other, Version): - other = Version(other) + @property + def major(self): + try: + return self.main[0] + except IndexError: + return None - # Check equals - def get_el(a_list, index): - if len(a_list) - 1 < index: - return 0 # out of range, 4 == 4.0 == 4.0.0 - return a_list[index] - - equals = all(get_el(other.as_list, ind) == get_el(self.as_list, ind) - for ind in range(0, max(len(other.as_list), len(self.as_list)))) - if equals: - if self.build == other.build: - return 0 - if self.build > other.build: - return -1 - else: - return 1 - - # Check greater than or less than - other_list = other.as_list - for ind, el in enumerate(self.as_list): - if ind + 1 > len(other_list): - if isinstance(el, int): - return 1 - return -1 - if not isinstance(el, int) and isinstance(other_list[ind], int): - # Version compare with 1.4.rc2 - return -1 - elif not isinstance(other_list[ind], int) and isinstance(el, int): - return 1 - elif el == other_list[ind]: - continue - elif el > other_list[ind]: - return 1 - else: - return -1 - if len(other_list) > len(self.as_list): - return -1 - - def __gt__(self, other): - return self.__cmp__(other) == 1 + @property + def minor(self): + try: + return self.main[1] + except IndexError: + return None - def __lt__(self, other): - return self.__cmp__(other) == -1 + @property + def patch(self): + try: + return self.main[2] + except IndexError: + return None + + @property + def micro(self): + try: + return self.main[3] + except IndexError: + return None - def __le__(self, other): - return self.__cmp__(other) in [0, -1] + def __str__(self): + return self._value - def __ge__(self, other): - return self.__cmp__(other) in [0, 1] + def __repr__(self): + return self._value def __eq__(self, other): - return self.__cmp__(other) == 0 + if other is None: + return False + if not isinstance(other, Version): + other = Version(other) - def __ne__(self, other): - # This one CANNOT BE REMOVED without breaking - return not self.__eq__(other) + return (self._nonzero_items, self._pre, self._build) ==\ + (other._nonzero_items, other._pre, other._build) def __hash__(self): - return str.__hash__(self) + return hash((self._nonzero_items, self._pre, self._build)) + + def __lt__(self, other): + if other is None: + return False + if not isinstance(other, Version): + other = Version(other) + + if self._pre: + if other._pre: # both are pre-releases + return (self._nonzero_items, self._pre, self._build) < \ + (other._nonzero_items, other._pre, other._build) + else: # Left hand is pre-release, right side is regular + if self._nonzero_items == other._nonzero_items: # Problem only happens if both equal + return True + else: + return self._nonzero_items < other._nonzero_items + else: + if other._pre: # Left hand is regular, right side is pre-release + if self._nonzero_items == other._nonzero_items: # Problem only happens if both equal + return False + else: + return self._nonzero_items < other._nonzero_items + else: # None of them is pre-release + return (self._nonzero_items, self._build) < (other._nonzero_items, other._build) diff --git a/conans/model/version_range.py b/conans/model/version_range.py index 13592ad0..854f8dcc 100644 --- a/conans/model/version_range.py +++ b/conans/model/version_range.py @@ -1,50 +1,54 @@ from collections import namedtuple -from conans.errors import ConanException from conans.model.recipe_ref import Version _Condition = namedtuple("_Condition", ["operator", "version"]) -def _parse_expression(expression): - operator = expression[0] - if operator not in (">", "<", "^", "~"): - raise ConanException(f"Invalid version range {expression}") - index = 1 - if operator in (">", "<"): - if expression[1] == "=": - operator += "=" - index = 2 - version = expression[index:] - if operator == "~": # tilde minor - v = Version(version) - return [_Condition(">=", v), _Condition("<", v.bump(1))] - elif operator == "^": # caret major - v = Version(version) - - def first_non_zero(main): - for i, m in enumerate(main): - if m != 0: - return i - return len(main) - - initial_index = first_non_zero(v.main) - return [_Condition(">=", v), _Condition("<", v.bump(initial_index))] - else: - return [_Condition(operator, Version(version))] - - -class VersionRange: +class _ConditionSet: def __init__(self, expression): - self._expression = expression expressions = expression.split() self.conditions = [] - for expression in expressions: - self.conditions.extend(_parse_expression(expression)) + for e in expressions: + self.conditions.extend(self._parse_expression(e)) - def __contains__(self, version): - assert isinstance(version, Version) + @staticmethod + def _parse_expression(expression): + expression = expression.strip() + if expression == "" or expression == "*": + return [_Condition(">=", Version("0.0.0"))] + + operator = expression[0] + if operator not in (">", "<", "^", "~", "="): + operator = "=" + index = 0 + else: + index = 1 + if operator in (">", "<"): + if expression[1] == "=": + operator += "=" + index = 2 + version = expression[index:] + if operator == "~": # tilde minor + v = Version(version) + index = 1 if len(v.main) > 1 else 0 + return [_Condition(">=", v), _Condition("<", v.bump(index))] + elif operator == "^": # caret major + v = Version(version) + + def first_non_zero(main): + for i, m in enumerate(main): + if m != 0: + return i + return len(main) + + initial_index = first_non_zero(v.main) + return [_Condition(">=", v), _Condition("<", v.bump(initial_index))] + else: + return [_Condition(operator, Version(version))] + + def valid(self, version): for condition in self.conditions: if condition.operator == ">": if not version > condition.version: @@ -58,4 +62,22 @@ def __contains__(self, version): elif condition.operator == "<=": if not version <= condition.version: return False + elif condition.operator == "=": + if not version == condition.version: + return False return True + + +class VersionRange: + def __init__(self, expression): + self._expression = expression + self.condition_sets = [] + for alternative in expression.split("||"): + self.condition_sets.append(_ConditionSet(alternative)) + + def __contains__(self, version): + assert isinstance(version, Version), type(version) + for condition_set in self.condition_sets: + if condition_set.valid(version): + return True + return False diff --git a/conans/test/unittests/model/version/test_version_range.py b/conans/test/unittests/model/version/test_version_range.py index fe6566d1..4fef0920 100644 --- a/conans/test/unittests/model/version/test_version_range.py +++ b/conans/test/unittests/model/version/test_version_range.py @@ -1,40 +1,43 @@ import pytest -from conans.errors import ConanException from conans.model.recipe_ref import Version from conans.model.version_range import VersionRange values = [ - ['>1.0.0', [['>', '1.0.0']], ["1.0.1"], ["0.1"]], - ['<2.0', [['<', '2.0']], ["1.0.1"], ["2.1"]], - ['>1 <2.0', [['>', '1'], ['<', '2.0']], ["1.5.1"], ["0.1", "2.1"]], - ['~2.5', [['>=', '2.5'], ['<', '2.6']], ["2.5.0", "2.5.3"], ["2.7", "2.6.1"]], - ['~2.5.1', [['>=', '2.5.1'], ['<', '2.6.0']], ["2.5.1", "2.5.3"], ["2.5", "2.6.1"]], - ['^1.2', [['>=', '1.2'], ['<', '2.0']], ["1.2.1", "1.51"], ["1", "2", "2.1", "2.0.1"]], - ['^1.2.3', [['>=', '1.2.3'], ["<", '2.0.0']], ["1.2.3", "1.2.4"], ["2", "2.1", "2.0.1"]], - ['^0.1.2', [['>=', '0.1.2'], ['<', '0.2.0']], ["0.1.3", "0.1.44"], ["1", "0.3", "0.2.1"]], + ['>1.0.0', [[['>', '1.0.0']]], ["1.0.1"], ["0.1"]], + ['<2.0', [[['<', '2.0']]], ["1.0.1"], ["2.1"]], + ['>1 <2.0', [[['>', '1'], ['<', '2.0']]], ["1.5.1"], ["0.1", "2.1"]], + # tilde + ['~2.5', [[['>=', '2.5'], ['<', '2.6']]], ["2.5.0", "2.5.3"], ["2.7", "2.6.1"]], + ['~2.5.1', [[['>=', '2.5.1'], ['<', '2.6.0']]], ["2.5.1", "2.5.3"], ["2.5", "2.6.1"]], + ['~1', [[['>=', '1'], ['<', '2']]], ["1.3", "1.8.1"], ["0.8", "2.2"]], + # caret + ['^1.2', [[['>=', '1.2'], ['<', '2.0']]], ["1.2.1", "1.51"], ["1", "2", "2.1", "2.0.1"]], + ['^1.2.3', [[['>=', '1.2.3'], ["<", '2.0.0']]], ["1.2.3", "1.2.4"], ["2", "2.1", "2.0.1"]], + ['^0.1.2', [[['>=', '0.1.2'], ['<', '0.2.0']]], ["0.1.3", "0.1.44"], ["1", "0.3", "0.2.1"]], + # Identity + ['1.0.0', [[["=", "1.0.0"]]], ["1.0.0"], ["2", "1.0.1"]], + ['=1.0.0', [[["=", "1.0.0"]]], ["1.0.0"], ["2", "1.0.1"]], + # Any + ['*', [[[">=", "0.0.0"]]], ["1.0", "a.b"], []], + ['', [[[">=", "0.0.0"]]], ["1.0", "a.b"], []], + # Unions + ['1.0.0 || 2.1.3', [[["=", "1.0.0"]], [["=", "2.1.3"]]], ["1.0.0", "2.1.3"], ["2", "1.0.1"]], + ['>1 <2.0 || ^3.2 ', [[['>', '1'], ['<', '2.0']], + [['>=', '3.2'], ['<', '4.0']]], ["1.5", "3.3"], ["2.1", "0.1", "5"]], ] @pytest.mark.parametrize("version_range, conditions, versions_in, versions_out", values) def test_range(version_range, conditions, versions_in, versions_out): r = VersionRange(version_range) - for result, expected in zip(r.conditions, conditions): - assert result.operator == expected[0] - assert result.version == expected[1] + for condition_set, expected_condition_set in zip(r.condition_sets, conditions): + for condition, expected_condition in zip(condition_set.conditions, expected_condition_set): + assert condition.operator == expected_condition[0] + assert condition.version == expected_condition[1] for v in versions_in: assert Version(v) in r for v in versions_out: assert Version(v) not in r - - -invalid = ["1.2", "-2.0", "?2.1"] - - -@pytest.mark.parametrize("version_range", invalid) -def test_invalid_range(version_range): - with pytest.raises(ConanException) as e: - VersionRange(version_range) - assert "Invalid version range" in str(e.value) From 6a778d3071fe8d82cb5dfa98ee5243e5747dd26e Mon Sep 17 00:00:00 2001 From: James Date: Thu, 25 Nov 2021 14:14:33 +0100 Subject: [PATCH 50/78] [develop2] remove dep to node-semver (#10058) * remove legacy versions * fixing detect * Update conans/client/tools/oss.py Co-authored-by: Anonymous Maarten * Update conans/client/tools/oss.py Co-authored-by: Anonymous Maarten * Update conans/client/tools/oss.py Co-authored-by: Anonymous Maarten * fix test * remove tools.Version * wip * wip * added = identity range * added conditions sets with OR operations and * * wip * fix tilde with 1 elem * wip * wip * review * added pre-releases * fix conan_required_version include_prelease Co-authored-by: Anonymous Maarten --- conans/model/version_range.py | 26 ++++++++++++++++--- .../model/version/test_version_range.py | 9 ++++++- 2 files changed, 30 insertions(+), 5 deletions(-) diff --git a/conans/model/version_range.py b/conans/model/version_range.py index 854f8dcc..8050965d 100644 --- a/conans/model/version_range.py +++ b/conans/model/version_range.py @@ -7,15 +7,20 @@ class _ConditionSet: - def __init__(self, expression): + + def __init__(self, expression, prerelease): expressions = expression.split() + self.prerelease = prerelease self.conditions = [] for e in expressions: + e = e.strip() + if e[-1] == "-": # Include pre-releases + e = e[:-1] + self.prerelease = True self.conditions.extend(self._parse_expression(e)) @staticmethod def _parse_expression(expression): - expression = expression.strip() if expression == "" or expression == "*": return [_Condition(">=", Version("0.0.0"))] @@ -49,6 +54,9 @@ def first_non_zero(main): return [_Condition(operator, Version(version))] def valid(self, version): + if version.pre: + if not self.prerelease: + return False for condition in self.conditions: if condition.operator == ">": if not version > condition.version: @@ -71,9 +79,19 @@ def valid(self, version): class VersionRange: def __init__(self, expression): self._expression = expression + tokens = expression.split(",") + prereleases = None + for t in tokens[1:]: + if "include_prerelease" in t: + prereleases = True + break + version_expr = tokens[0] self.condition_sets = [] - for alternative in expression.split("||"): - self.condition_sets.append(_ConditionSet(alternative)) + for alternative in version_expr.split("||"): + self.condition_sets.append(_ConditionSet(alternative, prereleases)) + + def __str__(self): + return self._expression def __contains__(self, version): assert isinstance(version, Version), type(version) diff --git a/conans/test/unittests/model/version/test_version_range.py b/conans/test/unittests/model/version/test_version_range.py index 4fef0920..4fe7a3b3 100644 --- a/conans/test/unittests/model/version/test_version_range.py +++ b/conans/test/unittests/model/version/test_version_range.py @@ -12,7 +12,7 @@ ['~2.5.1', [[['>=', '2.5.1'], ['<', '2.6.0']]], ["2.5.1", "2.5.3"], ["2.5", "2.6.1"]], ['~1', [[['>=', '1'], ['<', '2']]], ["1.3", "1.8.1"], ["0.8", "2.2"]], # caret - ['^1.2', [[['>=', '1.2'], ['<', '2.0']]], ["1.2.1", "1.51"], ["1", "2", "2.1", "2.0.1"]], + ['^1.2', [[['>=', '1.2'], ['<', '2.0']]], ["1.2.1", "1.51"], ["1", "2", "2.0.1"]], ['^1.2.3', [[['>=', '1.2.3'], ["<", '2.0.0']]], ["1.2.3", "1.2.4"], ["2", "2.1", "2.0.1"]], ['^0.1.2', [[['>=', '0.1.2'], ['<', '0.2.0']]], ["0.1.3", "0.1.44"], ["1", "0.3", "0.2.1"]], # Identity @@ -25,6 +25,13 @@ ['1.0.0 || 2.1.3', [[["=", "1.0.0"]], [["=", "2.1.3"]]], ["1.0.0", "2.1.3"], ["2", "1.0.1"]], ['>1 <2.0 || ^3.2 ', [[['>', '1'], ['<', '2.0']], [['>=', '3.2'], ['<', '4.0']]], ["1.5", "3.3"], ["2.1", "0.1", "5"]], + # pre-releases + ['', [[[">=", "0.0.0"]]], ["1.0"], ["1.0-pre.1"]], + ['*, include_prerelease=True', [[[">=", "0.0.0"]]], ["1.0", "1.0-pre.1"], []], + ['*-', [[[">=", "0.0.0"]]], ["1.0", "1.0-pre.1"], []], + ['>1- <2.0', [[['>', '1'], ['<', '2.0']]], ["1.5.1-pre1"], ["2.1-pre1"]], + ['>1- <2.0 || ^3.2 ', [[['>', '1'], ['<', '2.0']], + [['>=', '3.2'], ['<', '4.0']]], ["1.5-a1", "3.3"], ["3.3-a1"]], ] From eef8bf30cb293f9279c0ca52c85c9e2ca1187bac Mon Sep 17 00:00:00 2001 From: James Date: Tue, 7 Dec 2021 12:44:55 +0100 Subject: [PATCH 51/78] minor cleanings and refactors (#10135) * minor cleanings and refactors * fix server paths * fix tests * fix tests --- conans/errors.py | 24 +++++++----------------- 1 file changed, 7 insertions(+), 17 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 7a20e99b..e282d87d 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -1,5 +1,5 @@ """ - Exceptions raised and handled in Conan server. + Exceptions raised and handled in Conan These exceptions are mapped between server (as an HTTP response) and client through the REST API. When an error happens in server its translated to an HTTP error code that its sent to client. Client reads the server code and raise the @@ -8,7 +8,6 @@ see return_plugin.py """ -import copy from contextlib import contextmanager from subprocess import CalledProcessError @@ -28,22 +27,20 @@ def __str__(self): def conanfile_exception_formatter(conanfile_name, func_name): """ Decorator to throw an exception formatted with the line of the conanfile where the error ocurrs. - :param reference: Reference of the conanfile - :return: """ - def _raise_conanfile_exc(exc): - msg = _format_conanfile_exception(conanfile_name, func_name, exc) - raise ConanExceptionInUserConanfileMethod(msg) + def _raise_conanfile_exc(e): + m = _format_conanfile_exception(conanfile_name, func_name, e) + raise ConanExceptionInUserConanfileMethod(m) try: yield # TODO: Move ConanInvalidSystemRequirements, ConanInvalidConfiguration from here? except ConanInvalidSystemRequirements as exc: - msg = "{}: Invalid system requirements: {}".format(conanfile_name, exc) + msg = "{}: Invalid system requirements: {}".format(str(conanfile_name), exc) raise ConanInvalidSystemRequirements(msg) except ConanInvalidConfiguration as exc: - msg = "{}: Invalid configuration: {}".format(conanfile_name, exc) + msg = "{}: Invalid configuration: {}".format(str(conanfile_name), exc) raise ConanInvalidConfiguration(msg) except AttributeError as exc: list_methods = [m for m in dir(list) if not m.startswith('__')] @@ -51,7 +48,7 @@ def _raise_conanfile_exc(exc): any(method in str(exc) for method in list_methods): raise ConanException("{}: {}. No default values are set for components. You are probably " "trying to manipulate a component attribute in the '{}' method " - "without defining it previously".format(conanfile_name, exc, func_name)) + "without defining it previously".format(str(conanfile_name), exc, func_name)) else: _raise_conanfile_exc(exc) except Exception as exc: @@ -130,13 +127,6 @@ class ConanReferenceAlreadyExistsInDB(ConanException): pass -class ConanV2Exception(ConanException): - def __str__(self): - msg = super(ConanV2Exception, self).__str__() - # TODO: Add a link to a public webpage with Conan roadmap to v2 - return "Conan v2 incompatible: {}".format(msg) - - class NoRemoteAvailable(ConanException): """ No default remote configured or the specified remote do not exists """ From 5a44eec190214fdde07e5c7ebfedb0e2571b63bf Mon Sep 17 00:00:00 2001 From: James Date: Thu, 9 Dec 2021 13:00:28 +0100 Subject: [PATCH 52/78] fix version ranges pre-releases (#10149) --- conans/model/version.py | 12 ++++++++++++ conans/model/version_range.py | 4 ++-- .../model/version/test_version_comparison.py | 3 ++- .../model/version/test_version_range.py | 17 +++++++++-------- 4 files changed, 25 insertions(+), 11 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index da2a78c5..4150ec31 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -98,6 +98,18 @@ def bump(self, index): result = Version(v) return result + def upper_bound(self, index): + items = list(self._items[:index]) + try: + items.append(self._items[index] + 1) + except TypeError: + raise ConanException(f"Cannot bump '{self._value} version index {index}, not an int") + items.extend([0] * (len(items) - index - 1)) + v = ".".join(str(i) for i in items) + v += "-" # Exclude prereleases + result = Version(v) + return result + @property def pre(self): return self._pre diff --git a/conans/model/version_range.py b/conans/model/version_range.py index 8050965d..b0076d7b 100644 --- a/conans/model/version_range.py +++ b/conans/model/version_range.py @@ -38,7 +38,7 @@ def _parse_expression(expression): if operator == "~": # tilde minor v = Version(version) index = 1 if len(v.main) > 1 else 0 - return [_Condition(">=", v), _Condition("<", v.bump(index))] + return [_Condition(">=", v), _Condition("<", v.upper_bound(index))] elif operator == "^": # caret major v = Version(version) @@ -49,7 +49,7 @@ def first_non_zero(main): return len(main) initial_index = first_non_zero(v.main) - return [_Condition(">=", v), _Condition("<", v.bump(initial_index))] + return [_Condition(">=", v), _Condition("<", v.upper_bound(initial_index))] else: return [_Condition(operator, Version(version))] diff --git a/conans/test/unittests/model/version/test_version_comparison.py b/conans/test/unittests/model/version/test_version_comparison.py index 12341147..96d18138 100644 --- a/conans/test/unittests/model/version/test_version_comparison.py +++ b/conans/test/unittests/model/version/test_version_comparison.py @@ -38,7 +38,8 @@ ("1.1-alpha.1", "1.1"), ("1.1", "1.2-alpha1"), ("1.1-alpha.1", "1.1.0"), # pre to the generic 1.1 is earlier than 1.1.0 - ] + ("1.0.0-", "1.0.0-alpha1") +] @pytest.mark.parametrize("v1, v2", v) diff --git a/conans/test/unittests/model/version/test_version_range.py b/conans/test/unittests/model/version/test_version_range.py index 4fe7a3b3..ea2c5cfb 100644 --- a/conans/test/unittests/model/version/test_version_range.py +++ b/conans/test/unittests/model/version/test_version_range.py @@ -8,13 +8,13 @@ ['<2.0', [[['<', '2.0']]], ["1.0.1"], ["2.1"]], ['>1 <2.0', [[['>', '1'], ['<', '2.0']]], ["1.5.1"], ["0.1", "2.1"]], # tilde - ['~2.5', [[['>=', '2.5'], ['<', '2.6']]], ["2.5.0", "2.5.3"], ["2.7", "2.6.1"]], - ['~2.5.1', [[['>=', '2.5.1'], ['<', '2.6.0']]], ["2.5.1", "2.5.3"], ["2.5", "2.6.1"]], - ['~1', [[['>=', '1'], ['<', '2']]], ["1.3", "1.8.1"], ["0.8", "2.2"]], + ['~2.5', [[['>=', '2.5'], ['<', '2.6-']]], ["2.5.0", "2.5.3"], ["2.7", "2.6.1"]], + ['~2.5.1', [[['>=', '2.5.1'], ['<', '2.6.0-']]], ["2.5.1", "2.5.3"], ["2.5", "2.6.1"]], + ['~1', [[['>=', '1'], ['<', '2-']]], ["1.3", "1.8.1"], ["0.8", "2.2"]], # caret - ['^1.2', [[['>=', '1.2'], ['<', '2.0']]], ["1.2.1", "1.51"], ["1", "2", "2.0.1"]], - ['^1.2.3', [[['>=', '1.2.3'], ["<", '2.0.0']]], ["1.2.3", "1.2.4"], ["2", "2.1", "2.0.1"]], - ['^0.1.2', [[['>=', '0.1.2'], ['<', '0.2.0']]], ["0.1.3", "0.1.44"], ["1", "0.3", "0.2.1"]], + ['^1.2', [[['>=', '1.2'], ['<', '2.0-']]], ["1.2.1", "1.51"], ["1", "2", "2.0.1"]], + ['^1.2.3', [[['>=', '1.2.3'], ["<", '2.0.0-']]], ["1.2.3", "1.2.4"], ["2", "2.1", "2.0.1"]], + ['^0.1.2', [[['>=', '0.1.2'], ['<', '0.2.0-']]], ["0.1.3", "0.1.44"], ["1", "0.3", "0.2.1"]], # Identity ['1.0.0', [[["=", "1.0.0"]]], ["1.0.0"], ["2", "1.0.1"]], ['=1.0.0', [[["=", "1.0.0"]]], ["1.0.0"], ["2", "1.0.1"]], @@ -24,14 +24,15 @@ # Unions ['1.0.0 || 2.1.3', [[["=", "1.0.0"]], [["=", "2.1.3"]]], ["1.0.0", "2.1.3"], ["2", "1.0.1"]], ['>1 <2.0 || ^3.2 ', [[['>', '1'], ['<', '2.0']], - [['>=', '3.2'], ['<', '4.0']]], ["1.5", "3.3"], ["2.1", "0.1", "5"]], + [['>=', '3.2'], ['<', '4.0-']]], ["1.5", "3.3"], ["2.1", "0.1", "5"]], # pre-releases ['', [[[">=", "0.0.0"]]], ["1.0"], ["1.0-pre.1"]], ['*, include_prerelease=True', [[[">=", "0.0.0"]]], ["1.0", "1.0-pre.1"], []], ['*-', [[[">=", "0.0.0"]]], ["1.0", "1.0-pre.1"], []], ['>1- <2.0', [[['>', '1'], ['<', '2.0']]], ["1.5.1-pre1"], ["2.1-pre1"]], ['>1- <2.0 || ^3.2 ', [[['>', '1'], ['<', '2.0']], - [['>=', '3.2'], ['<', '4.0']]], ["1.5-a1", "3.3"], ["3.3-a1"]], + [['>=', '3.2'], ['<', '4.0-']]], ["1.5-a1", "3.3"], ["3.3-a1"]], + ['^1.1.2-', [[['>=', '1.1.2'], ['<', '2.0.0-']]], ["1.2.3", "1.2.0-alpha1"], ["2.0.0-alpha1"]], ] From 6edc7d866473dd76580e9f1ee0592b81f15ff661 Mon Sep 17 00:00:00 2001 From: James Date: Thu, 9 Dec 2021 14:29:18 +0100 Subject: [PATCH 53/78] checking tilde with prerelease excluded too (#10151) --- conans/test/unittests/model/version/test_version_range.py | 1 + 1 file changed, 1 insertion(+) diff --git a/conans/test/unittests/model/version/test_version_range.py b/conans/test/unittests/model/version/test_version_range.py index ea2c5cfb..419d0f8e 100644 --- a/conans/test/unittests/model/version/test_version_range.py +++ b/conans/test/unittests/model/version/test_version_range.py @@ -33,6 +33,7 @@ ['>1- <2.0 || ^3.2 ', [[['>', '1'], ['<', '2.0']], [['>=', '3.2'], ['<', '4.0-']]], ["1.5-a1", "3.3"], ["3.3-a1"]], ['^1.1.2-', [[['>=', '1.1.2'], ['<', '2.0.0-']]], ["1.2.3", "1.2.0-alpha1"], ["2.0.0-alpha1"]], + ['~1.1.2-', [[['>=', '1.1.2'], ['<', '1.2.0-']]], ["1.1.3", "1.1.3-alpha1"], ["1.2.0-alpha1"]], ] From e25124351f4948f9b8c0a9f022512c74c9508eb4 Mon Sep 17 00:00:00 2001 From: James Date: Mon, 20 Dec 2021 23:56:59 +0100 Subject: [PATCH 54/78] moving _compilers to tools.build.flags and other minor cleanings (#10163) * moving _compilers to tools.build.flags and other minor cleanings * fix tests * fixed tests --- conans/model/version.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index 4150ec31..d9e211d3 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -51,7 +51,7 @@ class Version: This is NOT an implementation of semver, as users may use any pattern in their versions. It is just a helper to parse "." or "-" and compare taking into account integers when possible """ - def __init__(self, value): + def __init__(self, value: str): assert isinstance(value, str) self._value = value @@ -159,7 +159,7 @@ def __repr__(self): def __eq__(self, other): if other is None: return False - if not isinstance(other, Version): + if isinstance(other, str): other = Version(other) return (self._nonzero_items, self._pre, self._build) ==\ From 4c7f417d8d3d3d425d6487335a8ba6dae13990b3 Mon Sep 17 00:00:00 2001 From: James Date: Thu, 17 Feb 2022 08:21:15 +0100 Subject: [PATCH 55/78] [develop2] minor refactors and cleaning BinaryInstaller (#10577) * refactoring installer * other minor refactors * add system_requuirements to editable * more cleaning --- conans/errors.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index e282d87d..eb27910b 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -214,8 +214,7 @@ class RecipeNotFoundException(NotFoundException): def __init__(self, ref, remote=None): from conans.model.recipe_ref import RecipeReference - assert isinstance(ref, RecipeReference), "RecipeNotFoundException requires a " \ - "RecipeReference" + assert isinstance(ref, RecipeReference), "RecipeNotFoundException requires a RecipeReference" self.ref = ref super(RecipeNotFoundException, self).__init__(remote=remote) @@ -228,8 +227,7 @@ class PackageNotFoundException(NotFoundException): def __init__(self, pref, remote=None): from conans.model.package_ref import PkgReference - assert isinstance(pref, PkgReference), "PackageNotFoundException requires a " \ - "PkgReference" + assert isinstance(pref, PkgReference), "PackageNotFoundException requires a PkgReference" self.pref = pref super(PackageNotFoundException, self).__init__(remote=remote) From 5719b0f607828dcfab9cdb37fcf8a8eed4e2b921 Mon Sep 17 00:00:00 2001 From: James Date: Mon, 21 Mar 2022 16:56:54 +0100 Subject: [PATCH 56/78] remove conanfile attrs improvements (#10844) --- conans/errors.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/conans/errors.py b/conans/errors.py index eb27910b..f44e8a4f 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -23,6 +23,28 @@ def __str__(self): return ret +@contextmanager +def conanfile_remove_attr(conanfile, names, method): + """ remove some self.xxxx attribute from the class, so it raises an exception if used + within a given conanfile method + """ + original_class = type(conanfile) + + def _prop(attr_name): + def _m(_): + raise ConanException(f"'self.{attr_name}' access in '{method}()' method is forbidden") + return property(_m) + + try: + new_class = type(original_class.__name__, (original_class, ), {}) + conanfile.__class__ = new_class + for name in names: + setattr(new_class, name, _prop(name)) + yield + finally: + conanfile.__class__ = original_class + + @contextmanager def conanfile_exception_formatter(conanfile_name, func_name): """ From d49a589b9d34b6fd809844085f07e142af07218b Mon Sep 17 00:00:00 2001 From: James Date: Fri, 29 Apr 2022 01:38:52 +0200 Subject: [PATCH 57/78] fix tools.scm.Version construction from non-str (#11119) --- conans/model/version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/conans/model/version.py b/conans/model/version.py index 96370274..af6df5c7 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -9,7 +9,7 @@ class Version(str): version_pattern = re.compile('[.-]') def __new__(cls, content): - return str.__new__(cls, content.strip()) + return str.__new__(cls, str(content).strip()) @property def as_list(self): From b61525b4924211c580ea43ae6e8fee1af696a4ad Mon Sep 17 00:00:00 2001 From: James Date: Mon, 9 May 2022 10:14:06 +0200 Subject: [PATCH 58/78] removed CalledProcessError exception (#11195) --- conans/errors.py | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index f44e8a4f..84559ab0 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -9,18 +9,8 @@ """ from contextlib import contextmanager -from subprocess import CalledProcessError from conans.util.env import get_env -from conans.util.files import decode_text - - -class CalledProcessErrorWithStderr(CalledProcessError): - def __str__(self): - ret = super(CalledProcessErrorWithStderr, self).__str__() - if self.output: - ret += "\n" + decode_text(self.output) - return ret @contextmanager From 28d17d3c33142c2c02c95cdf5f2f6101903f847d Mon Sep 17 00:00:00 2001 From: James Date: Fri, 18 Nov 2022 12:35:03 +0100 Subject: [PATCH 59/78] [develop2] Try to revert ``check_min_cppstd`` to use ``self.settings`` instead of ``self.info.settings`` (#12555) * wip * removing ConanErrorConfiguration * fix tests --- conans/errors.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 84559ab0..f6b413dc 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -172,13 +172,6 @@ class ConanInvalidConfiguration(ConanExceptionInUserConanfileMethod): pass -class ConanErrorConfiguration(ConanExceptionInUserConanfileMethod): - """ - The binary might exist, and have a valid package-id, but can't be used with current config - """ - pass - - class ConanMigrationError(ConanException): pass From b02d90289b5d1bbfd7ac5aeb0fe0c1e78d0331f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rub=C3=A9n=20Rinc=C3=B3n=20Blanco?= Date: Mon, 12 Dec 2022 22:53:06 +0100 Subject: [PATCH 60/78] Add better error UX when spaces are found in required_conan_version (#12695) * Add better error UX when spaces in required_conan_version * Fix typo * Fix import --- conans/model/version_range.py | 3 +++ conans/test/unittests/model/version/test_version_range.py | 6 ++++++ 2 files changed, 9 insertions(+) diff --git a/conans/model/version_range.py b/conans/model/version_range.py index b0076d7b..1bdadbe7 100644 --- a/conans/model/version_range.py +++ b/conans/model/version_range.py @@ -1,5 +1,6 @@ from collections import namedtuple +from conans.errors import ConanException from conans.model.recipe_ref import Version @@ -35,6 +36,8 @@ def _parse_expression(expression): operator += "=" index = 2 version = expression[index:] + if version == "": + raise ConanException(f"Error parsing version range {expression}") if operator == "~": # tilde minor v = Version(version) index = 1 if len(v.main) > 1 else 0 diff --git a/conans/test/unittests/model/version/test_version_range.py b/conans/test/unittests/model/version/test_version_range.py index 419d0f8e..fb41eeb0 100644 --- a/conans/test/unittests/model/version/test_version_range.py +++ b/conans/test/unittests/model/version/test_version_range.py @@ -1,5 +1,6 @@ import pytest +from conans.errors import ConanException from conans.model.recipe_ref import Version from conans.model.version_range import VersionRange @@ -50,3 +51,8 @@ def test_range(version_range, conditions, versions_in, versions_out): for v in versions_out: assert Version(v) not in r + +def test_wrong_range_syntax(): + # https://github.com/conan-io/conan/issues/12692 + with pytest.raises(ConanException) as e: + VersionRange(">= 1.0") From 4b7c5d3a44ca3db7abc08f7bb2d0104defa27786 Mon Sep 17 00:00:00 2001 From: James Date: Thu, 19 Jan 2023 15:23:10 +0100 Subject: [PATCH 61/78] [develop2] display tracebacks in test errors (#12928) * [develop2] display tracebacks in test errors * fix * fix --- conans/errors.py | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index f6b413dc..6d624234 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -47,10 +47,7 @@ def _raise_conanfile_exc(e): try: yield - # TODO: Move ConanInvalidSystemRequirements, ConanInvalidConfiguration from here? - except ConanInvalidSystemRequirements as exc: - msg = "{}: Invalid system requirements: {}".format(str(conanfile_name), exc) - raise ConanInvalidSystemRequirements(msg) + # TODO: Move ConanInvalidConfiguration from here? except ConanInvalidConfiguration as exc: msg = "{}: Invalid configuration: {}".format(str(conanfile_name), exc) raise ConanInvalidConfiguration(msg) @@ -161,10 +158,6 @@ class ConanExceptionInUserConanfileMethod(ConanException): pass -class ConanInvalidSystemRequirements(ConanException): - pass - - class ConanInvalidConfiguration(ConanExceptionInUserConanfileMethod): """ This binary, for the requested configuration and package-id cannot be built From 6b6add3534678495a4193528500ae4bcae68dccc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Francisco=20Ram=C3=ADrez?= Date: Fri, 20 Jan 2023 15:55:24 +0100 Subject: [PATCH 62/78] [bugfix] `Version` int comparison (#12934) fixed error comparing between integers --- conans/model/version.py | 2 +- .../unittests/model/version/test_version_comparison.py | 9 +++++++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/conans/model/version.py b/conans/model/version.py index ad678e4e..2ff31e0d 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -159,7 +159,7 @@ def __repr__(self): def __eq__(self, other): if other is None: return False - if isinstance(other, str): + if not isinstance(other, Version): other = Version(other) return (self._nonzero_items, self._pre, self._build) ==\ diff --git a/conans/test/unittests/model/version/test_version_comparison.py b/conans/test/unittests/model/version/test_version_comparison.py index 96d18138..7b24e9de 100644 --- a/conans/test/unittests/model/version/test_version_comparison.py +++ b/conans/test/unittests/model/version/test_version_comparison.py @@ -53,6 +53,15 @@ def test_comparison(v1, v2): assert v2 >= v1 +def test_comparison_with_integer(): + v1 = Version("13.0") + # Issue: https://github.com/conan-io/conan/issues/12907 + assert v1 > 5 + assert not v1 > 20 + assert v1 < 20 + assert v1 == 13 + + e = [("1", "1.0"), ("1", "1.0.0"), ("1.0", "1.0.0"), From 50ed1a7240d05cc48ed708abf79014a4191dca37 Mon Sep 17 00:00:00 2001 From: James Date: Tue, 24 Jan 2023 11:59:51 +0100 Subject: [PATCH 63/78] [develop2] Improve error messages for wrong methods (#12962) --- conans/model/version.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/conans/model/version.py b/conans/model/version.py index 2ff31e0d..0c88069e 100644 --- a/conans/model/version.py +++ b/conans/model/version.py @@ -79,10 +79,14 @@ def __init__(self, value): def bump(self, index): """ - Increments by 1 the version field at the specified index, setting to 0 the fields + :meta private: + Bump the version + Increments by 1 the version field at the specified index, setting to 0 the fields on the right. - 2.5 => bump(1) => 2.6 - 1.5.7 => bump(0) => 2.0.0 + 2.5 => bump(1) => 2.6 + 1.5.7 => bump(0) => 2.0.0 + + :param index: """ # this method is used to compute version ranges from tilde ~1.2 and caret ^1.2.1 ranges # TODO: at this moment it only works for digits, cannot increment pre-release or builds From 5e5846d0f5823c05b5945ec39c082b3689b66762 Mon Sep 17 00:00:00 2001 From: James Date: Mon, 20 Feb 2023 22:41:49 +0100 Subject: [PATCH 64/78] [develop2] Fix MesonToolchain wrong cppstd in apple-clang (#13172) --- conans/test/unittests/model/version/test_version_range.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/conans/test/unittests/model/version/test_version_range.py b/conans/test/unittests/model/version/test_version_range.py index fb41eeb0..1392d783 100644 --- a/conans/test/unittests/model/version/test_version_range.py +++ b/conans/test/unittests/model/version/test_version_range.py @@ -52,7 +52,8 @@ def test_range(version_range, conditions, versions_in, versions_out): for v in versions_out: assert Version(v) not in r + def test_wrong_range_syntax(): # https://github.com/conan-io/conan/issues/12692 - with pytest.raises(ConanException) as e: + with pytest.raises(ConanException): VersionRange(">= 1.0") From e5c842f41239d25a707dac322ca401fb95456571 Mon Sep 17 00:00:00 2001 From: "John M. Horan" Date: Thu, 23 Feb 2023 07:30:12 -0800 Subject: [PATCH 65/78] Add ConanVersionRange class and test #101 Reference: https://github.com/nexB/univers/issues/101 Signed-off-by: John M. Horan --- src/univers/version_range.py | 20 +- tests/data/conan_advisory.json | 2570 ++++++++++++++++++++++++++++++++ tests/test_version_range.py | 15 + 3 files changed, 2595 insertions(+), 10 deletions(-) create mode 100644 tests/data/conan_advisory.json diff --git a/src/univers/version_range.py b/src/univers/version_range.py index 3b4b053d..54e35e96 100644 --- a/src/univers/version_range.py +++ b/src/univers/version_range.py @@ -6,17 +6,12 @@ import attr import semantic_version -from packaging.specifiers import InvalidSpecifier -from packaging.specifiers import SpecifierSet -from semantic_version.base import AllOf -from semantic_version.base import AnyOf - -from univers import gem -from univers import maven -from univers import versions +from packaging.specifiers import InvalidSpecifier, SpecifierSet +from semantic_version.base import AllOf, AnyOf + +from univers import gem, maven, versions from univers.utils import remove_spaces -from univers.version_constraint import VersionConstraint -from univers.version_constraint import contains_version +from univers.version_constraint import VersionConstraint, contains_version class InvalidVersionRange(Exception): @@ -377,6 +372,11 @@ def from_native(cls, string): return cls(constraints=constraints) +class ConanVersionRange(NpmVersionRange): + scheme = "conan" + version_class = versions.SemverVersion + + class GemVersionRange(VersionRange): """ A version range implementation for Rubygems. diff --git a/tests/data/conan_advisory.json b/tests/data/conan_advisory.json new file mode 100644 index 00000000..f7476b16 --- /dev/null +++ b/tests/data/conan_advisory.json @@ -0,0 +1,2570 @@ +[ + { + "test_index": 1, + "scheme": "conan", + "native": ">=5.1.0 <=5.1.1", + "expected_vers": "vers:conan/>=5.1.0|<=5.1.1" + }, + { + "test_index": 2, + "scheme": "conan", + "native": "=5.2.5", + "expected_vers": "vers:conan/5.2.5" + }, + { + "test_index": 3, + "scheme": "conan", + "native": "<3.5.4", + "expected_vers": "vers:conan/<3.5.4" + }, + { + "test_index": 4, + "scheme": "conan", + "native": "=3.7", + "expected_vers": "vers:conan/3.7.0" + }, + { + "test_index": 5, + "scheme": "conan", + "native": "<0", + "expected_vers": "vers:conan/<0.0.0" + }, + { + "test_index": 6, + "scheme": "conan", + "native": "<2.17.3", + "expected_vers": "vers:conan/<2.17.3" + }, + { + "test_index": 7, + "scheme": "conan", + "native": "<=2.18.1", + "expected_vers": "vers:conan/<=2.18.1" + }, + { + "test_index": 8, + "scheme": "conan", + "native": ">=1.11.34 <2.19.3", + "expected_vers": "vers:conan/>=1.11.34|<2.19.3" + }, + { + "test_index": 9, + "scheme": "conan", + "native": "<1.0.8", + "expected_vers": "vers:conan/<1.0.8" + }, + { + "test_index": 10, + "scheme": "conan", + "native": "=1.16.0", + "expected_vers": "vers:conan/1.16.0" + }, + { + "test_index": 11, + "scheme": "conan", + "native": "<1.16.0", + "expected_vers": "vers:conan/<1.16.0" + }, + { + "test_index": 12, + "scheme": "conan", + "native": ">=1.0.0 <1.17.2", + "expected_vers": "vers:conan/>=1.0.0|<1.17.2" + }, + { + "test_index": 13, + "scheme": "conan", + "native": "<1.17.4", + "expected_vers": "vers:conan/<1.17.4" + }, + { + "test_index": 14, + "scheme": "conan", + "native": "<0.13.7||>=0.14.0 <0.14.11||>=0.15.0 <0.15.2", + "expected_vers": "vers:conan/<0.13.7|>=0.14.0|<0.14.11|>=0.15.0|<0.15.2" + }, + { + "test_index": 15, + "scheme": "conan", + "native": "<=1.3.0", + "expected_vers": "vers:conan/<=1.3.0" + }, + { + "test_index": 16, + "scheme": "conan", + "native": "<=1.3.0", + "expected_vers": "vers:conan/<=1.3.0" + }, + { + "test_index": 17, + "scheme": "conan", + "native": "<2.9.3", + "expected_vers": "vers:conan/<2.9.3" + }, + { + "test_index": 18, + "scheme": "conan", + "native": "<3.1.0", + "expected_vers": "vers:conan/<3.1.0" + }, + { + "test_index": 19, + "scheme": "conan", + "native": "<=0.5.8", + "expected_vers": "vers:conan/<=0.5.8" + }, + { + "test_index": 20, + "scheme": "conan", + "native": "<=0.1.12", + "expected_vers": "vers:conan/<=0.1.12" + }, + { + "test_index": 21, + "scheme": "conan", + "native": "<=0.1.12", + "expected_vers": "vers:conan/<=0.1.12" + }, + { + "test_index": 22, + "scheme": "conan", + "native": "<=2.1.27", + "expected_vers": "vers:conan/<=2.1.27" + }, + { + "test_index": 23, + "scheme": "conan", + "native": ">=2.1.17 <=2.1.27", + "expected_vers": "vers:conan/>=2.1.17|<=2.1.27" + }, + { + "test_index": 24, + "scheme": "conan", + "native": "<=3.6.6", + "expected_vers": "vers:conan/<=3.6.6" + }, + { + "test_index": 25, + "scheme": "conan", + "native": "<=3.6.6", + "expected_vers": "vers:conan/<=3.6.6" + }, + { + "test_index": 26, + "scheme": "conan", + "native": "<=3.6.6", + "expected_vers": "vers:conan/<=3.6.6" + }, + { + "test_index": 27, + "scheme": "conan", + "native": "<=3.6.6", + "expected_vers": "vers:conan/<=3.6.6" + }, + { + "test_index": 28, + "scheme": "conan", + "native": "<3.6.7", + "expected_vers": "vers:conan/<3.6.7" + }, + { + "test_index": 29, + "scheme": "conan", + "native": "<3.6.7", + "expected_vers": "vers:conan/<3.6.7" + }, + { + "test_index": 30, + "scheme": "conan", + "native": "<3.6.7", + "expected_vers": "vers:conan/<3.6.7" + }, + { + "test_index": 31, + "scheme": "conan", + "native": "=3.6.7", + "expected_vers": "vers:conan/3.6.7" + }, + { + "test_index": 32, + "scheme": "conan", + "native": "<2021.07.22.00", + "expected_vers": "vers:conan/<2021.7.22+00" + }, + { + "test_index": 33, + "scheme": "conan", + "native": "<1.0.12", + "expected_vers": "vers:conan/<1.0.12" + }, + { + "test_index": 34, + "scheme": "conan", + "native": "<1.0.12", + "expected_vers": "vers:conan/<1.0.12" + }, + { + "test_index": 35, + "scheme": "conan", + "native": "<1.0.12", + "expected_vers": "vers:conan/<1.0.12" + }, + { + "test_index": 36, + "scheme": "conan", + "native": ">=3.3.0 <=3.4.0", + "expected_vers": "vers:conan/>=3.3.0|<=3.4.0" + }, + { + "test_index": 37, + "scheme": "conan", + "native": "=2.42.6", + "expected_vers": "vers:conan/2.42.6" + }, + { + "test_index": 38, + "scheme": "conan", + "native": "<=5.1.4", + "expected_vers": "vers:conan/<=5.1.4" + }, + { + "test_index": 39, + "scheme": "conan", + "native": "=5.1.4", + "expected_vers": "vers:conan/5.1.4" + }, + { + "test_index": 40, + "scheme": "conan", + "native": "=5.2.1", + "expected_vers": "vers:conan/5.2.1" + }, + { + "test_index": 41, + "scheme": "conan", + "native": "<2.65.3", + "expected_vers": "vers:conan/<2.65.3" + }, + { + "test_index": 42, + "scheme": "conan", + "native": ">=2.60.0 <=2.62.4", + "expected_vers": "vers:conan/>=2.60.0|<=2.62.4" + }, + { + "test_index": 43, + "scheme": "conan", + "native": "<2.66.7||>=2.67.0 <2.67.4", + "expected_vers": "vers:conan/<2.66.7|>=2.67.0|<2.67.4" + }, + { + "test_index": 44, + "scheme": "conan", + "native": "<2.66.6||>=2.67.0 <2.67.3", + "expected_vers": "vers:conan/<2.66.6|>=2.67.0|<2.67.3" + }, + { + "test_index": 45, + "scheme": "conan", + "native": "<2.66.8", + "expected_vers": "vers:conan/<2.66.8" + }, + { + "test_index": 46, + "scheme": "conan", + "native": "<2.63.6", + "expected_vers": "vers:conan/<2.63.6" + }, + { + "test_index": 47, + "scheme": "conan", + "native": "<=3.2", + "expected_vers": "vers:conan/<=3.2.0" + }, + { + "test_index": 48, + "scheme": "conan", + "native": "<=3.2", + "expected_vers": "vers:conan/<=3.2.0" + }, + { + "test_index": 49, + "scheme": "conan", + "native": "=2.8.107", + "expected_vers": "vers:conan/2.8.107" + }, + { + "test_index": 50, + "scheme": "conan", + "native": "=2.8.107", + "expected_vers": "vers:conan/2.8.107" + }, + { + "test_index": 51, + "scheme": "conan", + "native": "=2.8.107", + "expected_vers": "vers:conan/2.8.107" + }, + { + "test_index": 52, + "scheme": "conan", + "native": "=2.8.107", + "expected_vers": "vers:conan/2.8.107" + }, + { + "test_index": 53, + "scheme": "conan", + "native": "=2.8.107", + "expected_vers": "vers:conan/2.8.107" + }, + { + "test_index": 54, + "scheme": "conan", + "native": "=2.8.107", + "expected_vers": "vers:conan/2.8.107" + }, + { + "test_index": 55, + "scheme": "conan", + "native": "=2.9.0", + "expected_vers": "vers:conan/2.9.0" + }, + { + "test_index": 56, + "scheme": "conan", + "native": "=4.3.0", + "expected_vers": "vers:conan/4.3.0" + }, + { + "test_index": 57, + "scheme": "conan", + "native": "<=1.12.0", + "expected_vers": "vers:conan/<=1.12.0" + }, + { + "test_index": 58, + "scheme": "conan", + "native": "<=1.12.0", + "expected_vers": "vers:conan/<=1.12.0" + }, + { + "test_index": 59, + "scheme": "conan", + "native": "<=1.12.0", + "expected_vers": "vers:conan/<=1.12.0" + }, + { + "test_index": 60, + "scheme": "conan", + "native": "<=1.12.0", + "expected_vers": "vers:conan/<=1.12.0" + }, + { + "test_index": 61, + "scheme": "conan", + "native": "=1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1" + }, + { + "test_index": 62, + "scheme": "conan", + "native": "=1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1" + }, + { + "test_index": 63, + "scheme": "conan", + "native": "=1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1" + }, + { + "test_index": 64, + "scheme": "conan", + "native": "=1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1" + }, + { + "test_index": 65, + "scheme": "conan", + "native": "=1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1" + }, + { + "test_index": 66, + "scheme": "conan", + "native": "=1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1" + }, + { + "test_index": 67, + "scheme": "conan", + "native": "=1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1" + }, + { + "test_index": 68, + "scheme": "conan", + "native": "=1.10.4", + "expected_vers": "vers:conan/1.10.4" + }, + { + "test_index": 69, + "scheme": "conan", + "native": "=1.10.4", + "expected_vers": "vers:conan/1.10.4" + }, + { + "test_index": 70, + "scheme": "conan", + "native": "=1.10.4", + "expected_vers": "vers:conan/1.10.4" + }, + { + "test_index": 71, + "scheme": "conan", + "native": "<=0.14.0", + "expected_vers": "vers:conan/<=0.14.0" + }, + { + "test_index": 72, + "scheme": "conan", + "native": "<=2.13.1", + "expected_vers": "vers:conan/<=2.13.1" + }, + { + "test_index": 73, + "scheme": "conan", + "native": "<2.0.23", + "expected_vers": "vers:conan/<2.0.23" + }, + { + "test_index": 74, + "scheme": "conan", + "native": "<2.0.25", + "expected_vers": "vers:conan/<2.0.25" + }, + { + "test_index": 75, + "scheme": "conan", + "native": "<2.0.25", + "expected_vers": "vers:conan/<2.0.25" + }, + { + "test_index": 76, + "scheme": "conan", + "native": ">=2.0.0 <2.0.17", + "expected_vers": "vers:conan/>=2.0.0|<2.0.17" + }, + { + "test_index": 77, + "scheme": "conan", + "native": "=2.0.24", + "expected_vers": "vers:conan/2.0.24" + }, + { + "test_index": 78, + "scheme": "conan", + "native": "<2.0.27", + "expected_vers": "vers:conan/<2.0.27" + }, + { + "test_index": 79, + "scheme": "conan", + "native": "<2.0.26", + "expected_vers": "vers:conan/<2.0.26" + }, + { + "test_index": 80, + "scheme": "conan", + "native": "=3.0.6", + "expected_vers": "vers:conan/3.0.6" + }, + { + "test_index": 81, + "scheme": "conan", + "native": "=3.0.6", + "expected_vers": "vers:conan/3.0.6" + }, + { + "test_index": 82, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 83, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 84, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 85, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 86, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 87, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 88, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 89, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 90, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 91, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 92, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 93, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 94, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 95, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 96, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 97, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 98, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 99, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 100, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 101, + "scheme": "conan", + "native": "=2.2.0", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 102, + "scheme": "conan", + "native": "<=2.3.0", + "expected_vers": "vers:conan/<=2.3.0" + }, + { + "test_index": 103, + "scheme": "conan", + "native": "<=2.3.0", + "expected_vers": "vers:conan/<=2.3.0" + }, + { + "test_index": 104, + "scheme": "conan", + "native": "=2.3.0", + "expected_vers": "vers:conan/2.3.0" + }, + { + "test_index": 105, + "scheme": "conan", + "native": "=2.4.0", + "expected_vers": "vers:conan/2.4.0" + }, + { + "test_index": 106, + "scheme": "conan", + "native": "=2.4.0", + "expected_vers": "vers:conan/2.4.0" + }, + { + "test_index": 107, + "scheme": "conan", + "native": "=2.4.0", + "expected_vers": "vers:conan/2.4.0" + }, + { + "test_index": 108, + "scheme": "conan", + "native": "=2.4.0", + "expected_vers": "vers:conan/2.4.0" + }, + { + "test_index": 109, + "scheme": "conan", + "native": "=2.4.0", + "expected_vers": "vers:conan/2.4.0" + }, + { + "test_index": 110, + "scheme": "conan", + "native": "=2.4.0", + "expected_vers": "vers:conan/2.4.0" + }, + { + "test_index": 111, + "scheme": "conan", + "native": "=2.4.0", + "expected_vers": "vers:conan/2.4.0" + }, + { + "test_index": 112, + "scheme": "conan", + "native": "<=2.4.0", + "expected_vers": "vers:conan/<=2.4.0" + }, + { + "test_index": 113, + "scheme": "conan", + "native": "<=2.4.0", + "expected_vers": "vers:conan/<=2.4.0" + }, + { + "test_index": 114, + "scheme": "conan", + "native": "", + "expected_vers": "vers:conan/" + }, + { + "test_index": 115, + "scheme": "conan", + "native": "<2021-10-15", + "expected_vers": "vers:conan/<2021.0.0-10-15" + }, + { + "test_index": 116, + "scheme": "conan", + "native": "<=2.4.0", + "expected_vers": "vers:conan/<=2.4.0" + }, + { + "test_index": 117, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 118, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 119, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 120, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 121, + "scheme": "conan", + "native": "=2.3.0", + "expected_vers": "vers:conan/2.3.0" + }, + { + "test_index": 122, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 123, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 124, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 125, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 126, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 127, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 128, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 129, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 130, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 131, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 132, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 133, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 134, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 135, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 136, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 137, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 138, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 139, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 140, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 141, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 142, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 143, + "scheme": "conan", + "native": "=3.0.0", + "expected_vers": "vers:conan/3.0.0" + }, + { + "test_index": 144, + "scheme": "conan", + "native": "", + "expected_vers": "vers:conan/" + }, + { + "test_index": 145, + "scheme": "conan", + "native": "=2.4.0", + "expected_vers": "vers:conan/2.4.0" + }, + { + "test_index": 146, + "scheme": "conan", + "native": "<=0.14", + "expected_vers": "vers:conan/<=0.14.0" + }, + { + "test_index": 147, + "scheme": "conan", + "native": "<1.80.0", + "expected_vers": "vers:conan/<1.80.0" + }, + { + "test_index": 148, + "scheme": "conan", + "native": "<1.80.0", + "expected_vers": "vers:conan/<1.80.0" + }, + { + "test_index": 149, + "scheme": "conan", + "native": "<1.80.0", + "expected_vers": "vers:conan/<1.80.0" + }, + { + "test_index": 150, + "scheme": "conan", + "native": "<1.80.0", + "expected_vers": "vers:conan/<1.80.0" + }, + { + "test_index": 151, + "scheme": "conan", + "native": "<1.80.0", + "expected_vers": "vers:conan/<1.80.0" + }, + { + "test_index": 152, + "scheme": "conan", + "native": "<1.80.0", + "expected_vers": "vers:conan/<1.80.0" + }, + { + "test_index": 153, + "scheme": "conan", + "native": "=3.4.1", + "expected_vers": "vers:conan/3.4.1" + }, + { + "test_index": 154, + "scheme": "conan", + "native": ">=3.4.0 <3.4.2", + "expected_vers": "vers:conan/>=3.4.0|<3.4.2" + }, + { + "test_index": 155, + "scheme": "conan", + "native": "<3.5.2", + "expected_vers": "vers:conan/<3.5.2" + }, + { + "test_index": 156, + "scheme": "conan", + "native": "<3.5.2", + "expected_vers": "vers:conan/<3.5.2" + }, + { + "test_index": 157, + "scheme": "conan", + "native": ">=3.4.1 <=3.5.2", + "expected_vers": "vers:conan/>=3.4.1|<=3.5.2" + }, + { + "test_index": 158, + "scheme": "conan", + "native": "=3.6.0", + "expected_vers": "vers:conan/3.6.0" + }, + { + "test_index": 159, + "scheme": "conan", + "native": "=3.6.0", + "expected_vers": "vers:conan/3.6.0" + }, + { + "test_index": 160, + "scheme": "conan", + "native": ">=3.0.0 <3.6.2", + "expected_vers": "vers:conan/>=3.0.0|<3.6.2" + }, + { + "test_index": 161, + "scheme": "conan", + "native": ">=0.6.0 <=0.6.1", + "expected_vers": "vers:conan/>=0.6.0|<=0.6.1" + }, + { + "test_index": 162, + "scheme": "conan", + "native": ">=0.6.0 <=0.6.1", + "expected_vers": "vers:conan/>=0.6.0|<=0.6.1" + }, + { + "test_index": 163, + "scheme": "conan", + "native": "=3.3", + "expected_vers": "vers:conan/3.3.0" + }, + { + "test_index": 164, + "scheme": "conan", + "native": ">=7.29.0 <=7.71.1", + "expected_vers": "vers:conan/>=7.29.0|<=7.71.1" + }, + { + "test_index": 165, + "scheme": "conan", + "native": ">=7.21.0 <7.74.0", + "expected_vers": "vers:conan/>=7.21.0|<7.74.0" + }, + { + "test_index": 166, + "scheme": "conan", + "native": ">=7.41.0 <7.74.0", + "expected_vers": "vers:conan/>=7.41.0|<7.74.0" + }, + { + "test_index": 167, + "scheme": "conan", + "native": ">=7.1.1 <=7.75.0", + "expected_vers": "vers:conan/>=7.1.1|<=7.75.0" + }, + { + "test_index": 168, + "scheme": "conan", + "native": ">=7.63.0 <=7.75.0", + "expected_vers": "vers:conan/>=7.63.0|<=7.75.0" + }, + { + "test_index": 169, + "scheme": "conan", + "native": ">=7.10.4 <7.77.0", + "expected_vers": "vers:conan/>=7.10.4|<7.77.0" + }, + { + "test_index": 170, + "scheme": "conan", + "native": ">=7.73.0 <=7.78.0", + "expected_vers": "vers:conan/>=7.73.0|<=7.78.0" + }, + { + "test_index": 171, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 172, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 173, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 174, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 175, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 176, + "scheme": "conan", + "native": "<=1.0.8", + "expected_vers": "vers:conan/<=1.0.8" + }, + { + "test_index": 177, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 178, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 179, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 180, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 181, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 182, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 183, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 184, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 185, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 186, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 187, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 188, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 189, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 190, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 191, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 192, + "scheme": "conan", + "native": "=1.0.8", + "expected_vers": "vers:conan/1.0.8" + }, + { + "test_index": 193, + "scheme": "conan", + "native": "=1.0.9", + "expected_vers": "vers:conan/1.0.9" + }, + { + "test_index": 194, + "scheme": "conan", + "native": "=0.4.0", + "expected_vers": "vers:conan/0.4.0" + }, + { + "test_index": 195, + "scheme": "conan", + "native": "=0.4.0", + "expected_vers": "vers:conan/0.4.0" + }, + { + "test_index": 196, + "scheme": "conan", + "native": "=0.4.1", + "expected_vers": "vers:conan/0.4.1" + }, + { + "test_index": 197, + "scheme": "conan", + "native": "<0.28.4", + "expected_vers": "vers:conan/<0.28.4" + }, + { + "test_index": 198, + "scheme": "conan", + "native": "<0.28.4", + "expected_vers": "vers:conan/<0.28.4" + }, + { + "test_index": 199, + "scheme": "conan", + "native": "=2.0.4", + "expected_vers": "vers:conan/2.0.4" + }, + { + "test_index": 200, + "scheme": "conan", + "native": "<2.0.4", + "expected_vers": "vers:conan/<2.0.4" + }, + { + "test_index": 201, + "scheme": "conan", + "native": "=2.0.90", + "expected_vers": "vers:conan/2.0.90" + }, + { + "test_index": 202, + "scheme": "conan", + "native": ">1.5.3 <=2.0.90", + "expected_vers": "vers:conan/>1.5.3|<=2.0.90" + }, + { + "test_index": 203, + "scheme": "conan", + "native": "<9d", + "expected_vers": "vers:conan/<9.0.0-d" + }, + { + "test_index": 204, + "scheme": "conan", + "native": "<9d", + "expected_vers": "vers:conan/<9.0.0-d" + }, + { + "test_index": 205, + "scheme": "conan", + "native": "<1.64", + "expected_vers": "vers:conan/<1.64.0" + }, + { + "test_index": 206, + "scheme": "conan", + "native": "<3.1.7", + "expected_vers": "vers:conan/<3.1.7" + }, + { + "test_index": 207, + "scheme": "conan", + "native": "=1.6.0", + "expected_vers": "vers:conan/1.6.0" + }, + { + "test_index": 208, + "scheme": "conan", + "native": "<0.20", + "expected_vers": "vers:conan/<0.20.0" + }, + { + "test_index": 209, + "scheme": "conan", + "native": "<=0.20", + "expected_vers": "vers:conan/<=0.20.0" + }, + { + "test_index": 210, + "scheme": "conan", + "native": "<0.20.1", + "expected_vers": "vers:conan/<0.20.1" + }, + { + "test_index": 211, + "scheme": "conan", + "native": "<0.20.0", + "expected_vers": "vers:conan/<0.20.0" + }, + { + "test_index": 212, + "scheme": "conan", + "native": "=0.20.0", + "expected_vers": "vers:conan/0.20.0" + }, + { + "test_index": 213, + "scheme": "conan", + "native": "<=3.4.0", + "expected_vers": "vers:conan/<=3.4.0" + }, + { + "test_index": 214, + "scheme": "conan", + "native": "=1.0.30", + "expected_vers": "vers:conan/1.0.30" + }, + { + "test_index": 215, + "scheme": "conan", + "native": "=1.1.10", + "expected_vers": "vers:conan/1.1.10" + }, + { + "test_index": 216, + "scheme": "conan", + "native": "<4.2.0", + "expected_vers": "vers:conan/<4.2.0" + }, + { + "test_index": 217, + "scheme": "conan", + "native": "<4.2.0", + "expected_vers": "vers:conan/<4.2.0" + }, + { + "test_index": 218, + "scheme": "conan", + "native": "<4.2.0", + "expected_vers": "vers:conan/<4.2.0" + }, + { + "test_index": 219, + "scheme": "conan", + "native": "<4.2.0", + "expected_vers": "vers:conan/<4.2.0" + }, + { + "test_index": 220, + "scheme": "conan", + "native": ">=3.9.0 <=4.3.0", + "expected_vers": "vers:conan/>=3.9.0|<=4.3.0" + }, + { + "test_index": 221, + "scheme": "conan", + "native": ">=4.0.0 <=4.3.0", + "expected_vers": "vers:conan/>=4.0.0|<=4.3.0" + }, + { + "test_index": 222, + "scheme": "conan", + "native": "=4.3.0", + "expected_vers": "vers:conan/4.3.0" + }, + { + "test_index": 223, + "scheme": "conan", + "native": ">=3.9.0 <=4.3.0", + "expected_vers": "vers:conan/>=3.9.0|<=4.3.0" + }, + { + "test_index": 224, + "scheme": "conan", + "native": "=4.3.0", + "expected_vers": "vers:conan/4.3.0" + }, + { + "test_index": 225, + "scheme": "conan", + "native": "<=4.3.0", + "expected_vers": "vers:conan/<=4.3.0" + }, + { + "test_index": 226, + "scheme": "conan", + "native": "=4.3.0", + "expected_vers": "vers:conan/4.3.0" + }, + { + "test_index": 227, + "scheme": "conan", + "native": "=4.3.0", + "expected_vers": "vers:conan/4.3.0" + }, + { + "test_index": 228, + "scheme": "conan", + "native": "=4.3.0", + "expected_vers": "vers:conan/4.3.0" + }, + { + "test_index": 229, + "scheme": "conan", + "native": "=4.3.0", + "expected_vers": "vers:conan/4.3.0" + }, + { + "test_index": 230, + "scheme": "conan", + "native": "<4.4.0", + "expected_vers": "vers:conan/<4.4.0" + }, + { + "test_index": 231, + "scheme": "conan", + "native": "<4.4.0", + "expected_vers": "vers:conan/<4.4.0" + }, + { + "test_index": 232, + "scheme": "conan", + "native": "=4.3.0", + "expected_vers": "vers:conan/4.3.0" + }, + { + "test_index": 233, + "scheme": "conan", + "native": "=4.3.0", + "expected_vers": "vers:conan/4.3.0" + }, + { + "test_index": 234, + "scheme": "conan", + "native": "=4.4.0", + "expected_vers": "vers:conan/4.4.0" + }, + { + "test_index": 235, + "scheme": "conan", + "native": "=4.4.0", + "expected_vers": "vers:conan/4.4.0" + }, + { + "test_index": 236, + "scheme": "conan", + "native": "=4.4.0", + "expected_vers": "vers:conan/4.4.0" + }, + { + "test_index": 237, + "scheme": "conan", + "native": "=4.3.0", + "expected_vers": "vers:conan/4.3.0" + }, + { + "test_index": 238, + "scheme": "conan", + "native": "=4.4.0", + "expected_vers": "vers:conan/4.4.0" + }, + { + "test_index": 239, + "scheme": "conan", + "native": "=4.4.0", + "expected_vers": "vers:conan/4.4.0" + }, + { + "test_index": 240, + "scheme": "conan", + "native": "=4.4.0", + "expected_vers": "vers:conan/4.4.0" + }, + { + "test_index": 241, + "scheme": "conan", + "native": "<4.4.0", + "expected_vers": "vers:conan/<4.4.0" + }, + { + "test_index": 242, + "scheme": "conan", + "native": "<4.4.0", + "expected_vers": "vers:conan/<4.4.0" + }, + { + "test_index": 243, + "scheme": "conan", + "native": "<4.4.0", + "expected_vers": "vers:conan/<4.4.0" + }, + { + "test_index": 244, + "scheme": "conan", + "native": "<=4.4.0", + "expected_vers": "vers:conan/<=4.4.0" + }, + { + "test_index": 245, + "scheme": "conan", + "native": "=4.0.3-35", + "expected_vers": "vers:conan/4.0.3-35" + }, + { + "test_index": 246, + "scheme": "conan", + "native": "=4.4.0", + "expected_vers": "vers:conan/4.4.0" + }, + { + "test_index": 247, + "scheme": "conan", + "native": ">=3.9.0 <=4.4.0", + "expected_vers": "vers:conan/>=3.9.0|<=4.4.0" + }, + { + "test_index": 248, + "scheme": "conan", + "native": "<=4.4.0", + "expected_vers": "vers:conan/<=4.4.0" + }, + { + "test_index": 249, + "scheme": "conan", + "native": "<=4.4.0", + "expected_vers": "vers:conan/<=4.4.0" + }, + { + "test_index": 250, + "scheme": "conan", + "native": "<=4.4.0", + "expected_vers": "vers:conan/<=4.4.0" + }, + { + "test_index": 251, + "scheme": "conan", + "native": "<=4.4.0", + "expected_vers": "vers:conan/<=4.4.0" + }, + { + "test_index": 252, + "scheme": "conan", + "native": "<=4.4.0", + "expected_vers": "vers:conan/<=4.4.0" + }, + { + "test_index": 253, + "scheme": "conan", + "native": "<4.5.0", + "expected_vers": "vers:conan/<4.5.0" + }, + { + "test_index": 254, + "scheme": "conan", + "native": "<1.0.1", + "expected_vers": "vers:conan/<1.0.1" + }, + { + "test_index": 255, + "scheme": "conan", + "native": "<1.0.1", + "expected_vers": "vers:conan/<1.0.1" + }, + { + "test_index": 256, + "scheme": "conan", + "native": "<1.0.1", + "expected_vers": "vers:conan/<1.0.1" + }, + { + "test_index": 257, + "scheme": "conan", + "native": "<1.0.1", + "expected_vers": "vers:conan/<1.0.1" + }, + { + "test_index": 258, + "scheme": "conan", + "native": "<1.0.1", + "expected_vers": "vers:conan/<1.0.1" + }, + { + "test_index": 259, + "scheme": "conan", + "native": "=2.9.10", + "expected_vers": "vers:conan/2.9.10" + }, + { + "test_index": 260, + "scheme": "conan", + "native": "=2.9.10", + "expected_vers": "vers:conan/2.9.10" + }, + { + "test_index": 261, + "scheme": "conan", + "native": "<2.9.11", + "expected_vers": "vers:conan/<2.9.11" + }, + { + "test_index": 262, + "scheme": "conan", + "native": "<2.9.11", + "expected_vers": "vers:conan/<2.9.11" + }, + { + "test_index": 263, + "scheme": "conan", + "native": "<2.9.11", + "expected_vers": "vers:conan/<2.9.11" + }, + { + "test_index": 264, + "scheme": "conan", + "native": "<2.9.11", + "expected_vers": "vers:conan/<2.9.11" + }, + { + "test_index": 265, + "scheme": "conan", + "native": "<2.9.11", + "expected_vers": "vers:conan/<2.9.11" + }, + { + "test_index": 266, + "scheme": "conan", + "native": "<2.9.13", + "expected_vers": "vers:conan/<2.9.13" + }, + { + "test_index": 267, + "scheme": "conan", + "native": "<2.9.14", + "expected_vers": "vers:conan/<2.9.14" + }, + { + "test_index": 268, + "scheme": "conan", + "native": "<2.10.3", + "expected_vers": "vers:conan/<2.10.3" + }, + { + "test_index": 269, + "scheme": "conan", + "native": "<2.10.3", + "expected_vers": "vers:conan/<2.10.3" + }, + { + "test_index": 270, + "scheme": "conan", + "native": "<1.1.35", + "expected_vers": "vers:conan/<1.1.35" + }, + { + "test_index": 271, + "scheme": "conan", + "native": "<=0.11.4", + "expected_vers": "vers:conan/<=0.11.4" + }, + { + "test_index": 272, + "scheme": "conan", + "native": "<0.12.1", + "expected_vers": "vers:conan/<0.12.1" + }, + { + "test_index": 273, + "scheme": "conan", + "native": "<0.12.1", + "expected_vers": "vers:conan/<0.12.1" + }, + { + "test_index": 274, + "scheme": "conan", + "native": "<=0.12.1", + "expected_vers": "vers:conan/<=0.12.1" + }, + { + "test_index": 275, + "scheme": "conan", + "native": "<=0.12.1", + "expected_vers": "vers:conan/<=0.12.1" + }, + { + "test_index": 276, + "scheme": "conan", + "native": "<=0.12.1", + "expected_vers": "vers:conan/<=0.12.1" + }, + { + "test_index": 277, + "scheme": "conan", + "native": "=0.12.1", + "expected_vers": "vers:conan/0.12.1" + }, + { + "test_index": 278, + "scheme": "conan", + "native": "=0.12.1", + "expected_vers": "vers:conan/0.12.1" + }, + { + "test_index": 279, + "scheme": "conan", + "native": "=0.12.1", + "expected_vers": "vers:conan/0.12.1" + }, + { + "test_index": 280, + "scheme": "conan", + "native": "<=5.4.0", + "expected_vers": "vers:conan/<=5.4.0" + }, + { + "test_index": 281, + "scheme": "conan", + "native": "=5.4.0", + "expected_vers": "vers:conan/5.4.0" + }, + { + "test_index": 282, + "scheme": "conan", + "native": "<=5.4.0", + "expected_vers": "vers:conan/<=5.4.0" + }, + { + "test_index": 283, + "scheme": "conan", + "native": "=5.4.0", + "expected_vers": "vers:conan/5.4.0" + }, + { + "test_index": 284, + "scheme": "conan", + "native": "=5.4.0", + "expected_vers": "vers:conan/5.4.0" + }, + { + "test_index": 285, + "scheme": "conan", + "native": "=5.4.0", + "expected_vers": "vers:conan/5.4.0" + }, + { + "test_index": 286, + "scheme": "conan", + "native": "=5.4.0", + "expected_vers": "vers:conan/5.4.0" + }, + { + "test_index": 287, + "scheme": "conan", + "native": ">=5.1.0 <5.3.5||>=5.4.0 <5.4.4", + "expected_vers": "vers:conan/>=5.1.0|<5.3.5|>=5.4.0|<5.4.4" + }, + { + "test_index": 288, + "scheme": "conan", + "native": "=5.4.3", + "expected_vers": "vers:conan/5.4.3" + }, + { + "test_index": 289, + "scheme": "conan", + "native": ">=5.4.0 <=5.4.3", + "expected_vers": "vers:conan/>=5.4.0|<=5.4.3" + }, + { + "test_index": 290, + "scheme": "conan", + "native": ">=5.4.0 <=5.4.4", + "expected_vers": "vers:conan/>=5.4.0|<=5.4.4" + }, + { + "test_index": 291, + "scheme": "conan", + "native": ">=5.4.2 <=5.4.4", + "expected_vers": "vers:conan/>=5.4.2|<=5.4.4" + }, + { + "test_index": 292, + "scheme": "conan", + "native": "=1.8.3", + "expected_vers": "vers:conan/1.8.3" + }, + { + "test_index": 293, + "scheme": "conan", + "native": "<2.7.17||>=2.8.0 <2.16.8||>=2.17.0 <2.24.0", + "expected_vers": "vers:conan/<2.7.17|>=2.8.0|<2.16.8|>=2.17.0|<2.24.0" + }, + { + "test_index": 294, + "scheme": "conan", + "native": "=4.0.0", + "expected_vers": "vers:conan/4.0.0" + }, + { + "test_index": 295, + "scheme": "conan", + "native": "<=6.2.1", + "expected_vers": "vers:conan/<=6.2.1" + }, + { + "test_index": 296, + "scheme": "conan", + "native": "<6.3", + "expected_vers": "vers:conan/<6.3.0" + }, + { + "test_index": 297, + "scheme": "conan", + "native": "<3.7.2", + "expected_vers": "vers:conan/<3.7.2" + }, + { + "test_index": 298, + "scheme": "conan", + "native": "<3.7.3", + "expected_vers": "vers:conan/<3.7.3" + }, + { + "test_index": 299, + "scheme": "conan", + "native": "<2.4.1", + "expected_vers": "vers:conan/<2.4.1" + }, + { + "test_index": 300, + "scheme": "conan", + "native": "<2.4.1", + "expected_vers": "vers:conan/<2.4.1" + }, + { + "test_index": 301, + "scheme": "conan", + "native": "<2.4.1", + "expected_vers": "vers:conan/<2.4.1" + }, + { + "test_index": 302, + "scheme": "conan", + "native": "<2.4.1", + "expected_vers": "vers:conan/<2.4.1" + }, + { + "test_index": 303, + "scheme": "conan", + "native": "<2.4.1", + "expected_vers": "vers:conan/<2.4.1" + }, + { + "test_index": 304, + "scheme": "conan", + "native": "<2.4.1", + "expected_vers": "vers:conan/<2.4.1" + }, + { + "test_index": 305, + "scheme": "conan", + "native": "<2.4.1", + "expected_vers": "vers:conan/<2.4.1" + }, + { + "test_index": 306, + "scheme": "conan", + "native": "<2.4.1", + "expected_vers": "vers:conan/<2.4.1" + }, + { + "test_index": 307, + "scheme": "conan", + "native": "<2.5.2", + "expected_vers": "vers:conan/<2.5.2" + }, + { + "test_index": 308, + "scheme": "conan", + "native": "<2.5.2", + "expected_vers": "vers:conan/<2.5.2" + }, + { + "test_index": 309, + "scheme": "conan", + "native": "<2.5.2", + "expected_vers": "vers:conan/<2.5.2" + }, + { + "test_index": 310, + "scheme": "conan", + "native": "=2.3.0", + "expected_vers": "vers:conan/2.3.0" + }, + { + "test_index": 311, + "scheme": "conan", + "native": "=2.3.0", + "expected_vers": "vers:conan/2.3.0" + }, + { + "test_index": 312, + "scheme": "conan", + "native": "=2.3.0", + "expected_vers": "vers:conan/2.3.0" + }, + { + "test_index": 313, + "scheme": "conan", + "native": "<2.4.3||>=2.5.0 <2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + }, + { + "test_index": 314, + "scheme": "conan", + "native": "<=2.5.7", + "expected_vers": "vers:conan/<=2.5.7" + }, + { + "test_index": 315, + "scheme": "conan", + "native": "<2.5.4", + "expected_vers": "vers:conan/<2.5.4" + }, + { + "test_index": 316, + "scheme": "conan", + "native": "<2.5.4", + "expected_vers": "vers:conan/<2.5.4" + }, + { + "test_index": 317, + "scheme": "conan", + "native": "<2.5.4", + "expected_vers": "vers:conan/<2.5.4" + }, + { + "test_index": 318, + "scheme": "conan", + "native": "<2.5.4", + "expected_vers": "vers:conan/<2.5.4" + }, + { + "test_index": 319, + "scheme": "conan", + "native": "<=2.5.7", + "expected_vers": "vers:conan/<=2.5.7" + }, + { + "test_index": 320, + "scheme": "conan", + "native": "<3.0.1", + "expected_vers": "vers:conan/<3.0.1" + }, + { + "test_index": 321, + "scheme": "conan", + "native": "<3.0.1", + "expected_vers": "vers:conan/<3.0.1" + }, + { + "test_index": 322, + "scheme": "conan", + "native": "<3.0.1", + "expected_vers": "vers:conan/<3.0.1" + }, + { + "test_index": 323, + "scheme": "conan", + "native": "<3.0.1", + "expected_vers": "vers:conan/<3.0.1" + }, + { + "test_index": 324, + "scheme": "conan", + "native": "<2.4.3||>=2.5.0 <2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + }, + { + "test_index": 325, + "scheme": "conan", + "native": "<2.4.3||>=2.5.0 <2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + }, + { + "test_index": 326, + "scheme": "conan", + "native": "<2.4.3||>=2.5.0 <2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + }, + { + "test_index": 327, + "scheme": "conan", + "native": "<2.4.3||>=2.5.0 <2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + }, + { + "test_index": 328, + "scheme": "conan", + "native": "<2.4.3||>=2.5.0 <2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + }, + { + "test_index": 329, + "scheme": "conan", + "native": "<2.4.3||>=2.5.0 <2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + }, + { + "test_index": 330, + "scheme": "conan", + "native": "<3.0.5", + "expected_vers": "vers:conan/<3.0.5" + }, + { + "test_index": 331, + "scheme": "conan", + "native": "<3.0.5", + "expected_vers": "vers:conan/<3.0.5" + }, + { + "test_index": 332, + "scheme": "conan", + "native": "<3.1.2", + "expected_vers": "vers:conan/<3.1.2" + }, + { + "test_index": 333, + "scheme": "conan", + "native": "=3.1.2", + "expected_vers": "vers:conan/3.1.2" + }, + { + "test_index": 334, + "scheme": "conan", + "native": ">=3.1.0 <3.1.4", + "expected_vers": "vers:conan/>=3.1.0|<3.1.4" + }, + { + "test_index": 335, + "scheme": "conan", + "native": "<=2.3.1", + "expected_vers": "vers:conan/<=2.3.1" + }, + { + "test_index": 336, + "scheme": "conan", + "native": "<=1.5.1||>=2.0.0 <2.4.0", + "expected_vers": "vers:conan/<=1.5.1|>=2.0.0|<2.4.0" + }, + { + "test_index": 337, + "scheme": "conan", + "native": "<2.4.0", + "expected_vers": "vers:conan/<2.4.0" + }, + { + "test_index": 338, + "scheme": "conan", + "native": "<2.4.0", + "expected_vers": "vers:conan/<2.4.0" + }, + { + "test_index": 339, + "scheme": "conan", + "native": "<2.4.0", + "expected_vers": "vers:conan/<2.4.0" + }, + { + "test_index": 340, + "scheme": "conan", + "native": "<2.4.0", + "expected_vers": "vers:conan/<2.4.0" + }, + { + "test_index": 341, + "scheme": "conan", + "native": "<2.4.0", + "expected_vers": "vers:conan/<2.4.0" + }, + { + "test_index": 342, + "scheme": "conan", + "native": "<2.4.0", + "expected_vers": "vers:conan/<2.4.0" + }, + { + "test_index": 343, + "scheme": "conan", + "native": "<2.4.0", + "expected_vers": "vers:conan/<2.4.0" + }, + { + "test_index": 344, + "scheme": "conan", + "native": "<=2.3.1", + "expected_vers": "vers:conan/<=2.3.1" + }, + { + "test_index": 345, + "scheme": "conan", + "native": "=2.3.1", + "expected_vers": "vers:conan/2.3.1" + }, + { + "test_index": 346, + "scheme": "conan", + "native": "=2.4.0", + "expected_vers": "vers:conan/2.4.0" + }, + { + "test_index": 347, + "scheme": "conan", + "native": "<=2.4.0", + "expected_vers": "vers:conan/<=2.4.0" + }, + { + "test_index": 348, + "scheme": "conan", + "native": "=2.4.0", + "expected_vers": "vers:conan/2.4.0" + }, + { + "test_index": 349, + "scheme": "conan", + "native": ">=1.1.1d <=1.1.1f", + "expected_vers": "vers:conan/>=1.1.1-d|<=1.1.1-f" + }, + { + "test_index": 350, + "scheme": "conan", + "native": ">=1.0.2 <=1.0.2v", + "expected_vers": "vers:conan/>=1.0.2|<=1.0.2" + }, + { + "test_index": 351, + "scheme": "conan", + "native": ">=1.0.2 <=1.0.2w||>=1.1.1 <=1.1.1h", + "expected_vers": "vers:conan/<=1.0.2-w|>=1.0.2|<=1.1.1-h|>=1.1.1" + }, + { + "test_index": 352, + "scheme": "conan", + "native": "=1.0.2s", + "expected_vers": "vers:conan/1.0.2-s" + }, + { + "test_index": 353, + "scheme": "conan", + "native": ">=1.0.2 <1.0.2y||>=1.1.1 <1.1.1j", + "expected_vers": "vers:conan/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1" + }, + { + "test_index": 354, + "scheme": "conan", + "native": ">=1.0.2 <1.0.2y||>=1.1.1 <1.1.1j", + "expected_vers": "vers:conan/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1" + }, + { + "test_index": 355, + "scheme": "conan", + "native": "<0", + "expected_vers": "vers:conan/<0.0.0" + }, + { + "test_index": 356, + "scheme": "conan", + "native": ">=1.1.1 <1.1.1k", + "expected_vers": "vers:conan/<1.1.1-k|>=1.1.1" + }, + { + "test_index": 357, + "scheme": "conan", + "native": ">=1.1.1h <1.1.1k", + "expected_vers": "vers:conan/>=1.1.1-h|<1.1.1-k" + }, + { + "test_index": 358, + "scheme": "conan", + "native": ">=1.1.1 <1.1.1l", + "expected_vers": "vers:conan/<1.1.1-l|>=1.1.1" + }, + { + "test_index": 359, + "scheme": "conan", + "native": ">=1.0.2 <1.0.2za||>=1.1.1 <1.1.1l", + "expected_vers": "vers:conan/<1.0.2-za|>=1.0.2|<1.1.1-l|>=1.1.1" + }, + { + "test_index": 360, + "scheme": "conan", + "native": "<1.0.2||=1.1.0||=3.0.0", + "expected_vers": "vers:conan/<1.0.2|1.1.0|3.0.0" + }, + { + "test_index": 361, + "scheme": "conan", + "native": ">=1.0.2 <1.1.1m||=3.0.0", + "expected_vers": "vers:conan/>=1.0.2|<1.1.1-m|3.0.0" + }, + { + "test_index": 362, + "scheme": "conan", + "native": ">=1.0.2 <1.0.2zd||>=1.1.0 <1.1.1n||>=3.0.0 <3.0.2", + "expected_vers": "vers:conan/<1.0.2-zd|>=1.0.2|>=1.1.0|<1.1.1-n|>=3.0.0|<3.0.2" + }, + { + "test_index": 363, + "scheme": "conan", + "native": ">=1.0.2 <1.0.2ze||>=1.1.1 <1.1.1o||>=3.0.0 <3.0.3", + "expected_vers": "vers:conan/<1.0.2-ze|>=1.0.2|<1.1.1-o|>=1.1.1|>=3.0.0|<3.0.3" + }, + { + "test_index": 364, + "scheme": "conan", + "native": ">=3.0.0 <3.0.3", + "expected_vers": "vers:conan/>=3.0.0|<3.0.3" + }, + { + "test_index": 365, + "scheme": "conan", + "native": ">=3.0.0 <3.0.3", + "expected_vers": "vers:conan/>=3.0.0|<3.0.3" + }, + { + "test_index": 366, + "scheme": "conan", + "native": ">=3.0.0 <3.0.3", + "expected_vers": "vers:conan/>=3.0.0|<3.0.3" + }, + { + "test_index": 367, + "scheme": "conan", + "native": ">=1.0.2 <1.0.2zf||>=1.1.1 <1.1.1p||>=3.0.0 <3.0.4", + "expected_vers": "vers:conan/<1.0.2-zf|>=1.0.2|<1.1.1-p|>=1.1.1|>=3.0.0|<3.0.4" + }, + { + "test_index": 368, + "scheme": "conan", + "native": ">=1.1.1 <1.1.1q||>=3.0.0 <3.0.5", + "expected_vers": "vers:conan/<1.1.1-q|>=1.1.1|>=3.0.0|<3.0.5" + }, + { + "test_index": 369, + "scheme": "conan", + "native": "=3.0.4", + "expected_vers": "vers:conan/3.0.4" + }, + { + "test_index": 370, + "scheme": "conan", + "native": ">=3.0.0 <3.0.6", + "expected_vers": "vers:conan/>=3.0.0|<3.0.6" + }, + { + "test_index": 371, + "scheme": "conan", + "native": ">=3.0.0 <3.0.7", + "expected_vers": "vers:conan/>=3.0.0|<3.0.7" + }, + { + "test_index": 372, + "scheme": "conan", + "native": ">=3.0.0 <3.0.7", + "expected_vers": "vers:conan/>=3.0.0|<3.0.7" + }, + { + "test_index": 373, + "scheme": "conan", + "native": ">=3.0.0 <=3.0.7", + "expected_vers": "vers:conan/>=3.0.0|<=3.0.7" + }, + { + "test_index": 374, + "scheme": "conan", + "native": "<8.44", + "expected_vers": "vers:conan/<8.44.0" + }, + { + "test_index": 375, + "scheme": "conan", + "native": "<10.40", + "expected_vers": "vers:conan/<10.40.0" + }, + { + "test_index": 376, + "scheme": "conan", + "native": "<10.40", + "expected_vers": "vers:conan/<10.40.0" + }, + { + "test_index": 377, + "scheme": "conan", + "native": "<3.15.0", + "expected_vers": "vers:conan/<3.15.0" + }, + { + "test_index": 378, + "scheme": "conan", + "native": "<3.18.3||>=3.19.0 <3.19.5||>=3.20.0 <3.20.2||>=3.21.0 <3.21.6", + "expected_vers": "vers:conan/<3.18.3|>=3.19.0|<3.19.5|>=3.20.0|<3.20.2|>=3.21.0|<3.21.6" + }, + { + "test_index": 379, + "scheme": "conan", + "native": "=1.3", + "expected_vers": "vers:conan/1.3.0" + }, + { + "test_index": 380, + "scheme": "conan", + "native": "=2.2", + "expected_vers": "vers:conan/2.2.0" + }, + { + "test_index": 381, + "scheme": "conan", + "native": "<=1.5.0", + "expected_vers": "vers:conan/<=1.5.0" + }, + { + "test_index": 382, + "scheme": "conan", + "native": ">=4.0 <4.4.1", + "expected_vers": "vers:conan/>=4.0.0|<4.4.1" + }, + { + "test_index": 383, + "scheme": "conan", + "native": ">=4.0 <4.4.3", + "expected_vers": "vers:conan/>=4.0.0|<4.4.3" + }, + { + "test_index": 384, + "scheme": "conan", + "native": "<=2.0.1", + "expected_vers": "vers:conan/<=2.0.1" + }, + { + "test_index": 385, + "scheme": "conan", + "native": "=cci.20200203", + "expected_vers": null + }, + { + "test_index": 386, + "scheme": "conan", + "native": "=2.27", + "expected_vers": "vers:conan/2.27.0" + }, + { + "test_index": 387, + "scheme": "conan", + "native": "=2.27", + "expected_vers": "vers:conan/2.27.0" + }, + { + "test_index": 388, + "scheme": "conan", + "native": "=8.6.11", + "expected_vers": "vers:conan/8.6.11" + }, + { + "test_index": 389, + "scheme": "conan", + "native": "=5.0.0", + "expected_vers": "vers:conan/5.0.0" + }, + { + "test_index": 390, + "scheme": "conan", + "native": ">=0.9.3 <=0.13.0", + "expected_vers": "vers:conan/>=0.9.3|<=0.13.0" + }, + { + "test_index": 391, + "scheme": "conan", + "native": "<2021.02.22.00", + "expected_vers": "vers:conan/<2021.2.22+00" + }, + { + "test_index": 392, + "scheme": "conan", + "native": "<1.05.01", + "expected_vers": "vers:conan/<1.5.1" + }, + { + "test_index": 393, + "scheme": "conan", + "native": "<0.9.6", + "expected_vers": "vers:conan/<0.9.6" + }, + { + "test_index": 394, + "scheme": "conan", + "native": "<0.9.6", + "expected_vers": "vers:conan/<0.9.6" + }, + { + "test_index": 395, + "scheme": "conan", + "native": ">=19.0.0 <=20.8.0", + "expected_vers": "vers:conan/>=19.0.0|<=20.8.0" + }, + { + "test_index": 396, + "scheme": "conan", + "native": ">=0.19.0 <0.30.0", + "expected_vers": "vers:conan/>=0.19.0|<0.30.0" + }, + { + "test_index": 397, + "scheme": "conan", + "native": ">=0.26.0 <0.30.0", + "expected_vers": "vers:conan/>=0.26.0|<0.30.0" + }, + { + "test_index": 398, + "scheme": "conan", + "native": "<0.30.0", + "expected_vers": "vers:conan/<0.30.0" + }, + { + "test_index": 399, + "scheme": "conan", + "native": "<0.33.1||>0.33.1 <0.34.1", + "expected_vers": "vers:conan/<0.33.1|>0.33.1|<0.34.1" + }, + { + "test_index": 400, + "scheme": "conan", + "native": ">=0.34.0 <0.34.2||>=0.35.0 <0.35.2", + "expected_vers": "vers:conan/>=0.34.0|<0.34.2|>=0.35.0|<0.35.2" + }, + { + "test_index": 401, + "scheme": "conan", + "native": "<0.38.1", + "expected_vers": "vers:conan/<0.38.1" + }, + { + "test_index": 402, + "scheme": "conan", + "native": ">=0.37.0 <0.38.2", + "expected_vers": "vers:conan/>=0.37.0|<0.38.2" + }, + { + "test_index": 403, + "scheme": "conan", + "native": "<0.38.1", + "expected_vers": "vers:conan/<0.38.1" + }, + { + "test_index": 404, + "scheme": "conan", + "native": "<1.0.2||>=2.0.0 <2.0.2", + "expected_vers": "vers:conan/<1.0.2|>=2.0.0|<2.0.2" + }, + { + "test_index": 405, + "scheme": "conan", + "native": "<1.0.2||>=2.0.0 <2.0.2", + "expected_vers": "vers:conan/<1.0.2|>=2.0.0|<2.0.2" + }, + { + "test_index": 406, + "scheme": "conan", + "native": "<1.0.2||>=2.0.0 <2.0.2", + "expected_vers": "vers:conan/<1.0.2|>=2.0.0|<2.0.2" + }, + { + "test_index": 407, + "scheme": "conan", + "native": "=4.3.0", + "expected_vers": "vers:conan/4.3.0" + }, + { + "test_index": 408, + "scheme": "conan", + "native": "<4.4.0", + "expected_vers": "vers:conan/<4.4.0" + }, + { + "test_index": 409, + "scheme": "conan", + "native": "<4.5.0", + "expected_vers": "vers:conan/<4.5.0" + }, + { + "test_index": 410, + "scheme": "conan", + "native": "<4.5.0", + "expected_vers": "vers:conan/<4.5.0" + }, + { + "test_index": 411, + "scheme": "conan", + "native": "<4.5.0", + "expected_vers": "vers:conan/<4.5.0" + }, + { + "test_index": 412, + "scheme": "conan", + "native": "<4.5.0", + "expected_vers": "vers:conan/<4.5.0" + }, + { + "test_index": 413, + "scheme": "conan", + "native": "<4.6.0", + "expected_vers": "vers:conan/<4.6.0" + }, + { + "test_index": 414, + "scheme": "conan", + "native": "<4.6.0", + "expected_vers": "vers:conan/<4.6.0" + }, + { + "test_index": 415, + "scheme": "conan", + "native": "<4.7.0", + "expected_vers": "vers:conan/<4.7.0" + }, + { + "test_index": 416, + "scheme": "conan", + "native": ">=4.6.0 <4.8.0", + "expected_vers": "vers:conan/>=4.6.0|<4.8.0" + }, + { + "test_index": 417, + "scheme": "conan", + "native": "<4.8.1", + "expected_vers": "vers:conan/<4.8.1" + }, + { + "test_index": 418, + "scheme": "conan", + "native": "<=5.0.0", + "expected_vers": "vers:conan/<=5.0.0" + }, + { + "test_index": 419, + "scheme": "conan", + "native": ">=5.0.0 <5.1.1", + "expected_vers": "vers:conan/>=5.0.0|<5.1.1" + }, + { + "test_index": 420, + "scheme": "conan", + "native": "<5.2.0", + "expected_vers": "vers:conan/<5.2.0" + }, + { + "test_index": 421, + "scheme": "conan", + "native": "<5.2.0", + "expected_vers": "vers:conan/<5.2.0" + }, + { + "test_index": 422, + "scheme": "conan", + "native": "<5.4.0", + "expected_vers": "vers:conan/<5.4.0" + }, + { + "test_index": 423, + "scheme": "conan", + "native": "<5.5.0", + "expected_vers": "vers:conan/<5.5.0" + }, + { + "test_index": 424, + "scheme": "conan", + "native": "=5.3.0", + "expected_vers": "vers:conan/5.3.0" + }, + { + "test_index": 425, + "scheme": "conan", + "native": "<5.5.1", + "expected_vers": "vers:conan/<5.5.1" + }, + { + "test_index": 426, + "scheme": "conan", + "native": "<5.5.2", + "expected_vers": "vers:conan/<5.5.2" + }, + { + "test_index": 427, + "scheme": "conan", + "native": "<5.5.0", + "expected_vers": "vers:conan/<5.5.0" + }, + { + "test_index": 428, + "scheme": "conan", + "native": "<4.3.3", + "expected_vers": "vers:conan/<4.3.3" + } +] diff --git a/tests/test_version_range.py b/tests/test_version_range.py index 70332838..608f85e7 100644 --- a/tests/test_version_range.py +++ b/tests/test_version_range.py @@ -397,6 +397,21 @@ def test_npm_advisory_version_range_parse(test_case): assert str(result) == test_case["expected_vers"] +@pytest.mark.parametrize("test_case", json.load(open("./tests/data/conan_advisory.json"))) +def test_conan_advisory_version_range_parse(test_case): + if test_case["expected_vers"] is None: + # with pytest.raises(InvalidVersionRange): + with pytest.raises(InvalidVersion): + # ConanVersionRange.from_native(string=test_case["conan_native"]) + ConanVersionRange.from_native(string=test_case["native"]) + return + result = ConanVersionRange.from_native( + # string=test_case["conan_native"], + string=test_case["native"], + ) + assert str(result) == test_case["expected_vers"] + + def test_invert(): vers_with_equal_operator = VersionRange.from_string("vers:gem/1.0") assert str(vers_with_equal_operator.invert()) == "vers:gem/!=1.0" From 570f4adac0bcd7d0661a78acd7b75cd69034afbc Mon Sep 17 00:00:00 2001 From: "John M. Horan" Date: Thu, 23 Feb 2023 09:59:59 -0800 Subject: [PATCH 66/78] Fix import formatting #101 Reference: https://github.com/nexB/univers/issues/101 Signed-off-by: John M. Horan --- src/univers/version_range.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/univers/version_range.py b/src/univers/version_range.py index 54e35e96..9533e35e 100644 --- a/src/univers/version_range.py +++ b/src/univers/version_range.py @@ -6,12 +6,17 @@ import attr import semantic_version -from packaging.specifiers import InvalidSpecifier, SpecifierSet -from semantic_version.base import AllOf, AnyOf - -from univers import gem, maven, versions +from packaging.specifiers import InvalidSpecifier +from packaging.specifiers import SpecifierSet +from semantic_version.base import AllOf +from semantic_version.base import AnyOf + +from univers import gem +from univers import maven +from univers import versions from univers.utils import remove_spaces -from univers.version_constraint import VersionConstraint, contains_version +from univers.version_constraint import VersionConstraint +from univers.version_constraint import contains_version class InvalidVersionRange(Exception): From d71d003f5bfff4317d5db675f9284fc10513da65 Mon Sep 17 00:00:00 2001 From: "John M. Horan" Date: Thu, 23 Feb 2023 10:24:40 -0800 Subject: [PATCH 67/78] Change scheme from conan to conan1 #101 Signed-off-by: John M. Horan --- src/univers/version_range.py | 11 +- tests/data/conan_advisory.json | 1710 ++++++++++++++++---------------- 2 files changed, 864 insertions(+), 857 deletions(-) diff --git a/src/univers/version_range.py b/src/univers/version_range.py index 9533e35e..6c16b978 100644 --- a/src/univers/version_range.py +++ b/src/univers/version_range.py @@ -377,8 +377,8 @@ def from_native(cls, string): return cls(constraints=constraints) -class ConanVersionRange(NpmVersionRange): - scheme = "conan" +class Conan1VersionRange(NpmVersionRange): + scheme = "conan1" version_class = versions.SemverVersion @@ -1105,6 +1105,11 @@ class MattermostVersionRange(VersionRange): def from_gitlab_native(gitlab_scheme, string): purl_scheme = PURL_TYPE_BY_GITLAB_SCHEME[gitlab_scheme] vrc = RANGE_CLASS_BY_SCHEMES[purl_scheme] + supported_native_implementations = [ + Conan1VersionRange, + ] + if vrc in supported_native_implementations: + return vrc.from_native(string) constraint_items = [] constraints = [] split = " " @@ -1228,6 +1233,7 @@ def build_range_from_github_advisory_constraint(scheme: str, string: str): "nginx": NginxVersionRange, "openssl": OpensslVersionRange, "mattermost": MattermostVersionRange, + "conan1": Conan1VersionRange, } PURL_TYPE_BY_GITLAB_SCHEME = { @@ -1238,4 +1244,5 @@ def build_range_from_github_advisory_constraint(scheme: str, string: str): "nuget": "nuget", "pypi": "pypi", "packagist": "composer", + "conan": "conan1", } diff --git a/tests/data/conan_advisory.json b/tests/data/conan_advisory.json index f7476b16..393b9c27 100644 --- a/tests/data/conan_advisory.json +++ b/tests/data/conan_advisory.json @@ -1,2570 +1,2570 @@ [ { "test_index": 1, - "scheme": "conan", + "scheme": "conan1", "native": ">=5.1.0 <=5.1.1", - "expected_vers": "vers:conan/>=5.1.0|<=5.1.1" + "expected_vers": "vers:conan1/>=5.1.0|<=5.1.1" }, { "test_index": 2, - "scheme": "conan", + "scheme": "conan1", "native": "=5.2.5", - "expected_vers": "vers:conan/5.2.5" + "expected_vers": "vers:conan1/5.2.5" }, { "test_index": 3, - "scheme": "conan", + "scheme": "conan1", "native": "<3.5.4", - "expected_vers": "vers:conan/<3.5.4" + "expected_vers": "vers:conan1/<3.5.4" }, { "test_index": 4, - "scheme": "conan", + "scheme": "conan1", "native": "=3.7", - "expected_vers": "vers:conan/3.7.0" + "expected_vers": "vers:conan1/3.7.0" }, { "test_index": 5, - "scheme": "conan", + "scheme": "conan1", "native": "<0", - "expected_vers": "vers:conan/<0.0.0" + "expected_vers": "vers:conan1/<0.0.0" }, { "test_index": 6, - "scheme": "conan", + "scheme": "conan1", "native": "<2.17.3", - "expected_vers": "vers:conan/<2.17.3" + "expected_vers": "vers:conan1/<2.17.3" }, { "test_index": 7, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.18.1", - "expected_vers": "vers:conan/<=2.18.1" + "expected_vers": "vers:conan1/<=2.18.1" }, { "test_index": 8, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.11.34 <2.19.3", - "expected_vers": "vers:conan/>=1.11.34|<2.19.3" + "expected_vers": "vers:conan1/>=1.11.34|<2.19.3" }, { "test_index": 9, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.8", - "expected_vers": "vers:conan/<1.0.8" + "expected_vers": "vers:conan1/<1.0.8" }, { "test_index": 10, - "scheme": "conan", + "scheme": "conan1", "native": "=1.16.0", - "expected_vers": "vers:conan/1.16.0" + "expected_vers": "vers:conan1/1.16.0" }, { "test_index": 11, - "scheme": "conan", + "scheme": "conan1", "native": "<1.16.0", - "expected_vers": "vers:conan/<1.16.0" + "expected_vers": "vers:conan1/<1.16.0" }, { "test_index": 12, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.0.0 <1.17.2", - "expected_vers": "vers:conan/>=1.0.0|<1.17.2" + "expected_vers": "vers:conan1/>=1.0.0|<1.17.2" }, { "test_index": 13, - "scheme": "conan", + "scheme": "conan1", "native": "<1.17.4", - "expected_vers": "vers:conan/<1.17.4" + "expected_vers": "vers:conan1/<1.17.4" }, { "test_index": 14, - "scheme": "conan", + "scheme": "conan1", "native": "<0.13.7||>=0.14.0 <0.14.11||>=0.15.0 <0.15.2", - "expected_vers": "vers:conan/<0.13.7|>=0.14.0|<0.14.11|>=0.15.0|<0.15.2" + "expected_vers": "vers:conan1/<0.13.7|>=0.14.0|<0.14.11|>=0.15.0|<0.15.2" }, { "test_index": 15, - "scheme": "conan", + "scheme": "conan1", "native": "<=1.3.0", - "expected_vers": "vers:conan/<=1.3.0" + "expected_vers": "vers:conan1/<=1.3.0" }, { "test_index": 16, - "scheme": "conan", + "scheme": "conan1", "native": "<=1.3.0", - "expected_vers": "vers:conan/<=1.3.0" + "expected_vers": "vers:conan1/<=1.3.0" }, { "test_index": 17, - "scheme": "conan", + "scheme": "conan1", "native": "<2.9.3", - "expected_vers": "vers:conan/<2.9.3" + "expected_vers": "vers:conan1/<2.9.3" }, { "test_index": 18, - "scheme": "conan", + "scheme": "conan1", "native": "<3.1.0", - "expected_vers": "vers:conan/<3.1.0" + "expected_vers": "vers:conan1/<3.1.0" }, { "test_index": 19, - "scheme": "conan", + "scheme": "conan1", "native": "<=0.5.8", - "expected_vers": "vers:conan/<=0.5.8" + "expected_vers": "vers:conan1/<=0.5.8" }, { "test_index": 20, - "scheme": "conan", + "scheme": "conan1", "native": "<=0.1.12", - "expected_vers": "vers:conan/<=0.1.12" + "expected_vers": "vers:conan1/<=0.1.12" }, { "test_index": 21, - "scheme": "conan", + "scheme": "conan1", "native": "<=0.1.12", - "expected_vers": "vers:conan/<=0.1.12" + "expected_vers": "vers:conan1/<=0.1.12" }, { "test_index": 22, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.1.27", - "expected_vers": "vers:conan/<=2.1.27" + "expected_vers": "vers:conan1/<=2.1.27" }, { "test_index": 23, - "scheme": "conan", + "scheme": "conan1", "native": ">=2.1.17 <=2.1.27", - "expected_vers": "vers:conan/>=2.1.17|<=2.1.27" + "expected_vers": "vers:conan1/>=2.1.17|<=2.1.27" }, { "test_index": 24, - "scheme": "conan", + "scheme": "conan1", "native": "<=3.6.6", - "expected_vers": "vers:conan/<=3.6.6" + "expected_vers": "vers:conan1/<=3.6.6" }, { "test_index": 25, - "scheme": "conan", + "scheme": "conan1", "native": "<=3.6.6", - "expected_vers": "vers:conan/<=3.6.6" + "expected_vers": "vers:conan1/<=3.6.6" }, { "test_index": 26, - "scheme": "conan", + "scheme": "conan1", "native": "<=3.6.6", - "expected_vers": "vers:conan/<=3.6.6" + "expected_vers": "vers:conan1/<=3.6.6" }, { "test_index": 27, - "scheme": "conan", + "scheme": "conan1", "native": "<=3.6.6", - "expected_vers": "vers:conan/<=3.6.6" + "expected_vers": "vers:conan1/<=3.6.6" }, { "test_index": 28, - "scheme": "conan", + "scheme": "conan1", "native": "<3.6.7", - "expected_vers": "vers:conan/<3.6.7" + "expected_vers": "vers:conan1/<3.6.7" }, { "test_index": 29, - "scheme": "conan", + "scheme": "conan1", "native": "<3.6.7", - "expected_vers": "vers:conan/<3.6.7" + "expected_vers": "vers:conan1/<3.6.7" }, { "test_index": 30, - "scheme": "conan", + "scheme": "conan1", "native": "<3.6.7", - "expected_vers": "vers:conan/<3.6.7" + "expected_vers": "vers:conan1/<3.6.7" }, { "test_index": 31, - "scheme": "conan", + "scheme": "conan1", "native": "=3.6.7", - "expected_vers": "vers:conan/3.6.7" + "expected_vers": "vers:conan1/3.6.7" }, { "test_index": 32, - "scheme": "conan", + "scheme": "conan1", "native": "<2021.07.22.00", - "expected_vers": "vers:conan/<2021.7.22+00" + "expected_vers": "vers:conan1/<2021.7.22+00" }, { "test_index": 33, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.12", - "expected_vers": "vers:conan/<1.0.12" + "expected_vers": "vers:conan1/<1.0.12" }, { "test_index": 34, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.12", - "expected_vers": "vers:conan/<1.0.12" + "expected_vers": "vers:conan1/<1.0.12" }, { "test_index": 35, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.12", - "expected_vers": "vers:conan/<1.0.12" + "expected_vers": "vers:conan1/<1.0.12" }, { "test_index": 36, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.3.0 <=3.4.0", - "expected_vers": "vers:conan/>=3.3.0|<=3.4.0" + "expected_vers": "vers:conan1/>=3.3.0|<=3.4.0" }, { "test_index": 37, - "scheme": "conan", + "scheme": "conan1", "native": "=2.42.6", - "expected_vers": "vers:conan/2.42.6" + "expected_vers": "vers:conan1/2.42.6" }, { "test_index": 38, - "scheme": "conan", + "scheme": "conan1", "native": "<=5.1.4", - "expected_vers": "vers:conan/<=5.1.4" + "expected_vers": "vers:conan1/<=5.1.4" }, { "test_index": 39, - "scheme": "conan", + "scheme": "conan1", "native": "=5.1.4", - "expected_vers": "vers:conan/5.1.4" + "expected_vers": "vers:conan1/5.1.4" }, { "test_index": 40, - "scheme": "conan", + "scheme": "conan1", "native": "=5.2.1", - "expected_vers": "vers:conan/5.2.1" + "expected_vers": "vers:conan1/5.2.1" }, { "test_index": 41, - "scheme": "conan", + "scheme": "conan1", "native": "<2.65.3", - "expected_vers": "vers:conan/<2.65.3" + "expected_vers": "vers:conan1/<2.65.3" }, { "test_index": 42, - "scheme": "conan", + "scheme": "conan1", "native": ">=2.60.0 <=2.62.4", - "expected_vers": "vers:conan/>=2.60.0|<=2.62.4" + "expected_vers": "vers:conan1/>=2.60.0|<=2.62.4" }, { "test_index": 43, - "scheme": "conan", + "scheme": "conan1", "native": "<2.66.7||>=2.67.0 <2.67.4", - "expected_vers": "vers:conan/<2.66.7|>=2.67.0|<2.67.4" + "expected_vers": "vers:conan1/<2.66.7|>=2.67.0|<2.67.4" }, { "test_index": 44, - "scheme": "conan", + "scheme": "conan1", "native": "<2.66.6||>=2.67.0 <2.67.3", - "expected_vers": "vers:conan/<2.66.6|>=2.67.0|<2.67.3" + "expected_vers": "vers:conan1/<2.66.6|>=2.67.0|<2.67.3" }, { "test_index": 45, - "scheme": "conan", + "scheme": "conan1", "native": "<2.66.8", - "expected_vers": "vers:conan/<2.66.8" + "expected_vers": "vers:conan1/<2.66.8" }, { "test_index": 46, - "scheme": "conan", + "scheme": "conan1", "native": "<2.63.6", - "expected_vers": "vers:conan/<2.63.6" + "expected_vers": "vers:conan1/<2.63.6" }, { "test_index": 47, - "scheme": "conan", + "scheme": "conan1", "native": "<=3.2", - "expected_vers": "vers:conan/<=3.2.0" + "expected_vers": "vers:conan1/<=3.2.0" }, { "test_index": 48, - "scheme": "conan", + "scheme": "conan1", "native": "<=3.2", - "expected_vers": "vers:conan/<=3.2.0" + "expected_vers": "vers:conan1/<=3.2.0" }, { "test_index": 49, - "scheme": "conan", + "scheme": "conan1", "native": "=2.8.107", - "expected_vers": "vers:conan/2.8.107" + "expected_vers": "vers:conan1/2.8.107" }, { "test_index": 50, - "scheme": "conan", + "scheme": "conan1", "native": "=2.8.107", - "expected_vers": "vers:conan/2.8.107" + "expected_vers": "vers:conan1/2.8.107" }, { "test_index": 51, - "scheme": "conan", + "scheme": "conan1", "native": "=2.8.107", - "expected_vers": "vers:conan/2.8.107" + "expected_vers": "vers:conan1/2.8.107" }, { "test_index": 52, - "scheme": "conan", + "scheme": "conan1", "native": "=2.8.107", - "expected_vers": "vers:conan/2.8.107" + "expected_vers": "vers:conan1/2.8.107" }, { "test_index": 53, - "scheme": "conan", + "scheme": "conan1", "native": "=2.8.107", - "expected_vers": "vers:conan/2.8.107" + "expected_vers": "vers:conan1/2.8.107" }, { "test_index": 54, - "scheme": "conan", + "scheme": "conan1", "native": "=2.8.107", - "expected_vers": "vers:conan/2.8.107" + "expected_vers": "vers:conan1/2.8.107" }, { "test_index": 55, - "scheme": "conan", + "scheme": "conan1", "native": "=2.9.0", - "expected_vers": "vers:conan/2.9.0" + "expected_vers": "vers:conan1/2.9.0" }, { "test_index": 56, - "scheme": "conan", + "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan/4.3.0" + "expected_vers": "vers:conan1/4.3.0" }, { "test_index": 57, - "scheme": "conan", + "scheme": "conan1", "native": "<=1.12.0", - "expected_vers": "vers:conan/<=1.12.0" + "expected_vers": "vers:conan1/<=1.12.0" }, { "test_index": 58, - "scheme": "conan", + "scheme": "conan1", "native": "<=1.12.0", - "expected_vers": "vers:conan/<=1.12.0" + "expected_vers": "vers:conan1/<=1.12.0" }, { "test_index": 59, - "scheme": "conan", + "scheme": "conan1", "native": "<=1.12.0", - "expected_vers": "vers:conan/<=1.12.0" + "expected_vers": "vers:conan1/<=1.12.0" }, { "test_index": 60, - "scheme": "conan", + "scheme": "conan1", "native": "<=1.12.0", - "expected_vers": "vers:conan/<=1.12.0" + "expected_vers": "vers:conan1/<=1.12.0" }, { "test_index": 61, - "scheme": "conan", + "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1" }, { "test_index": 62, - "scheme": "conan", + "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1" }, { "test_index": 63, - "scheme": "conan", + "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1" }, { "test_index": 64, - "scheme": "conan", + "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1" }, { "test_index": 65, - "scheme": "conan", + "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1" }, { "test_index": 66, - "scheme": "conan", + "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1" }, { "test_index": 67, - "scheme": "conan", + "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1" }, { "test_index": 68, - "scheme": "conan", + "scheme": "conan1", "native": "=1.10.4", - "expected_vers": "vers:conan/1.10.4" + "expected_vers": "vers:conan1/1.10.4" }, { "test_index": 69, - "scheme": "conan", + "scheme": "conan1", "native": "=1.10.4", - "expected_vers": "vers:conan/1.10.4" + "expected_vers": "vers:conan1/1.10.4" }, { "test_index": 70, - "scheme": "conan", + "scheme": "conan1", "native": "=1.10.4", - "expected_vers": "vers:conan/1.10.4" + "expected_vers": "vers:conan1/1.10.4" }, { "test_index": 71, - "scheme": "conan", + "scheme": "conan1", "native": "<=0.14.0", - "expected_vers": "vers:conan/<=0.14.0" + "expected_vers": "vers:conan1/<=0.14.0" }, { "test_index": 72, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.13.1", - "expected_vers": "vers:conan/<=2.13.1" + "expected_vers": "vers:conan1/<=2.13.1" }, { "test_index": 73, - "scheme": "conan", + "scheme": "conan1", "native": "<2.0.23", - "expected_vers": "vers:conan/<2.0.23" + "expected_vers": "vers:conan1/<2.0.23" }, { "test_index": 74, - "scheme": "conan", + "scheme": "conan1", "native": "<2.0.25", - "expected_vers": "vers:conan/<2.0.25" + "expected_vers": "vers:conan1/<2.0.25" }, { "test_index": 75, - "scheme": "conan", + "scheme": "conan1", "native": "<2.0.25", - "expected_vers": "vers:conan/<2.0.25" + "expected_vers": "vers:conan1/<2.0.25" }, { "test_index": 76, - "scheme": "conan", + "scheme": "conan1", "native": ">=2.0.0 <2.0.17", - "expected_vers": "vers:conan/>=2.0.0|<2.0.17" + "expected_vers": "vers:conan1/>=2.0.0|<2.0.17" }, { "test_index": 77, - "scheme": "conan", + "scheme": "conan1", "native": "=2.0.24", - "expected_vers": "vers:conan/2.0.24" + "expected_vers": "vers:conan1/2.0.24" }, { "test_index": 78, - "scheme": "conan", + "scheme": "conan1", "native": "<2.0.27", - "expected_vers": "vers:conan/<2.0.27" + "expected_vers": "vers:conan1/<2.0.27" }, { "test_index": 79, - "scheme": "conan", + "scheme": "conan1", "native": "<2.0.26", - "expected_vers": "vers:conan/<2.0.26" + "expected_vers": "vers:conan1/<2.0.26" }, { "test_index": 80, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.6", - "expected_vers": "vers:conan/3.0.6" + "expected_vers": "vers:conan1/3.0.6" }, { "test_index": 81, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.6", - "expected_vers": "vers:conan/3.0.6" + "expected_vers": "vers:conan1/3.0.6" }, { "test_index": 82, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 83, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 84, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 85, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 86, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 87, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 88, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 89, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 90, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 91, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 92, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 93, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 94, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 95, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 96, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 97, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 98, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 99, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 100, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 101, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 102, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.3.0", - "expected_vers": "vers:conan/<=2.3.0" + "expected_vers": "vers:conan1/<=2.3.0" }, { "test_index": 103, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.3.0", - "expected_vers": "vers:conan/<=2.3.0" + "expected_vers": "vers:conan1/<=2.3.0" }, { "test_index": 104, - "scheme": "conan", + "scheme": "conan1", "native": "=2.3.0", - "expected_vers": "vers:conan/2.3.0" + "expected_vers": "vers:conan1/2.3.0" }, { "test_index": 105, - "scheme": "conan", + "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan/2.4.0" + "expected_vers": "vers:conan1/2.4.0" }, { "test_index": 106, - "scheme": "conan", + "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan/2.4.0" + "expected_vers": "vers:conan1/2.4.0" }, { "test_index": 107, - "scheme": "conan", + "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan/2.4.0" + "expected_vers": "vers:conan1/2.4.0" }, { "test_index": 108, - "scheme": "conan", + "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan/2.4.0" + "expected_vers": "vers:conan1/2.4.0" }, { "test_index": 109, - "scheme": "conan", + "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan/2.4.0" + "expected_vers": "vers:conan1/2.4.0" }, { "test_index": 110, - "scheme": "conan", + "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan/2.4.0" + "expected_vers": "vers:conan1/2.4.0" }, { "test_index": 111, - "scheme": "conan", + "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan/2.4.0" + "expected_vers": "vers:conan1/2.4.0" }, { "test_index": 112, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.4.0", - "expected_vers": "vers:conan/<=2.4.0" + "expected_vers": "vers:conan1/<=2.4.0" }, { "test_index": 113, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.4.0", - "expected_vers": "vers:conan/<=2.4.0" + "expected_vers": "vers:conan1/<=2.4.0" }, { "test_index": 114, - "scheme": "conan", + "scheme": "conan1", "native": "", - "expected_vers": "vers:conan/" + "expected_vers": "vers:conan1/" }, { "test_index": 115, - "scheme": "conan", + "scheme": "conan1", "native": "<2021-10-15", - "expected_vers": "vers:conan/<2021.0.0-10-15" + "expected_vers": "vers:conan1/<2021.0.0-10-15" }, { "test_index": 116, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.4.0", - "expected_vers": "vers:conan/<=2.4.0" + "expected_vers": "vers:conan1/<=2.4.0" }, { "test_index": 117, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 118, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 119, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 120, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 121, - "scheme": "conan", + "scheme": "conan1", "native": "=2.3.0", - "expected_vers": "vers:conan/2.3.0" + "expected_vers": "vers:conan1/2.3.0" }, { "test_index": 122, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 123, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 124, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 125, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 126, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 127, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 128, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 129, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 130, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 131, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 132, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 133, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 134, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 135, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 136, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 137, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 138, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 139, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 140, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 141, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 142, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 143, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan/3.0.0" + "expected_vers": "vers:conan1/3.0.0" }, { "test_index": 144, - "scheme": "conan", + "scheme": "conan1", "native": "", - "expected_vers": "vers:conan/" + "expected_vers": "vers:conan1/" }, { "test_index": 145, - "scheme": "conan", + "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan/2.4.0" + "expected_vers": "vers:conan1/2.4.0" }, { "test_index": 146, - "scheme": "conan", + "scheme": "conan1", "native": "<=0.14", - "expected_vers": "vers:conan/<=0.14.0" + "expected_vers": "vers:conan1/<=0.14.0" }, { "test_index": 147, - "scheme": "conan", + "scheme": "conan1", "native": "<1.80.0", - "expected_vers": "vers:conan/<1.80.0" + "expected_vers": "vers:conan1/<1.80.0" }, { "test_index": 148, - "scheme": "conan", + "scheme": "conan1", "native": "<1.80.0", - "expected_vers": "vers:conan/<1.80.0" + "expected_vers": "vers:conan1/<1.80.0" }, { "test_index": 149, - "scheme": "conan", + "scheme": "conan1", "native": "<1.80.0", - "expected_vers": "vers:conan/<1.80.0" + "expected_vers": "vers:conan1/<1.80.0" }, { "test_index": 150, - "scheme": "conan", + "scheme": "conan1", "native": "<1.80.0", - "expected_vers": "vers:conan/<1.80.0" + "expected_vers": "vers:conan1/<1.80.0" }, { "test_index": 151, - "scheme": "conan", + "scheme": "conan1", "native": "<1.80.0", - "expected_vers": "vers:conan/<1.80.0" + "expected_vers": "vers:conan1/<1.80.0" }, { "test_index": 152, - "scheme": "conan", + "scheme": "conan1", "native": "<1.80.0", - "expected_vers": "vers:conan/<1.80.0" + "expected_vers": "vers:conan1/<1.80.0" }, { "test_index": 153, - "scheme": "conan", + "scheme": "conan1", "native": "=3.4.1", - "expected_vers": "vers:conan/3.4.1" + "expected_vers": "vers:conan1/3.4.1" }, { "test_index": 154, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.4.0 <3.4.2", - "expected_vers": "vers:conan/>=3.4.0|<3.4.2" + "expected_vers": "vers:conan1/>=3.4.0|<3.4.2" }, { "test_index": 155, - "scheme": "conan", + "scheme": "conan1", "native": "<3.5.2", - "expected_vers": "vers:conan/<3.5.2" + "expected_vers": "vers:conan1/<3.5.2" }, { "test_index": 156, - "scheme": "conan", + "scheme": "conan1", "native": "<3.5.2", - "expected_vers": "vers:conan/<3.5.2" + "expected_vers": "vers:conan1/<3.5.2" }, { "test_index": 157, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.4.1 <=3.5.2", - "expected_vers": "vers:conan/>=3.4.1|<=3.5.2" + "expected_vers": "vers:conan1/>=3.4.1|<=3.5.2" }, { "test_index": 158, - "scheme": "conan", + "scheme": "conan1", "native": "=3.6.0", - "expected_vers": "vers:conan/3.6.0" + "expected_vers": "vers:conan1/3.6.0" }, { "test_index": 159, - "scheme": "conan", + "scheme": "conan1", "native": "=3.6.0", - "expected_vers": "vers:conan/3.6.0" + "expected_vers": "vers:conan1/3.6.0" }, { "test_index": 160, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.0.0 <3.6.2", - "expected_vers": "vers:conan/>=3.0.0|<3.6.2" + "expected_vers": "vers:conan1/>=3.0.0|<3.6.2" }, { "test_index": 161, - "scheme": "conan", + "scheme": "conan1", "native": ">=0.6.0 <=0.6.1", - "expected_vers": "vers:conan/>=0.6.0|<=0.6.1" + "expected_vers": "vers:conan1/>=0.6.0|<=0.6.1" }, { "test_index": 162, - "scheme": "conan", + "scheme": "conan1", "native": ">=0.6.0 <=0.6.1", - "expected_vers": "vers:conan/>=0.6.0|<=0.6.1" + "expected_vers": "vers:conan1/>=0.6.0|<=0.6.1" }, { "test_index": 163, - "scheme": "conan", + "scheme": "conan1", "native": "=3.3", - "expected_vers": "vers:conan/3.3.0" + "expected_vers": "vers:conan1/3.3.0" }, { "test_index": 164, - "scheme": "conan", + "scheme": "conan1", "native": ">=7.29.0 <=7.71.1", - "expected_vers": "vers:conan/>=7.29.0|<=7.71.1" + "expected_vers": "vers:conan1/>=7.29.0|<=7.71.1" }, { "test_index": 165, - "scheme": "conan", + "scheme": "conan1", "native": ">=7.21.0 <7.74.0", - "expected_vers": "vers:conan/>=7.21.0|<7.74.0" + "expected_vers": "vers:conan1/>=7.21.0|<7.74.0" }, { "test_index": 166, - "scheme": "conan", + "scheme": "conan1", "native": ">=7.41.0 <7.74.0", - "expected_vers": "vers:conan/>=7.41.0|<7.74.0" + "expected_vers": "vers:conan1/>=7.41.0|<7.74.0" }, { "test_index": 167, - "scheme": "conan", + "scheme": "conan1", "native": ">=7.1.1 <=7.75.0", - "expected_vers": "vers:conan/>=7.1.1|<=7.75.0" + "expected_vers": "vers:conan1/>=7.1.1|<=7.75.0" }, { "test_index": 168, - "scheme": "conan", + "scheme": "conan1", "native": ">=7.63.0 <=7.75.0", - "expected_vers": "vers:conan/>=7.63.0|<=7.75.0" + "expected_vers": "vers:conan1/>=7.63.0|<=7.75.0" }, { "test_index": 169, - "scheme": "conan", + "scheme": "conan1", "native": ">=7.10.4 <7.77.0", - "expected_vers": "vers:conan/>=7.10.4|<7.77.0" + "expected_vers": "vers:conan1/>=7.10.4|<7.77.0" }, { "test_index": 170, - "scheme": "conan", + "scheme": "conan1", "native": ">=7.73.0 <=7.78.0", - "expected_vers": "vers:conan/>=7.73.0|<=7.78.0" + "expected_vers": "vers:conan1/>=7.73.0|<=7.78.0" }, { "test_index": 171, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 172, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 173, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 174, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 175, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 176, - "scheme": "conan", + "scheme": "conan1", "native": "<=1.0.8", - "expected_vers": "vers:conan/<=1.0.8" + "expected_vers": "vers:conan1/<=1.0.8" }, { "test_index": 177, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 178, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 179, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 180, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 181, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 182, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 183, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 184, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 185, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 186, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 187, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 188, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 189, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 190, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 191, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 192, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan/1.0.8" + "expected_vers": "vers:conan1/1.0.8" }, { "test_index": 193, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.9", - "expected_vers": "vers:conan/1.0.9" + "expected_vers": "vers:conan1/1.0.9" }, { "test_index": 194, - "scheme": "conan", + "scheme": "conan1", "native": "=0.4.0", - "expected_vers": "vers:conan/0.4.0" + "expected_vers": "vers:conan1/0.4.0" }, { "test_index": 195, - "scheme": "conan", + "scheme": "conan1", "native": "=0.4.0", - "expected_vers": "vers:conan/0.4.0" + "expected_vers": "vers:conan1/0.4.0" }, { "test_index": 196, - "scheme": "conan", + "scheme": "conan1", "native": "=0.4.1", - "expected_vers": "vers:conan/0.4.1" + "expected_vers": "vers:conan1/0.4.1" }, { "test_index": 197, - "scheme": "conan", + "scheme": "conan1", "native": "<0.28.4", - "expected_vers": "vers:conan/<0.28.4" + "expected_vers": "vers:conan1/<0.28.4" }, { "test_index": 198, - "scheme": "conan", + "scheme": "conan1", "native": "<0.28.4", - "expected_vers": "vers:conan/<0.28.4" + "expected_vers": "vers:conan1/<0.28.4" }, { "test_index": 199, - "scheme": "conan", + "scheme": "conan1", "native": "=2.0.4", - "expected_vers": "vers:conan/2.0.4" + "expected_vers": "vers:conan1/2.0.4" }, { "test_index": 200, - "scheme": "conan", + "scheme": "conan1", "native": "<2.0.4", - "expected_vers": "vers:conan/<2.0.4" + "expected_vers": "vers:conan1/<2.0.4" }, { "test_index": 201, - "scheme": "conan", + "scheme": "conan1", "native": "=2.0.90", - "expected_vers": "vers:conan/2.0.90" + "expected_vers": "vers:conan1/2.0.90" }, { "test_index": 202, - "scheme": "conan", + "scheme": "conan1", "native": ">1.5.3 <=2.0.90", - "expected_vers": "vers:conan/>1.5.3|<=2.0.90" + "expected_vers": "vers:conan1/>1.5.3|<=2.0.90" }, { "test_index": 203, - "scheme": "conan", + "scheme": "conan1", "native": "<9d", - "expected_vers": "vers:conan/<9.0.0-d" + "expected_vers": "vers:conan1/<9.0.0-d" }, { "test_index": 204, - "scheme": "conan", + "scheme": "conan1", "native": "<9d", - "expected_vers": "vers:conan/<9.0.0-d" + "expected_vers": "vers:conan1/<9.0.0-d" }, { "test_index": 205, - "scheme": "conan", + "scheme": "conan1", "native": "<1.64", - "expected_vers": "vers:conan/<1.64.0" + "expected_vers": "vers:conan1/<1.64.0" }, { "test_index": 206, - "scheme": "conan", + "scheme": "conan1", "native": "<3.1.7", - "expected_vers": "vers:conan/<3.1.7" + "expected_vers": "vers:conan1/<3.1.7" }, { "test_index": 207, - "scheme": "conan", + "scheme": "conan1", "native": "=1.6.0", - "expected_vers": "vers:conan/1.6.0" + "expected_vers": "vers:conan1/1.6.0" }, { "test_index": 208, - "scheme": "conan", + "scheme": "conan1", "native": "<0.20", - "expected_vers": "vers:conan/<0.20.0" + "expected_vers": "vers:conan1/<0.20.0" }, { "test_index": 209, - "scheme": "conan", + "scheme": "conan1", "native": "<=0.20", - "expected_vers": "vers:conan/<=0.20.0" + "expected_vers": "vers:conan1/<=0.20.0" }, { "test_index": 210, - "scheme": "conan", + "scheme": "conan1", "native": "<0.20.1", - "expected_vers": "vers:conan/<0.20.1" + "expected_vers": "vers:conan1/<0.20.1" }, { "test_index": 211, - "scheme": "conan", + "scheme": "conan1", "native": "<0.20.0", - "expected_vers": "vers:conan/<0.20.0" + "expected_vers": "vers:conan1/<0.20.0" }, { "test_index": 212, - "scheme": "conan", + "scheme": "conan1", "native": "=0.20.0", - "expected_vers": "vers:conan/0.20.0" + "expected_vers": "vers:conan1/0.20.0" }, { "test_index": 213, - "scheme": "conan", + "scheme": "conan1", "native": "<=3.4.0", - "expected_vers": "vers:conan/<=3.4.0" + "expected_vers": "vers:conan1/<=3.4.0" }, { "test_index": 214, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.30", - "expected_vers": "vers:conan/1.0.30" + "expected_vers": "vers:conan1/1.0.30" }, { "test_index": 215, - "scheme": "conan", + "scheme": "conan1", "native": "=1.1.10", - "expected_vers": "vers:conan/1.1.10" + "expected_vers": "vers:conan1/1.1.10" }, { "test_index": 216, - "scheme": "conan", + "scheme": "conan1", "native": "<4.2.0", - "expected_vers": "vers:conan/<4.2.0" + "expected_vers": "vers:conan1/<4.2.0" }, { "test_index": 217, - "scheme": "conan", + "scheme": "conan1", "native": "<4.2.0", - "expected_vers": "vers:conan/<4.2.0" + "expected_vers": "vers:conan1/<4.2.0" }, { "test_index": 218, - "scheme": "conan", + "scheme": "conan1", "native": "<4.2.0", - "expected_vers": "vers:conan/<4.2.0" + "expected_vers": "vers:conan1/<4.2.0" }, { "test_index": 219, - "scheme": "conan", + "scheme": "conan1", "native": "<4.2.0", - "expected_vers": "vers:conan/<4.2.0" + "expected_vers": "vers:conan1/<4.2.0" }, { "test_index": 220, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.9.0 <=4.3.0", - "expected_vers": "vers:conan/>=3.9.0|<=4.3.0" + "expected_vers": "vers:conan1/>=3.9.0|<=4.3.0" }, { "test_index": 221, - "scheme": "conan", + "scheme": "conan1", "native": ">=4.0.0 <=4.3.0", - "expected_vers": "vers:conan/>=4.0.0|<=4.3.0" + "expected_vers": "vers:conan1/>=4.0.0|<=4.3.0" }, { "test_index": 222, - "scheme": "conan", + "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan/4.3.0" + "expected_vers": "vers:conan1/4.3.0" }, { "test_index": 223, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.9.0 <=4.3.0", - "expected_vers": "vers:conan/>=3.9.0|<=4.3.0" + "expected_vers": "vers:conan1/>=3.9.0|<=4.3.0" }, { "test_index": 224, - "scheme": "conan", + "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan/4.3.0" + "expected_vers": "vers:conan1/4.3.0" }, { "test_index": 225, - "scheme": "conan", + "scheme": "conan1", "native": "<=4.3.0", - "expected_vers": "vers:conan/<=4.3.0" + "expected_vers": "vers:conan1/<=4.3.0" }, { "test_index": 226, - "scheme": "conan", + "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan/4.3.0" + "expected_vers": "vers:conan1/4.3.0" }, { "test_index": 227, - "scheme": "conan", + "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan/4.3.0" + "expected_vers": "vers:conan1/4.3.0" }, { "test_index": 228, - "scheme": "conan", + "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan/4.3.0" + "expected_vers": "vers:conan1/4.3.0" }, { "test_index": 229, - "scheme": "conan", + "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan/4.3.0" + "expected_vers": "vers:conan1/4.3.0" }, { "test_index": 230, - "scheme": "conan", + "scheme": "conan1", "native": "<4.4.0", - "expected_vers": "vers:conan/<4.4.0" + "expected_vers": "vers:conan1/<4.4.0" }, { "test_index": 231, - "scheme": "conan", + "scheme": "conan1", "native": "<4.4.0", - "expected_vers": "vers:conan/<4.4.0" + "expected_vers": "vers:conan1/<4.4.0" }, { "test_index": 232, - "scheme": "conan", + "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan/4.3.0" + "expected_vers": "vers:conan1/4.3.0" }, { "test_index": 233, - "scheme": "conan", + "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan/4.3.0" + "expected_vers": "vers:conan1/4.3.0" }, { "test_index": 234, - "scheme": "conan", + "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan/4.4.0" + "expected_vers": "vers:conan1/4.4.0" }, { "test_index": 235, - "scheme": "conan", + "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan/4.4.0" + "expected_vers": "vers:conan1/4.4.0" }, { "test_index": 236, - "scheme": "conan", + "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan/4.4.0" + "expected_vers": "vers:conan1/4.4.0" }, { "test_index": 237, - "scheme": "conan", + "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan/4.3.0" + "expected_vers": "vers:conan1/4.3.0" }, { "test_index": 238, - "scheme": "conan", + "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan/4.4.0" + "expected_vers": "vers:conan1/4.4.0" }, { "test_index": 239, - "scheme": "conan", + "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan/4.4.0" + "expected_vers": "vers:conan1/4.4.0" }, { "test_index": 240, - "scheme": "conan", + "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan/4.4.0" + "expected_vers": "vers:conan1/4.4.0" }, { "test_index": 241, - "scheme": "conan", + "scheme": "conan1", "native": "<4.4.0", - "expected_vers": "vers:conan/<4.4.0" + "expected_vers": "vers:conan1/<4.4.0" }, { "test_index": 242, - "scheme": "conan", + "scheme": "conan1", "native": "<4.4.0", - "expected_vers": "vers:conan/<4.4.0" + "expected_vers": "vers:conan1/<4.4.0" }, { "test_index": 243, - "scheme": "conan", + "scheme": "conan1", "native": "<4.4.0", - "expected_vers": "vers:conan/<4.4.0" + "expected_vers": "vers:conan1/<4.4.0" }, { "test_index": 244, - "scheme": "conan", + "scheme": "conan1", "native": "<=4.4.0", - "expected_vers": "vers:conan/<=4.4.0" + "expected_vers": "vers:conan1/<=4.4.0" }, { "test_index": 245, - "scheme": "conan", + "scheme": "conan1", "native": "=4.0.3-35", - "expected_vers": "vers:conan/4.0.3-35" + "expected_vers": "vers:conan1/4.0.3-35" }, { "test_index": 246, - "scheme": "conan", + "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan/4.4.0" + "expected_vers": "vers:conan1/4.4.0" }, { "test_index": 247, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.9.0 <=4.4.0", - "expected_vers": "vers:conan/>=3.9.0|<=4.4.0" + "expected_vers": "vers:conan1/>=3.9.0|<=4.4.0" }, { "test_index": 248, - "scheme": "conan", + "scheme": "conan1", "native": "<=4.4.0", - "expected_vers": "vers:conan/<=4.4.0" + "expected_vers": "vers:conan1/<=4.4.0" }, { "test_index": 249, - "scheme": "conan", + "scheme": "conan1", "native": "<=4.4.0", - "expected_vers": "vers:conan/<=4.4.0" + "expected_vers": "vers:conan1/<=4.4.0" }, { "test_index": 250, - "scheme": "conan", + "scheme": "conan1", "native": "<=4.4.0", - "expected_vers": "vers:conan/<=4.4.0" + "expected_vers": "vers:conan1/<=4.4.0" }, { "test_index": 251, - "scheme": "conan", + "scheme": "conan1", "native": "<=4.4.0", - "expected_vers": "vers:conan/<=4.4.0" + "expected_vers": "vers:conan1/<=4.4.0" }, { "test_index": 252, - "scheme": "conan", + "scheme": "conan1", "native": "<=4.4.0", - "expected_vers": "vers:conan/<=4.4.0" + "expected_vers": "vers:conan1/<=4.4.0" }, { "test_index": 253, - "scheme": "conan", + "scheme": "conan1", "native": "<4.5.0", - "expected_vers": "vers:conan/<4.5.0" + "expected_vers": "vers:conan1/<4.5.0" }, { "test_index": 254, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.1", - "expected_vers": "vers:conan/<1.0.1" + "expected_vers": "vers:conan1/<1.0.1" }, { "test_index": 255, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.1", - "expected_vers": "vers:conan/<1.0.1" + "expected_vers": "vers:conan1/<1.0.1" }, { "test_index": 256, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.1", - "expected_vers": "vers:conan/<1.0.1" + "expected_vers": "vers:conan1/<1.0.1" }, { "test_index": 257, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.1", - "expected_vers": "vers:conan/<1.0.1" + "expected_vers": "vers:conan1/<1.0.1" }, { "test_index": 258, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.1", - "expected_vers": "vers:conan/<1.0.1" + "expected_vers": "vers:conan1/<1.0.1" }, { "test_index": 259, - "scheme": "conan", + "scheme": "conan1", "native": "=2.9.10", - "expected_vers": "vers:conan/2.9.10" + "expected_vers": "vers:conan1/2.9.10" }, { "test_index": 260, - "scheme": "conan", + "scheme": "conan1", "native": "=2.9.10", - "expected_vers": "vers:conan/2.9.10" + "expected_vers": "vers:conan1/2.9.10" }, { "test_index": 261, - "scheme": "conan", + "scheme": "conan1", "native": "<2.9.11", - "expected_vers": "vers:conan/<2.9.11" + "expected_vers": "vers:conan1/<2.9.11" }, { "test_index": 262, - "scheme": "conan", + "scheme": "conan1", "native": "<2.9.11", - "expected_vers": "vers:conan/<2.9.11" + "expected_vers": "vers:conan1/<2.9.11" }, { "test_index": 263, - "scheme": "conan", + "scheme": "conan1", "native": "<2.9.11", - "expected_vers": "vers:conan/<2.9.11" + "expected_vers": "vers:conan1/<2.9.11" }, { "test_index": 264, - "scheme": "conan", + "scheme": "conan1", "native": "<2.9.11", - "expected_vers": "vers:conan/<2.9.11" + "expected_vers": "vers:conan1/<2.9.11" }, { "test_index": 265, - "scheme": "conan", + "scheme": "conan1", "native": "<2.9.11", - "expected_vers": "vers:conan/<2.9.11" + "expected_vers": "vers:conan1/<2.9.11" }, { "test_index": 266, - "scheme": "conan", + "scheme": "conan1", "native": "<2.9.13", - "expected_vers": "vers:conan/<2.9.13" + "expected_vers": "vers:conan1/<2.9.13" }, { "test_index": 267, - "scheme": "conan", + "scheme": "conan1", "native": "<2.9.14", - "expected_vers": "vers:conan/<2.9.14" + "expected_vers": "vers:conan1/<2.9.14" }, { "test_index": 268, - "scheme": "conan", + "scheme": "conan1", "native": "<2.10.3", - "expected_vers": "vers:conan/<2.10.3" + "expected_vers": "vers:conan1/<2.10.3" }, { "test_index": 269, - "scheme": "conan", + "scheme": "conan1", "native": "<2.10.3", - "expected_vers": "vers:conan/<2.10.3" + "expected_vers": "vers:conan1/<2.10.3" }, { "test_index": 270, - "scheme": "conan", + "scheme": "conan1", "native": "<1.1.35", - "expected_vers": "vers:conan/<1.1.35" + "expected_vers": "vers:conan1/<1.1.35" }, { "test_index": 271, - "scheme": "conan", + "scheme": "conan1", "native": "<=0.11.4", - "expected_vers": "vers:conan/<=0.11.4" + "expected_vers": "vers:conan1/<=0.11.4" }, { "test_index": 272, - "scheme": "conan", + "scheme": "conan1", "native": "<0.12.1", - "expected_vers": "vers:conan/<0.12.1" + "expected_vers": "vers:conan1/<0.12.1" }, { "test_index": 273, - "scheme": "conan", + "scheme": "conan1", "native": "<0.12.1", - "expected_vers": "vers:conan/<0.12.1" + "expected_vers": "vers:conan1/<0.12.1" }, { "test_index": 274, - "scheme": "conan", + "scheme": "conan1", "native": "<=0.12.1", - "expected_vers": "vers:conan/<=0.12.1" + "expected_vers": "vers:conan1/<=0.12.1" }, { "test_index": 275, - "scheme": "conan", + "scheme": "conan1", "native": "<=0.12.1", - "expected_vers": "vers:conan/<=0.12.1" + "expected_vers": "vers:conan1/<=0.12.1" }, { "test_index": 276, - "scheme": "conan", + "scheme": "conan1", "native": "<=0.12.1", - "expected_vers": "vers:conan/<=0.12.1" + "expected_vers": "vers:conan1/<=0.12.1" }, { "test_index": 277, - "scheme": "conan", + "scheme": "conan1", "native": "=0.12.1", - "expected_vers": "vers:conan/0.12.1" + "expected_vers": "vers:conan1/0.12.1" }, { "test_index": 278, - "scheme": "conan", + "scheme": "conan1", "native": "=0.12.1", - "expected_vers": "vers:conan/0.12.1" + "expected_vers": "vers:conan1/0.12.1" }, { "test_index": 279, - "scheme": "conan", + "scheme": "conan1", "native": "=0.12.1", - "expected_vers": "vers:conan/0.12.1" + "expected_vers": "vers:conan1/0.12.1" }, { "test_index": 280, - "scheme": "conan", + "scheme": "conan1", "native": "<=5.4.0", - "expected_vers": "vers:conan/<=5.4.0" + "expected_vers": "vers:conan1/<=5.4.0" }, { "test_index": 281, - "scheme": "conan", + "scheme": "conan1", "native": "=5.4.0", - "expected_vers": "vers:conan/5.4.0" + "expected_vers": "vers:conan1/5.4.0" }, { "test_index": 282, - "scheme": "conan", + "scheme": "conan1", "native": "<=5.4.0", - "expected_vers": "vers:conan/<=5.4.0" + "expected_vers": "vers:conan1/<=5.4.0" }, { "test_index": 283, - "scheme": "conan", + "scheme": "conan1", "native": "=5.4.0", - "expected_vers": "vers:conan/5.4.0" + "expected_vers": "vers:conan1/5.4.0" }, { "test_index": 284, - "scheme": "conan", + "scheme": "conan1", "native": "=5.4.0", - "expected_vers": "vers:conan/5.4.0" + "expected_vers": "vers:conan1/5.4.0" }, { "test_index": 285, - "scheme": "conan", + "scheme": "conan1", "native": "=5.4.0", - "expected_vers": "vers:conan/5.4.0" + "expected_vers": "vers:conan1/5.4.0" }, { "test_index": 286, - "scheme": "conan", + "scheme": "conan1", "native": "=5.4.0", - "expected_vers": "vers:conan/5.4.0" + "expected_vers": "vers:conan1/5.4.0" }, { "test_index": 287, - "scheme": "conan", + "scheme": "conan1", "native": ">=5.1.0 <5.3.5||>=5.4.0 <5.4.4", - "expected_vers": "vers:conan/>=5.1.0|<5.3.5|>=5.4.0|<5.4.4" + "expected_vers": "vers:conan1/>=5.1.0|<5.3.5|>=5.4.0|<5.4.4" }, { "test_index": 288, - "scheme": "conan", + "scheme": "conan1", "native": "=5.4.3", - "expected_vers": "vers:conan/5.4.3" + "expected_vers": "vers:conan1/5.4.3" }, { "test_index": 289, - "scheme": "conan", + "scheme": "conan1", "native": ">=5.4.0 <=5.4.3", - "expected_vers": "vers:conan/>=5.4.0|<=5.4.3" + "expected_vers": "vers:conan1/>=5.4.0|<=5.4.3" }, { "test_index": 290, - "scheme": "conan", + "scheme": "conan1", "native": ">=5.4.0 <=5.4.4", - "expected_vers": "vers:conan/>=5.4.0|<=5.4.4" + "expected_vers": "vers:conan1/>=5.4.0|<=5.4.4" }, { "test_index": 291, - "scheme": "conan", + "scheme": "conan1", "native": ">=5.4.2 <=5.4.4", - "expected_vers": "vers:conan/>=5.4.2|<=5.4.4" + "expected_vers": "vers:conan1/>=5.4.2|<=5.4.4" }, { "test_index": 292, - "scheme": "conan", + "scheme": "conan1", "native": "=1.8.3", - "expected_vers": "vers:conan/1.8.3" + "expected_vers": "vers:conan1/1.8.3" }, { "test_index": 293, - "scheme": "conan", + "scheme": "conan1", "native": "<2.7.17||>=2.8.0 <2.16.8||>=2.17.0 <2.24.0", - "expected_vers": "vers:conan/<2.7.17|>=2.8.0|<2.16.8|>=2.17.0|<2.24.0" + "expected_vers": "vers:conan1/<2.7.17|>=2.8.0|<2.16.8|>=2.17.0|<2.24.0" }, { "test_index": 294, - "scheme": "conan", + "scheme": "conan1", "native": "=4.0.0", - "expected_vers": "vers:conan/4.0.0" + "expected_vers": "vers:conan1/4.0.0" }, { "test_index": 295, - "scheme": "conan", + "scheme": "conan1", "native": "<=6.2.1", - "expected_vers": "vers:conan/<=6.2.1" + "expected_vers": "vers:conan1/<=6.2.1" }, { "test_index": 296, - "scheme": "conan", + "scheme": "conan1", "native": "<6.3", - "expected_vers": "vers:conan/<6.3.0" + "expected_vers": "vers:conan1/<6.3.0" }, { "test_index": 297, - "scheme": "conan", + "scheme": "conan1", "native": "<3.7.2", - "expected_vers": "vers:conan/<3.7.2" + "expected_vers": "vers:conan1/<3.7.2" }, { "test_index": 298, - "scheme": "conan", + "scheme": "conan1", "native": "<3.7.3", - "expected_vers": "vers:conan/<3.7.3" + "expected_vers": "vers:conan1/<3.7.3" }, { "test_index": 299, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1" }, { "test_index": 300, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1" }, { "test_index": 301, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1" }, { "test_index": 302, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1" }, { "test_index": 303, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1" }, { "test_index": 304, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1" }, { "test_index": 305, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1" }, { "test_index": 306, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1" }, { "test_index": 307, - "scheme": "conan", + "scheme": "conan1", "native": "<2.5.2", - "expected_vers": "vers:conan/<2.5.2" + "expected_vers": "vers:conan1/<2.5.2" }, { "test_index": 308, - "scheme": "conan", + "scheme": "conan1", "native": "<2.5.2", - "expected_vers": "vers:conan/<2.5.2" + "expected_vers": "vers:conan1/<2.5.2" }, { "test_index": 309, - "scheme": "conan", + "scheme": "conan1", "native": "<2.5.2", - "expected_vers": "vers:conan/<2.5.2" + "expected_vers": "vers:conan1/<2.5.2" }, { "test_index": 310, - "scheme": "conan", + "scheme": "conan1", "native": "=2.3.0", - "expected_vers": "vers:conan/2.3.0" + "expected_vers": "vers:conan1/2.3.0" }, { "test_index": 311, - "scheme": "conan", + "scheme": "conan1", "native": "=2.3.0", - "expected_vers": "vers:conan/2.3.0" + "expected_vers": "vers:conan1/2.3.0" }, { "test_index": 312, - "scheme": "conan", + "scheme": "conan1", "native": "=2.3.0", - "expected_vers": "vers:conan/2.3.0" + "expected_vers": "vers:conan1/2.3.0" }, { "test_index": 313, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" }, { "test_index": 314, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.5.7", - "expected_vers": "vers:conan/<=2.5.7" + "expected_vers": "vers:conan1/<=2.5.7" }, { "test_index": 315, - "scheme": "conan", + "scheme": "conan1", "native": "<2.5.4", - "expected_vers": "vers:conan/<2.5.4" + "expected_vers": "vers:conan1/<2.5.4" }, { "test_index": 316, - "scheme": "conan", + "scheme": "conan1", "native": "<2.5.4", - "expected_vers": "vers:conan/<2.5.4" + "expected_vers": "vers:conan1/<2.5.4" }, { "test_index": 317, - "scheme": "conan", + "scheme": "conan1", "native": "<2.5.4", - "expected_vers": "vers:conan/<2.5.4" + "expected_vers": "vers:conan1/<2.5.4" }, { "test_index": 318, - "scheme": "conan", + "scheme": "conan1", "native": "<2.5.4", - "expected_vers": "vers:conan/<2.5.4" + "expected_vers": "vers:conan1/<2.5.4" }, { "test_index": 319, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.5.7", - "expected_vers": "vers:conan/<=2.5.7" + "expected_vers": "vers:conan1/<=2.5.7" }, { "test_index": 320, - "scheme": "conan", + "scheme": "conan1", "native": "<3.0.1", - "expected_vers": "vers:conan/<3.0.1" + "expected_vers": "vers:conan1/<3.0.1" }, { "test_index": 321, - "scheme": "conan", + "scheme": "conan1", "native": "<3.0.1", - "expected_vers": "vers:conan/<3.0.1" + "expected_vers": "vers:conan1/<3.0.1" }, { "test_index": 322, - "scheme": "conan", + "scheme": "conan1", "native": "<3.0.1", - "expected_vers": "vers:conan/<3.0.1" + "expected_vers": "vers:conan1/<3.0.1" }, { "test_index": 323, - "scheme": "conan", + "scheme": "conan1", "native": "<3.0.1", - "expected_vers": "vers:conan/<3.0.1" + "expected_vers": "vers:conan1/<3.0.1" }, { "test_index": 324, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" }, { "test_index": 325, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" }, { "test_index": 326, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" }, { "test_index": 327, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" }, { "test_index": 328, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" }, { "test_index": 329, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" }, { "test_index": 330, - "scheme": "conan", + "scheme": "conan1", "native": "<3.0.5", - "expected_vers": "vers:conan/<3.0.5" + "expected_vers": "vers:conan1/<3.0.5" }, { "test_index": 331, - "scheme": "conan", + "scheme": "conan1", "native": "<3.0.5", - "expected_vers": "vers:conan/<3.0.5" + "expected_vers": "vers:conan1/<3.0.5" }, { "test_index": 332, - "scheme": "conan", + "scheme": "conan1", "native": "<3.1.2", - "expected_vers": "vers:conan/<3.1.2" + "expected_vers": "vers:conan1/<3.1.2" }, { "test_index": 333, - "scheme": "conan", + "scheme": "conan1", "native": "=3.1.2", - "expected_vers": "vers:conan/3.1.2" + "expected_vers": "vers:conan1/3.1.2" }, { "test_index": 334, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.1.0 <3.1.4", - "expected_vers": "vers:conan/>=3.1.0|<3.1.4" + "expected_vers": "vers:conan1/>=3.1.0|<3.1.4" }, { "test_index": 335, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.3.1", - "expected_vers": "vers:conan/<=2.3.1" + "expected_vers": "vers:conan1/<=2.3.1" }, { "test_index": 336, - "scheme": "conan", + "scheme": "conan1", "native": "<=1.5.1||>=2.0.0 <2.4.0", - "expected_vers": "vers:conan/<=1.5.1|>=2.0.0|<2.4.0" + "expected_vers": "vers:conan1/<=1.5.1|>=2.0.0|<2.4.0" }, { "test_index": 337, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0" }, { "test_index": 338, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0" }, { "test_index": 339, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0" }, { "test_index": 340, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0" }, { "test_index": 341, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0" }, { "test_index": 342, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0" }, { "test_index": 343, - "scheme": "conan", + "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0" }, { "test_index": 344, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.3.1", - "expected_vers": "vers:conan/<=2.3.1" + "expected_vers": "vers:conan1/<=2.3.1" }, { "test_index": 345, - "scheme": "conan", + "scheme": "conan1", "native": "=2.3.1", - "expected_vers": "vers:conan/2.3.1" + "expected_vers": "vers:conan1/2.3.1" }, { "test_index": 346, - "scheme": "conan", + "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan/2.4.0" + "expected_vers": "vers:conan1/2.4.0" }, { "test_index": 347, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.4.0", - "expected_vers": "vers:conan/<=2.4.0" + "expected_vers": "vers:conan1/<=2.4.0" }, { "test_index": 348, - "scheme": "conan", + "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan/2.4.0" + "expected_vers": "vers:conan1/2.4.0" }, { "test_index": 349, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.1.1d <=1.1.1f", - "expected_vers": "vers:conan/>=1.1.1-d|<=1.1.1-f" + "expected_vers": "vers:conan1/>=1.1.1-d|<=1.1.1-f" }, { "test_index": 350, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.0.2 <=1.0.2v", - "expected_vers": "vers:conan/>=1.0.2|<=1.0.2" + "expected_vers": "vers:conan1/>=1.0.2|<=1.0.2" }, { "test_index": 351, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.0.2 <=1.0.2w||>=1.1.1 <=1.1.1h", - "expected_vers": "vers:conan/<=1.0.2-w|>=1.0.2|<=1.1.1-h|>=1.1.1" + "expected_vers": "vers:conan1/<=1.0.2-w|>=1.0.2|<=1.1.1-h|>=1.1.1" }, { "test_index": 352, - "scheme": "conan", + "scheme": "conan1", "native": "=1.0.2s", - "expected_vers": "vers:conan/1.0.2-s" + "expected_vers": "vers:conan1/1.0.2-s" }, { "test_index": 353, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.0.2 <1.0.2y||>=1.1.1 <1.1.1j", - "expected_vers": "vers:conan/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1" + "expected_vers": "vers:conan1/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1" }, { "test_index": 354, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.0.2 <1.0.2y||>=1.1.1 <1.1.1j", - "expected_vers": "vers:conan/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1" + "expected_vers": "vers:conan1/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1" }, { "test_index": 355, - "scheme": "conan", + "scheme": "conan1", "native": "<0", - "expected_vers": "vers:conan/<0.0.0" + "expected_vers": "vers:conan1/<0.0.0" }, { "test_index": 356, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.1.1 <1.1.1k", - "expected_vers": "vers:conan/<1.1.1-k|>=1.1.1" + "expected_vers": "vers:conan1/<1.1.1-k|>=1.1.1" }, { "test_index": 357, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.1.1h <1.1.1k", - "expected_vers": "vers:conan/>=1.1.1-h|<1.1.1-k" + "expected_vers": "vers:conan1/>=1.1.1-h|<1.1.1-k" }, { "test_index": 358, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.1.1 <1.1.1l", - "expected_vers": "vers:conan/<1.1.1-l|>=1.1.1" + "expected_vers": "vers:conan1/<1.1.1-l|>=1.1.1" }, { "test_index": 359, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.0.2 <1.0.2za||>=1.1.1 <1.1.1l", - "expected_vers": "vers:conan/<1.0.2-za|>=1.0.2|<1.1.1-l|>=1.1.1" + "expected_vers": "vers:conan1/<1.0.2-za|>=1.0.2|<1.1.1-l|>=1.1.1" }, { "test_index": 360, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.2||=1.1.0||=3.0.0", - "expected_vers": "vers:conan/<1.0.2|1.1.0|3.0.0" + "expected_vers": "vers:conan1/<1.0.2|1.1.0|3.0.0" }, { "test_index": 361, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.0.2 <1.1.1m||=3.0.0", - "expected_vers": "vers:conan/>=1.0.2|<1.1.1-m|3.0.0" + "expected_vers": "vers:conan1/>=1.0.2|<1.1.1-m|3.0.0" }, { "test_index": 362, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.0.2 <1.0.2zd||>=1.1.0 <1.1.1n||>=3.0.0 <3.0.2", - "expected_vers": "vers:conan/<1.0.2-zd|>=1.0.2|>=1.1.0|<1.1.1-n|>=3.0.0|<3.0.2" + "expected_vers": "vers:conan1/<1.0.2-zd|>=1.0.2|>=1.1.0|<1.1.1-n|>=3.0.0|<3.0.2" }, { "test_index": 363, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.0.2 <1.0.2ze||>=1.1.1 <1.1.1o||>=3.0.0 <3.0.3", - "expected_vers": "vers:conan/<1.0.2-ze|>=1.0.2|<1.1.1-o|>=1.1.1|>=3.0.0|<3.0.3" + "expected_vers": "vers:conan1/<1.0.2-ze|>=1.0.2|<1.1.1-o|>=1.1.1|>=3.0.0|<3.0.3" }, { "test_index": 364, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.0.0 <3.0.3", - "expected_vers": "vers:conan/>=3.0.0|<3.0.3" + "expected_vers": "vers:conan1/>=3.0.0|<3.0.3" }, { "test_index": 365, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.0.0 <3.0.3", - "expected_vers": "vers:conan/>=3.0.0|<3.0.3" + "expected_vers": "vers:conan1/>=3.0.0|<3.0.3" }, { "test_index": 366, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.0.0 <3.0.3", - "expected_vers": "vers:conan/>=3.0.0|<3.0.3" + "expected_vers": "vers:conan1/>=3.0.0|<3.0.3" }, { "test_index": 367, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.0.2 <1.0.2zf||>=1.1.1 <1.1.1p||>=3.0.0 <3.0.4", - "expected_vers": "vers:conan/<1.0.2-zf|>=1.0.2|<1.1.1-p|>=1.1.1|>=3.0.0|<3.0.4" + "expected_vers": "vers:conan1/<1.0.2-zf|>=1.0.2|<1.1.1-p|>=1.1.1|>=3.0.0|<3.0.4" }, { "test_index": 368, - "scheme": "conan", + "scheme": "conan1", "native": ">=1.1.1 <1.1.1q||>=3.0.0 <3.0.5", - "expected_vers": "vers:conan/<1.1.1-q|>=1.1.1|>=3.0.0|<3.0.5" + "expected_vers": "vers:conan1/<1.1.1-q|>=1.1.1|>=3.0.0|<3.0.5" }, { "test_index": 369, - "scheme": "conan", + "scheme": "conan1", "native": "=3.0.4", - "expected_vers": "vers:conan/3.0.4" + "expected_vers": "vers:conan1/3.0.4" }, { "test_index": 370, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.0.0 <3.0.6", - "expected_vers": "vers:conan/>=3.0.0|<3.0.6" + "expected_vers": "vers:conan1/>=3.0.0|<3.0.6" }, { "test_index": 371, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.0.0 <3.0.7", - "expected_vers": "vers:conan/>=3.0.0|<3.0.7" + "expected_vers": "vers:conan1/>=3.0.0|<3.0.7" }, { "test_index": 372, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.0.0 <3.0.7", - "expected_vers": "vers:conan/>=3.0.0|<3.0.7" + "expected_vers": "vers:conan1/>=3.0.0|<3.0.7" }, { "test_index": 373, - "scheme": "conan", + "scheme": "conan1", "native": ">=3.0.0 <=3.0.7", - "expected_vers": "vers:conan/>=3.0.0|<=3.0.7" + "expected_vers": "vers:conan1/>=3.0.0|<=3.0.7" }, { "test_index": 374, - "scheme": "conan", + "scheme": "conan1", "native": "<8.44", - "expected_vers": "vers:conan/<8.44.0" + "expected_vers": "vers:conan1/<8.44.0" }, { "test_index": 375, - "scheme": "conan", + "scheme": "conan1", "native": "<10.40", - "expected_vers": "vers:conan/<10.40.0" + "expected_vers": "vers:conan1/<10.40.0" }, { "test_index": 376, - "scheme": "conan", + "scheme": "conan1", "native": "<10.40", - "expected_vers": "vers:conan/<10.40.0" + "expected_vers": "vers:conan1/<10.40.0" }, { "test_index": 377, - "scheme": "conan", + "scheme": "conan1", "native": "<3.15.0", - "expected_vers": "vers:conan/<3.15.0" + "expected_vers": "vers:conan1/<3.15.0" }, { "test_index": 378, - "scheme": "conan", + "scheme": "conan1", "native": "<3.18.3||>=3.19.0 <3.19.5||>=3.20.0 <3.20.2||>=3.21.0 <3.21.6", - "expected_vers": "vers:conan/<3.18.3|>=3.19.0|<3.19.5|>=3.20.0|<3.20.2|>=3.21.0|<3.21.6" + "expected_vers": "vers:conan1/<3.18.3|>=3.19.0|<3.19.5|>=3.20.0|<3.20.2|>=3.21.0|<3.21.6" }, { "test_index": 379, - "scheme": "conan", + "scheme": "conan1", "native": "=1.3", - "expected_vers": "vers:conan/1.3.0" + "expected_vers": "vers:conan1/1.3.0" }, { "test_index": 380, - "scheme": "conan", + "scheme": "conan1", "native": "=2.2", - "expected_vers": "vers:conan/2.2.0" + "expected_vers": "vers:conan1/2.2.0" }, { "test_index": 381, - "scheme": "conan", + "scheme": "conan1", "native": "<=1.5.0", - "expected_vers": "vers:conan/<=1.5.0" + "expected_vers": "vers:conan1/<=1.5.0" }, { "test_index": 382, - "scheme": "conan", + "scheme": "conan1", "native": ">=4.0 <4.4.1", - "expected_vers": "vers:conan/>=4.0.0|<4.4.1" + "expected_vers": "vers:conan1/>=4.0.0|<4.4.1" }, { "test_index": 383, - "scheme": "conan", + "scheme": "conan1", "native": ">=4.0 <4.4.3", - "expected_vers": "vers:conan/>=4.0.0|<4.4.3" + "expected_vers": "vers:conan1/>=4.0.0|<4.4.3" }, { "test_index": 384, - "scheme": "conan", + "scheme": "conan1", "native": "<=2.0.1", - "expected_vers": "vers:conan/<=2.0.1" + "expected_vers": "vers:conan1/<=2.0.1" }, { "test_index": 385, - "scheme": "conan", + "scheme": "conan1", "native": "=cci.20200203", "expected_vers": null }, { "test_index": 386, - "scheme": "conan", + "scheme": "conan1", "native": "=2.27", - "expected_vers": "vers:conan/2.27.0" + "expected_vers": "vers:conan1/2.27.0" }, { "test_index": 387, - "scheme": "conan", + "scheme": "conan1", "native": "=2.27", - "expected_vers": "vers:conan/2.27.0" + "expected_vers": "vers:conan1/2.27.0" }, { "test_index": 388, - "scheme": "conan", + "scheme": "conan1", "native": "=8.6.11", - "expected_vers": "vers:conan/8.6.11" + "expected_vers": "vers:conan1/8.6.11" }, { "test_index": 389, - "scheme": "conan", + "scheme": "conan1", "native": "=5.0.0", - "expected_vers": "vers:conan/5.0.0" + "expected_vers": "vers:conan1/5.0.0" }, { "test_index": 390, - "scheme": "conan", + "scheme": "conan1", "native": ">=0.9.3 <=0.13.0", - "expected_vers": "vers:conan/>=0.9.3|<=0.13.0" + "expected_vers": "vers:conan1/>=0.9.3|<=0.13.0" }, { "test_index": 391, - "scheme": "conan", + "scheme": "conan1", "native": "<2021.02.22.00", - "expected_vers": "vers:conan/<2021.2.22+00" + "expected_vers": "vers:conan1/<2021.2.22+00" }, { "test_index": 392, - "scheme": "conan", + "scheme": "conan1", "native": "<1.05.01", - "expected_vers": "vers:conan/<1.5.1" + "expected_vers": "vers:conan1/<1.5.1" }, { "test_index": 393, - "scheme": "conan", + "scheme": "conan1", "native": "<0.9.6", - "expected_vers": "vers:conan/<0.9.6" + "expected_vers": "vers:conan1/<0.9.6" }, { "test_index": 394, - "scheme": "conan", + "scheme": "conan1", "native": "<0.9.6", - "expected_vers": "vers:conan/<0.9.6" + "expected_vers": "vers:conan1/<0.9.6" }, { "test_index": 395, - "scheme": "conan", + "scheme": "conan1", "native": ">=19.0.0 <=20.8.0", - "expected_vers": "vers:conan/>=19.0.0|<=20.8.0" + "expected_vers": "vers:conan1/>=19.0.0|<=20.8.0" }, { "test_index": 396, - "scheme": "conan", + "scheme": "conan1", "native": ">=0.19.0 <0.30.0", - "expected_vers": "vers:conan/>=0.19.0|<0.30.0" + "expected_vers": "vers:conan1/>=0.19.0|<0.30.0" }, { "test_index": 397, - "scheme": "conan", + "scheme": "conan1", "native": ">=0.26.0 <0.30.0", - "expected_vers": "vers:conan/>=0.26.0|<0.30.0" + "expected_vers": "vers:conan1/>=0.26.0|<0.30.0" }, { "test_index": 398, - "scheme": "conan", + "scheme": "conan1", "native": "<0.30.0", - "expected_vers": "vers:conan/<0.30.0" + "expected_vers": "vers:conan1/<0.30.0" }, { "test_index": 399, - "scheme": "conan", + "scheme": "conan1", "native": "<0.33.1||>0.33.1 <0.34.1", - "expected_vers": "vers:conan/<0.33.1|>0.33.1|<0.34.1" + "expected_vers": "vers:conan1/<0.33.1|>0.33.1|<0.34.1" }, { "test_index": 400, - "scheme": "conan", + "scheme": "conan1", "native": ">=0.34.0 <0.34.2||>=0.35.0 <0.35.2", - "expected_vers": "vers:conan/>=0.34.0|<0.34.2|>=0.35.0|<0.35.2" + "expected_vers": "vers:conan1/>=0.34.0|<0.34.2|>=0.35.0|<0.35.2" }, { "test_index": 401, - "scheme": "conan", + "scheme": "conan1", "native": "<0.38.1", - "expected_vers": "vers:conan/<0.38.1" + "expected_vers": "vers:conan1/<0.38.1" }, { "test_index": 402, - "scheme": "conan", + "scheme": "conan1", "native": ">=0.37.0 <0.38.2", - "expected_vers": "vers:conan/>=0.37.0|<0.38.2" + "expected_vers": "vers:conan1/>=0.37.0|<0.38.2" }, { "test_index": 403, - "scheme": "conan", + "scheme": "conan1", "native": "<0.38.1", - "expected_vers": "vers:conan/<0.38.1" + "expected_vers": "vers:conan1/<0.38.1" }, { "test_index": 404, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.2||>=2.0.0 <2.0.2", - "expected_vers": "vers:conan/<1.0.2|>=2.0.0|<2.0.2" + "expected_vers": "vers:conan1/<1.0.2|>=2.0.0|<2.0.2" }, { "test_index": 405, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.2||>=2.0.0 <2.0.2", - "expected_vers": "vers:conan/<1.0.2|>=2.0.0|<2.0.2" + "expected_vers": "vers:conan1/<1.0.2|>=2.0.0|<2.0.2" }, { "test_index": 406, - "scheme": "conan", + "scheme": "conan1", "native": "<1.0.2||>=2.0.0 <2.0.2", - "expected_vers": "vers:conan/<1.0.2|>=2.0.0|<2.0.2" + "expected_vers": "vers:conan1/<1.0.2|>=2.0.0|<2.0.2" }, { "test_index": 407, - "scheme": "conan", + "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan/4.3.0" + "expected_vers": "vers:conan1/4.3.0" }, { "test_index": 408, - "scheme": "conan", + "scheme": "conan1", "native": "<4.4.0", - "expected_vers": "vers:conan/<4.4.0" + "expected_vers": "vers:conan1/<4.4.0" }, { "test_index": 409, - "scheme": "conan", + "scheme": "conan1", "native": "<4.5.0", - "expected_vers": "vers:conan/<4.5.0" + "expected_vers": "vers:conan1/<4.5.0" }, { "test_index": 410, - "scheme": "conan", + "scheme": "conan1", "native": "<4.5.0", - "expected_vers": "vers:conan/<4.5.0" + "expected_vers": "vers:conan1/<4.5.0" }, { "test_index": 411, - "scheme": "conan", + "scheme": "conan1", "native": "<4.5.0", - "expected_vers": "vers:conan/<4.5.0" + "expected_vers": "vers:conan1/<4.5.0" }, { "test_index": 412, - "scheme": "conan", + "scheme": "conan1", "native": "<4.5.0", - "expected_vers": "vers:conan/<4.5.0" + "expected_vers": "vers:conan1/<4.5.0" }, { "test_index": 413, - "scheme": "conan", + "scheme": "conan1", "native": "<4.6.0", - "expected_vers": "vers:conan/<4.6.0" + "expected_vers": "vers:conan1/<4.6.0" }, { "test_index": 414, - "scheme": "conan", + "scheme": "conan1", "native": "<4.6.0", - "expected_vers": "vers:conan/<4.6.0" + "expected_vers": "vers:conan1/<4.6.0" }, { "test_index": 415, - "scheme": "conan", + "scheme": "conan1", "native": "<4.7.0", - "expected_vers": "vers:conan/<4.7.0" + "expected_vers": "vers:conan1/<4.7.0" }, { "test_index": 416, - "scheme": "conan", + "scheme": "conan1", "native": ">=4.6.0 <4.8.0", - "expected_vers": "vers:conan/>=4.6.0|<4.8.0" + "expected_vers": "vers:conan1/>=4.6.0|<4.8.0" }, { "test_index": 417, - "scheme": "conan", + "scheme": "conan1", "native": "<4.8.1", - "expected_vers": "vers:conan/<4.8.1" + "expected_vers": "vers:conan1/<4.8.1" }, { "test_index": 418, - "scheme": "conan", + "scheme": "conan1", "native": "<=5.0.0", - "expected_vers": "vers:conan/<=5.0.0" + "expected_vers": "vers:conan1/<=5.0.0" }, { "test_index": 419, - "scheme": "conan", + "scheme": "conan1", "native": ">=5.0.0 <5.1.1", - "expected_vers": "vers:conan/>=5.0.0|<5.1.1" + "expected_vers": "vers:conan1/>=5.0.0|<5.1.1" }, { "test_index": 420, - "scheme": "conan", + "scheme": "conan1", "native": "<5.2.0", - "expected_vers": "vers:conan/<5.2.0" + "expected_vers": "vers:conan1/<5.2.0" }, { "test_index": 421, - "scheme": "conan", + "scheme": "conan1", "native": "<5.2.0", - "expected_vers": "vers:conan/<5.2.0" + "expected_vers": "vers:conan1/<5.2.0" }, { "test_index": 422, - "scheme": "conan", + "scheme": "conan1", "native": "<5.4.0", - "expected_vers": "vers:conan/<5.4.0" + "expected_vers": "vers:conan1/<5.4.0" }, { "test_index": 423, - "scheme": "conan", + "scheme": "conan1", "native": "<5.5.0", - "expected_vers": "vers:conan/<5.5.0" + "expected_vers": "vers:conan1/<5.5.0" }, { "test_index": 424, - "scheme": "conan", + "scheme": "conan1", "native": "=5.3.0", - "expected_vers": "vers:conan/5.3.0" + "expected_vers": "vers:conan1/5.3.0" }, { "test_index": 425, - "scheme": "conan", + "scheme": "conan1", "native": "<5.5.1", - "expected_vers": "vers:conan/<5.5.1" + "expected_vers": "vers:conan1/<5.5.1" }, { "test_index": 426, - "scheme": "conan", + "scheme": "conan1", "native": "<5.5.2", - "expected_vers": "vers:conan/<5.5.2" + "expected_vers": "vers:conan1/<5.5.2" }, { "test_index": 427, - "scheme": "conan", + "scheme": "conan1", "native": "<5.5.0", - "expected_vers": "vers:conan/<5.5.0" + "expected_vers": "vers:conan1/<5.5.0" }, { "test_index": 428, - "scheme": "conan", + "scheme": "conan1", "native": "<4.3.3", - "expected_vers": "vers:conan/<4.3.3" + "expected_vers": "vers:conan1/<4.3.3" } ] From 0c3283bf0e4173ff6de75847b3b7665b6cefb619 Mon Sep 17 00:00:00 2001 From: "John M. Horan" Date: Thu, 23 Feb 2023 13:25:44 -0800 Subject: [PATCH 68/78] Add test and fix failing tests #101 Reference: https://github.com/nexB/univers/issues/101 Signed-off-by: John M. Horan --- src/univers/version_range.py | 2 +- tests/test_version_range.py | 22 +++++++++++++++++----- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/src/univers/version_range.py b/src/univers/version_range.py index 6c16b978..7d48cfb2 100644 --- a/src/univers/version_range.py +++ b/src/univers/version_range.py @@ -1244,5 +1244,5 @@ def build_range_from_github_advisory_constraint(scheme: str, string: str): "nuget": "nuget", "pypi": "pypi", "packagist": "composer", - "conan": "conan1", + "conan1": "conan1", } diff --git a/tests/test_version_range.py b/tests/test_version_range.py index 608f85e7..ccae53d1 100644 --- a/tests/test_version_range.py +++ b/tests/test_version_range.py @@ -11,6 +11,7 @@ from univers.version_constraint import VersionConstraint from univers.version_range import RANGE_CLASS_BY_SCHEMES +from univers.version_range import Conan1VersionRange from univers.version_range import GemVersionRange from univers.version_range import InvalidVersionRange from univers.version_range import MattermostVersionRange @@ -20,6 +21,7 @@ from univers.version_range import PypiVersionRange from univers.version_range import VersionRange from univers.version_range import from_gitlab_native +from univers.versions import InvalidVersion from univers.versions import NugetVersion from univers.versions import OpensslVersion from univers.versions import PypiVersion @@ -353,6 +355,19 @@ def test_pypi_gitlab_version_range_parse(test_case): assert str(result) == test_case["expected_vers"] +@pytest.mark.parametrize("test_case", json.load(open("./tests/data/conan_advisory.json"))) +def test_conan_gitlab_version_range_parse(test_case): + if test_case["expected_vers"] is None: + with pytest.raises(InvalidVersion): + Conan1VersionRange.from_native(string=test_case["native"]) + return + result = from_gitlab_native( + gitlab_scheme=test_case["scheme"], + string=test_case["native"], + ) + assert str(result) == test_case["expected_vers"] + + @pytest.mark.parametrize("test_case", json.load(open("./tests/data/npm_gitlab.json"))) def test_npm_gitlab_version_range_parse(test_case): result = from_gitlab_native( @@ -400,13 +415,10 @@ def test_npm_advisory_version_range_parse(test_case): @pytest.mark.parametrize("test_case", json.load(open("./tests/data/conan_advisory.json"))) def test_conan_advisory_version_range_parse(test_case): if test_case["expected_vers"] is None: - # with pytest.raises(InvalidVersionRange): with pytest.raises(InvalidVersion): - # ConanVersionRange.from_native(string=test_case["conan_native"]) - ConanVersionRange.from_native(string=test_case["native"]) + Conan1VersionRange.from_native(string=test_case["native"]) return - result = ConanVersionRange.from_native( - # string=test_case["conan_native"], + result = Conan1VersionRange.from_native( string=test_case["native"], ) assert str(result) == test_case["expected_vers"] From 231039b061c5c3ca4d1552eedfbdc9f6a8e56331 Mon Sep 17 00:00:00 2001 From: "John M. Horan" Date: Fri, 24 Feb 2023 10:42:08 -0800 Subject: [PATCH 69/78] Fix 'gitlab_scheme'-related test failures #101 Reference: https://github.com/nexB/univers/issues/101 Signed-off-by: John M. Horan --- src/univers/version_range.py | 2 +- tests/data/conan_advisory.json | 1284 +++++++++++++++++++++----------- tests/test_version_range.py | 2 +- 3 files changed, 858 insertions(+), 430 deletions(-) diff --git a/src/univers/version_range.py b/src/univers/version_range.py index 7d48cfb2..6c16b978 100644 --- a/src/univers/version_range.py +++ b/src/univers/version_range.py @@ -1244,5 +1244,5 @@ def build_range_from_github_advisory_constraint(scheme: str, string: str): "nuget": "nuget", "pypi": "pypi", "packagist": "composer", - "conan1": "conan1", + "conan": "conan1", } diff --git a/tests/data/conan_advisory.json b/tests/data/conan_advisory.json index 393b9c27..cdd552c3 100644 --- a/tests/data/conan_advisory.json +++ b/tests/data/conan_advisory.json @@ -3,2568 +3,2996 @@ "test_index": 1, "scheme": "conan1", "native": ">=5.1.0 <=5.1.1", - "expected_vers": "vers:conan1/>=5.1.0|<=5.1.1" + "expected_vers": "vers:conan1/>=5.1.0|<=5.1.1", + "gitlab_scheme": "conan" }, { "test_index": 2, "scheme": "conan1", "native": "=5.2.5", - "expected_vers": "vers:conan1/5.2.5" + "expected_vers": "vers:conan1/5.2.5", + "gitlab_scheme": "conan" }, { "test_index": 3, "scheme": "conan1", "native": "<3.5.4", - "expected_vers": "vers:conan1/<3.5.4" + "expected_vers": "vers:conan1/<3.5.4", + "gitlab_scheme": "conan" }, { "test_index": 4, "scheme": "conan1", "native": "=3.7", - "expected_vers": "vers:conan1/3.7.0" + "expected_vers": "vers:conan1/3.7.0", + "gitlab_scheme": "conan" }, { "test_index": 5, "scheme": "conan1", "native": "<0", - "expected_vers": "vers:conan1/<0.0.0" + "expected_vers": "vers:conan1/<0.0.0", + "gitlab_scheme": "conan" }, { "test_index": 6, "scheme": "conan1", "native": "<2.17.3", - "expected_vers": "vers:conan1/<2.17.3" + "expected_vers": "vers:conan1/<2.17.3", + "gitlab_scheme": "conan" }, { "test_index": 7, "scheme": "conan1", "native": "<=2.18.1", - "expected_vers": "vers:conan1/<=2.18.1" + "expected_vers": "vers:conan1/<=2.18.1", + "gitlab_scheme": "conan" }, { "test_index": 8, "scheme": "conan1", "native": ">=1.11.34 <2.19.3", - "expected_vers": "vers:conan1/>=1.11.34|<2.19.3" + "expected_vers": "vers:conan1/>=1.11.34|<2.19.3", + "gitlab_scheme": "conan" }, { "test_index": 9, "scheme": "conan1", "native": "<1.0.8", - "expected_vers": "vers:conan1/<1.0.8" + "expected_vers": "vers:conan1/<1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 10, "scheme": "conan1", "native": "=1.16.0", - "expected_vers": "vers:conan1/1.16.0" + "expected_vers": "vers:conan1/1.16.0", + "gitlab_scheme": "conan" }, { "test_index": 11, "scheme": "conan1", "native": "<1.16.0", - "expected_vers": "vers:conan1/<1.16.0" + "expected_vers": "vers:conan1/<1.16.0", + "gitlab_scheme": "conan" }, { "test_index": 12, "scheme": "conan1", "native": ">=1.0.0 <1.17.2", - "expected_vers": "vers:conan1/>=1.0.0|<1.17.2" + "expected_vers": "vers:conan1/>=1.0.0|<1.17.2", + "gitlab_scheme": "conan" }, { "test_index": 13, "scheme": "conan1", "native": "<1.17.4", - "expected_vers": "vers:conan1/<1.17.4" + "expected_vers": "vers:conan1/<1.17.4", + "gitlab_scheme": "conan" }, { "test_index": 14, "scheme": "conan1", "native": "<0.13.7||>=0.14.0 <0.14.11||>=0.15.0 <0.15.2", - "expected_vers": "vers:conan1/<0.13.7|>=0.14.0|<0.14.11|>=0.15.0|<0.15.2" + "expected_vers": "vers:conan1/<0.13.7|>=0.14.0|<0.14.11|>=0.15.0|<0.15.2", + "gitlab_scheme": "conan" }, { "test_index": 15, "scheme": "conan1", "native": "<=1.3.0", - "expected_vers": "vers:conan1/<=1.3.0" + "expected_vers": "vers:conan1/<=1.3.0", + "gitlab_scheme": "conan" }, { "test_index": 16, "scheme": "conan1", "native": "<=1.3.0", - "expected_vers": "vers:conan1/<=1.3.0" + "expected_vers": "vers:conan1/<=1.3.0", + "gitlab_scheme": "conan" }, { "test_index": 17, "scheme": "conan1", "native": "<2.9.3", - "expected_vers": "vers:conan1/<2.9.3" + "expected_vers": "vers:conan1/<2.9.3", + "gitlab_scheme": "conan" }, { "test_index": 18, "scheme": "conan1", "native": "<3.1.0", - "expected_vers": "vers:conan1/<3.1.0" + "expected_vers": "vers:conan1/<3.1.0", + "gitlab_scheme": "conan" }, { "test_index": 19, "scheme": "conan1", "native": "<=0.5.8", - "expected_vers": "vers:conan1/<=0.5.8" + "expected_vers": "vers:conan1/<=0.5.8", + "gitlab_scheme": "conan" }, { "test_index": 20, "scheme": "conan1", "native": "<=0.1.12", - "expected_vers": "vers:conan1/<=0.1.12" + "expected_vers": "vers:conan1/<=0.1.12", + "gitlab_scheme": "conan" }, { "test_index": 21, "scheme": "conan1", "native": "<=0.1.12", - "expected_vers": "vers:conan1/<=0.1.12" + "expected_vers": "vers:conan1/<=0.1.12", + "gitlab_scheme": "conan" }, { "test_index": 22, "scheme": "conan1", "native": "<=2.1.27", - "expected_vers": "vers:conan1/<=2.1.27" + "expected_vers": "vers:conan1/<=2.1.27", + "gitlab_scheme": "conan" }, { "test_index": 23, "scheme": "conan1", "native": ">=2.1.17 <=2.1.27", - "expected_vers": "vers:conan1/>=2.1.17|<=2.1.27" + "expected_vers": "vers:conan1/>=2.1.17|<=2.1.27", + "gitlab_scheme": "conan" }, { "test_index": 24, "scheme": "conan1", "native": "<=3.6.6", - "expected_vers": "vers:conan1/<=3.6.6" + "expected_vers": "vers:conan1/<=3.6.6", + "gitlab_scheme": "conan" }, { "test_index": 25, "scheme": "conan1", "native": "<=3.6.6", - "expected_vers": "vers:conan1/<=3.6.6" + "expected_vers": "vers:conan1/<=3.6.6", + "gitlab_scheme": "conan" }, { "test_index": 26, "scheme": "conan1", "native": "<=3.6.6", - "expected_vers": "vers:conan1/<=3.6.6" + "expected_vers": "vers:conan1/<=3.6.6", + "gitlab_scheme": "conan" }, { "test_index": 27, "scheme": "conan1", "native": "<=3.6.6", - "expected_vers": "vers:conan1/<=3.6.6" + "expected_vers": "vers:conan1/<=3.6.6", + "gitlab_scheme": "conan" }, { "test_index": 28, "scheme": "conan1", "native": "<3.6.7", - "expected_vers": "vers:conan1/<3.6.7" + "expected_vers": "vers:conan1/<3.6.7", + "gitlab_scheme": "conan" }, { "test_index": 29, "scheme": "conan1", "native": "<3.6.7", - "expected_vers": "vers:conan1/<3.6.7" + "expected_vers": "vers:conan1/<3.6.7", + "gitlab_scheme": "conan" }, { "test_index": 30, "scheme": "conan1", "native": "<3.6.7", - "expected_vers": "vers:conan1/<3.6.7" + "expected_vers": "vers:conan1/<3.6.7", + "gitlab_scheme": "conan" }, { "test_index": 31, "scheme": "conan1", "native": "=3.6.7", - "expected_vers": "vers:conan1/3.6.7" + "expected_vers": "vers:conan1/3.6.7", + "gitlab_scheme": "conan" }, { "test_index": 32, "scheme": "conan1", "native": "<2021.07.22.00", - "expected_vers": "vers:conan1/<2021.7.22+00" + "expected_vers": "vers:conan1/<2021.7.22+00", + "gitlab_scheme": "conan" }, { "test_index": 33, "scheme": "conan1", "native": "<1.0.12", - "expected_vers": "vers:conan1/<1.0.12" + "expected_vers": "vers:conan1/<1.0.12", + "gitlab_scheme": "conan" }, { "test_index": 34, "scheme": "conan1", "native": "<1.0.12", - "expected_vers": "vers:conan1/<1.0.12" + "expected_vers": "vers:conan1/<1.0.12", + "gitlab_scheme": "conan" }, { "test_index": 35, "scheme": "conan1", "native": "<1.0.12", - "expected_vers": "vers:conan1/<1.0.12" + "expected_vers": "vers:conan1/<1.0.12", + "gitlab_scheme": "conan" }, { "test_index": 36, "scheme": "conan1", "native": ">=3.3.0 <=3.4.0", - "expected_vers": "vers:conan1/>=3.3.0|<=3.4.0" + "expected_vers": "vers:conan1/>=3.3.0|<=3.4.0", + "gitlab_scheme": "conan" }, { "test_index": 37, "scheme": "conan1", "native": "=2.42.6", - "expected_vers": "vers:conan1/2.42.6" + "expected_vers": "vers:conan1/2.42.6", + "gitlab_scheme": "conan" }, { "test_index": 38, "scheme": "conan1", "native": "<=5.1.4", - "expected_vers": "vers:conan1/<=5.1.4" + "expected_vers": "vers:conan1/<=5.1.4", + "gitlab_scheme": "conan" }, { "test_index": 39, "scheme": "conan1", "native": "=5.1.4", - "expected_vers": "vers:conan1/5.1.4" + "expected_vers": "vers:conan1/5.1.4", + "gitlab_scheme": "conan" }, { "test_index": 40, "scheme": "conan1", "native": "=5.2.1", - "expected_vers": "vers:conan1/5.2.1" + "expected_vers": "vers:conan1/5.2.1", + "gitlab_scheme": "conan" }, { "test_index": 41, "scheme": "conan1", "native": "<2.65.3", - "expected_vers": "vers:conan1/<2.65.3" + "expected_vers": "vers:conan1/<2.65.3", + "gitlab_scheme": "conan" }, { "test_index": 42, "scheme": "conan1", "native": ">=2.60.0 <=2.62.4", - "expected_vers": "vers:conan1/>=2.60.0|<=2.62.4" + "expected_vers": "vers:conan1/>=2.60.0|<=2.62.4", + "gitlab_scheme": "conan" }, { "test_index": 43, "scheme": "conan1", "native": "<2.66.7||>=2.67.0 <2.67.4", - "expected_vers": "vers:conan1/<2.66.7|>=2.67.0|<2.67.4" + "expected_vers": "vers:conan1/<2.66.7|>=2.67.0|<2.67.4", + "gitlab_scheme": "conan" }, { "test_index": 44, "scheme": "conan1", "native": "<2.66.6||>=2.67.0 <2.67.3", - "expected_vers": "vers:conan1/<2.66.6|>=2.67.0|<2.67.3" + "expected_vers": "vers:conan1/<2.66.6|>=2.67.0|<2.67.3", + "gitlab_scheme": "conan" }, { "test_index": 45, "scheme": "conan1", "native": "<2.66.8", - "expected_vers": "vers:conan1/<2.66.8" + "expected_vers": "vers:conan1/<2.66.8", + "gitlab_scheme": "conan" }, { "test_index": 46, "scheme": "conan1", "native": "<2.63.6", - "expected_vers": "vers:conan1/<2.63.6" + "expected_vers": "vers:conan1/<2.63.6", + "gitlab_scheme": "conan" }, { "test_index": 47, "scheme": "conan1", "native": "<=3.2", - "expected_vers": "vers:conan1/<=3.2.0" + "expected_vers": "vers:conan1/<=3.2.0", + "gitlab_scheme": "conan" }, { "test_index": 48, "scheme": "conan1", "native": "<=3.2", - "expected_vers": "vers:conan1/<=3.2.0" + "expected_vers": "vers:conan1/<=3.2.0", + "gitlab_scheme": "conan" }, { "test_index": 49, "scheme": "conan1", "native": "=2.8.107", - "expected_vers": "vers:conan1/2.8.107" + "expected_vers": "vers:conan1/2.8.107", + "gitlab_scheme": "conan" }, { "test_index": 50, "scheme": "conan1", "native": "=2.8.107", - "expected_vers": "vers:conan1/2.8.107" + "expected_vers": "vers:conan1/2.8.107", + "gitlab_scheme": "conan" }, { "test_index": 51, "scheme": "conan1", "native": "=2.8.107", - "expected_vers": "vers:conan1/2.8.107" + "expected_vers": "vers:conan1/2.8.107", + "gitlab_scheme": "conan" }, { "test_index": 52, "scheme": "conan1", "native": "=2.8.107", - "expected_vers": "vers:conan1/2.8.107" + "expected_vers": "vers:conan1/2.8.107", + "gitlab_scheme": "conan" }, { "test_index": 53, "scheme": "conan1", "native": "=2.8.107", - "expected_vers": "vers:conan1/2.8.107" + "expected_vers": "vers:conan1/2.8.107", + "gitlab_scheme": "conan" }, { "test_index": 54, "scheme": "conan1", "native": "=2.8.107", - "expected_vers": "vers:conan1/2.8.107" + "expected_vers": "vers:conan1/2.8.107", + "gitlab_scheme": "conan" }, { "test_index": 55, "scheme": "conan1", "native": "=2.9.0", - "expected_vers": "vers:conan1/2.9.0" + "expected_vers": "vers:conan1/2.9.0", + "gitlab_scheme": "conan" }, { "test_index": 56, "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0" + "expected_vers": "vers:conan1/4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 57, "scheme": "conan1", "native": "<=1.12.0", - "expected_vers": "vers:conan1/<=1.12.0" + "expected_vers": "vers:conan1/<=1.12.0", + "gitlab_scheme": "conan" }, { "test_index": 58, "scheme": "conan1", "native": "<=1.12.0", - "expected_vers": "vers:conan1/<=1.12.0" + "expected_vers": "vers:conan1/<=1.12.0", + "gitlab_scheme": "conan" }, { "test_index": 59, "scheme": "conan1", "native": "<=1.12.0", - "expected_vers": "vers:conan1/<=1.12.0" + "expected_vers": "vers:conan1/<=1.12.0", + "gitlab_scheme": "conan" }, { "test_index": 60, "scheme": "conan1", "native": "<=1.12.0", - "expected_vers": "vers:conan1/<=1.12.0" + "expected_vers": "vers:conan1/<=1.12.0", + "gitlab_scheme": "conan" }, { "test_index": 61, "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1", + "gitlab_scheme": "conan" }, { "test_index": 62, "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1", + "gitlab_scheme": "conan" }, { "test_index": 63, "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1", + "gitlab_scheme": "conan" }, { "test_index": 64, "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1", + "gitlab_scheme": "conan" }, { "test_index": 65, "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1", + "gitlab_scheme": "conan" }, { "test_index": 66, "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1", + "gitlab_scheme": "conan" }, { "test_index": 67, "scheme": "conan1", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1" + "expected_vers": "vers:conan1/1.13.1-1", + "gitlab_scheme": "conan" }, { "test_index": 68, "scheme": "conan1", "native": "=1.10.4", - "expected_vers": "vers:conan1/1.10.4" + "expected_vers": "vers:conan1/1.10.4", + "gitlab_scheme": "conan" }, { "test_index": 69, "scheme": "conan1", "native": "=1.10.4", - "expected_vers": "vers:conan1/1.10.4" + "expected_vers": "vers:conan1/1.10.4", + "gitlab_scheme": "conan" }, { "test_index": 70, "scheme": "conan1", "native": "=1.10.4", - "expected_vers": "vers:conan1/1.10.4" + "expected_vers": "vers:conan1/1.10.4", + "gitlab_scheme": "conan" }, { "test_index": 71, "scheme": "conan1", "native": "<=0.14.0", - "expected_vers": "vers:conan1/<=0.14.0" + "expected_vers": "vers:conan1/<=0.14.0", + "gitlab_scheme": "conan" }, { "test_index": 72, "scheme": "conan1", "native": "<=2.13.1", - "expected_vers": "vers:conan1/<=2.13.1" + "expected_vers": "vers:conan1/<=2.13.1", + "gitlab_scheme": "conan" }, { "test_index": 73, "scheme": "conan1", "native": "<2.0.23", - "expected_vers": "vers:conan1/<2.0.23" + "expected_vers": "vers:conan1/<2.0.23", + "gitlab_scheme": "conan" }, { "test_index": 74, "scheme": "conan1", "native": "<2.0.25", - "expected_vers": "vers:conan1/<2.0.25" + "expected_vers": "vers:conan1/<2.0.25", + "gitlab_scheme": "conan" }, { "test_index": 75, "scheme": "conan1", "native": "<2.0.25", - "expected_vers": "vers:conan1/<2.0.25" + "expected_vers": "vers:conan1/<2.0.25", + "gitlab_scheme": "conan" }, { "test_index": 76, "scheme": "conan1", "native": ">=2.0.0 <2.0.17", - "expected_vers": "vers:conan1/>=2.0.0|<2.0.17" + "expected_vers": "vers:conan1/>=2.0.0|<2.0.17", + "gitlab_scheme": "conan" }, { "test_index": 77, "scheme": "conan1", "native": "=2.0.24", - "expected_vers": "vers:conan1/2.0.24" + "expected_vers": "vers:conan1/2.0.24", + "gitlab_scheme": "conan" }, { "test_index": 78, "scheme": "conan1", "native": "<2.0.27", - "expected_vers": "vers:conan1/<2.0.27" + "expected_vers": "vers:conan1/<2.0.27", + "gitlab_scheme": "conan" }, { "test_index": 79, "scheme": "conan1", "native": "<2.0.26", - "expected_vers": "vers:conan1/<2.0.26" + "expected_vers": "vers:conan1/<2.0.26", + "gitlab_scheme": "conan" }, { "test_index": 80, "scheme": "conan1", "native": "=3.0.6", - "expected_vers": "vers:conan1/3.0.6" + "expected_vers": "vers:conan1/3.0.6", + "gitlab_scheme": "conan" }, { "test_index": 81, "scheme": "conan1", "native": "=3.0.6", - "expected_vers": "vers:conan1/3.0.6" + "expected_vers": "vers:conan1/3.0.6", + "gitlab_scheme": "conan" }, { "test_index": 82, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 83, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 84, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 85, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 86, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 87, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 88, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 89, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 90, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 91, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 92, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 93, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 94, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 95, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 96, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 97, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 98, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 99, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 100, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 101, "scheme": "conan1", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 102, "scheme": "conan1", "native": "<=2.3.0", - "expected_vers": "vers:conan1/<=2.3.0" + "expected_vers": "vers:conan1/<=2.3.0", + "gitlab_scheme": "conan" }, { "test_index": 103, "scheme": "conan1", "native": "<=2.3.0", - "expected_vers": "vers:conan1/<=2.3.0" + "expected_vers": "vers:conan1/<=2.3.0", + "gitlab_scheme": "conan" }, { "test_index": 104, "scheme": "conan1", "native": "=2.3.0", - "expected_vers": "vers:conan1/2.3.0" + "expected_vers": "vers:conan1/2.3.0", + "gitlab_scheme": "conan" }, { "test_index": 105, "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0" + "expected_vers": "vers:conan1/2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 106, "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0" + "expected_vers": "vers:conan1/2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 107, "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0" + "expected_vers": "vers:conan1/2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 108, "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0" + "expected_vers": "vers:conan1/2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 109, "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0" + "expected_vers": "vers:conan1/2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 110, "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0" + "expected_vers": "vers:conan1/2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 111, "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0" + "expected_vers": "vers:conan1/2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 112, "scheme": "conan1", "native": "<=2.4.0", - "expected_vers": "vers:conan1/<=2.4.0" + "expected_vers": "vers:conan1/<=2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 113, "scheme": "conan1", "native": "<=2.4.0", - "expected_vers": "vers:conan1/<=2.4.0" + "expected_vers": "vers:conan1/<=2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 114, "scheme": "conan1", "native": "", - "expected_vers": "vers:conan1/" + "expected_vers": "vers:conan1/", + "gitlab_scheme": "conan" }, { "test_index": 115, "scheme": "conan1", "native": "<2021-10-15", - "expected_vers": "vers:conan1/<2021.0.0-10-15" + "expected_vers": "vers:conan1/<2021.0.0-10-15", + "gitlab_scheme": "conan" }, { "test_index": 116, "scheme": "conan1", "native": "<=2.4.0", - "expected_vers": "vers:conan1/<=2.4.0" + "expected_vers": "vers:conan1/<=2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 117, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 118, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 119, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 120, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 121, "scheme": "conan1", "native": "=2.3.0", - "expected_vers": "vers:conan1/2.3.0" + "expected_vers": "vers:conan1/2.3.0", + "gitlab_scheme": "conan" }, { "test_index": 122, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 123, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 124, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 125, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 126, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 127, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 128, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 129, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 130, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 131, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 132, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 133, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 134, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 135, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 136, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 137, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 138, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 139, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 140, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 141, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 142, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 143, "scheme": "conan1", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0" + "expected_vers": "vers:conan1/3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 144, "scheme": "conan1", "native": "", - "expected_vers": "vers:conan1/" + "expected_vers": "vers:conan1/", + "gitlab_scheme": "conan" }, { "test_index": 145, "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0" + "expected_vers": "vers:conan1/2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 146, "scheme": "conan1", "native": "<=0.14", - "expected_vers": "vers:conan1/<=0.14.0" + "expected_vers": "vers:conan1/<=0.14.0", + "gitlab_scheme": "conan" }, { "test_index": 147, "scheme": "conan1", "native": "<1.80.0", - "expected_vers": "vers:conan1/<1.80.0" + "expected_vers": "vers:conan1/<1.80.0", + "gitlab_scheme": "conan" }, { "test_index": 148, "scheme": "conan1", "native": "<1.80.0", - "expected_vers": "vers:conan1/<1.80.0" + "expected_vers": "vers:conan1/<1.80.0", + "gitlab_scheme": "conan" }, { "test_index": 149, "scheme": "conan1", "native": "<1.80.0", - "expected_vers": "vers:conan1/<1.80.0" + "expected_vers": "vers:conan1/<1.80.0", + "gitlab_scheme": "conan" }, { "test_index": 150, "scheme": "conan1", "native": "<1.80.0", - "expected_vers": "vers:conan1/<1.80.0" + "expected_vers": "vers:conan1/<1.80.0", + "gitlab_scheme": "conan" }, { "test_index": 151, "scheme": "conan1", "native": "<1.80.0", - "expected_vers": "vers:conan1/<1.80.0" + "expected_vers": "vers:conan1/<1.80.0", + "gitlab_scheme": "conan" }, { "test_index": 152, "scheme": "conan1", "native": "<1.80.0", - "expected_vers": "vers:conan1/<1.80.0" + "expected_vers": "vers:conan1/<1.80.0", + "gitlab_scheme": "conan" }, { "test_index": 153, "scheme": "conan1", "native": "=3.4.1", - "expected_vers": "vers:conan1/3.4.1" + "expected_vers": "vers:conan1/3.4.1", + "gitlab_scheme": "conan" }, { "test_index": 154, "scheme": "conan1", "native": ">=3.4.0 <3.4.2", - "expected_vers": "vers:conan1/>=3.4.0|<3.4.2" + "expected_vers": "vers:conan1/>=3.4.0|<3.4.2", + "gitlab_scheme": "conan" }, { "test_index": 155, "scheme": "conan1", "native": "<3.5.2", - "expected_vers": "vers:conan1/<3.5.2" + "expected_vers": "vers:conan1/<3.5.2", + "gitlab_scheme": "conan" }, { "test_index": 156, "scheme": "conan1", "native": "<3.5.2", - "expected_vers": "vers:conan1/<3.5.2" + "expected_vers": "vers:conan1/<3.5.2", + "gitlab_scheme": "conan" }, { "test_index": 157, "scheme": "conan1", "native": ">=3.4.1 <=3.5.2", - "expected_vers": "vers:conan1/>=3.4.1|<=3.5.2" + "expected_vers": "vers:conan1/>=3.4.1|<=3.5.2", + "gitlab_scheme": "conan" }, { "test_index": 158, "scheme": "conan1", "native": "=3.6.0", - "expected_vers": "vers:conan1/3.6.0" + "expected_vers": "vers:conan1/3.6.0", + "gitlab_scheme": "conan" }, { "test_index": 159, "scheme": "conan1", "native": "=3.6.0", - "expected_vers": "vers:conan1/3.6.0" + "expected_vers": "vers:conan1/3.6.0", + "gitlab_scheme": "conan" }, { "test_index": 160, "scheme": "conan1", "native": ">=3.0.0 <3.6.2", - "expected_vers": "vers:conan1/>=3.0.0|<3.6.2" + "expected_vers": "vers:conan1/>=3.0.0|<3.6.2", + "gitlab_scheme": "conan" }, { "test_index": 161, "scheme": "conan1", "native": ">=0.6.0 <=0.6.1", - "expected_vers": "vers:conan1/>=0.6.0|<=0.6.1" + "expected_vers": "vers:conan1/>=0.6.0|<=0.6.1", + "gitlab_scheme": "conan" }, { "test_index": 162, "scheme": "conan1", "native": ">=0.6.0 <=0.6.1", - "expected_vers": "vers:conan1/>=0.6.0|<=0.6.1" + "expected_vers": "vers:conan1/>=0.6.0|<=0.6.1", + "gitlab_scheme": "conan" }, { "test_index": 163, "scheme": "conan1", "native": "=3.3", - "expected_vers": "vers:conan1/3.3.0" + "expected_vers": "vers:conan1/3.3.0", + "gitlab_scheme": "conan" }, { "test_index": 164, "scheme": "conan1", "native": ">=7.29.0 <=7.71.1", - "expected_vers": "vers:conan1/>=7.29.0|<=7.71.1" + "expected_vers": "vers:conan1/>=7.29.0|<=7.71.1", + "gitlab_scheme": "conan" }, { "test_index": 165, "scheme": "conan1", "native": ">=7.21.0 <7.74.0", - "expected_vers": "vers:conan1/>=7.21.0|<7.74.0" + "expected_vers": "vers:conan1/>=7.21.0|<7.74.0", + "gitlab_scheme": "conan" }, { "test_index": 166, "scheme": "conan1", "native": ">=7.41.0 <7.74.0", - "expected_vers": "vers:conan1/>=7.41.0|<7.74.0" + "expected_vers": "vers:conan1/>=7.41.0|<7.74.0", + "gitlab_scheme": "conan" }, { "test_index": 167, "scheme": "conan1", "native": ">=7.1.1 <=7.75.0", - "expected_vers": "vers:conan1/>=7.1.1|<=7.75.0" + "expected_vers": "vers:conan1/>=7.1.1|<=7.75.0", + "gitlab_scheme": "conan" }, { "test_index": 168, "scheme": "conan1", "native": ">=7.63.0 <=7.75.0", - "expected_vers": "vers:conan1/>=7.63.0|<=7.75.0" + "expected_vers": "vers:conan1/>=7.63.0|<=7.75.0", + "gitlab_scheme": "conan" }, { "test_index": 169, "scheme": "conan1", "native": ">=7.10.4 <7.77.0", - "expected_vers": "vers:conan1/>=7.10.4|<7.77.0" + "expected_vers": "vers:conan1/>=7.10.4|<7.77.0", + "gitlab_scheme": "conan" }, { "test_index": 170, "scheme": "conan1", "native": ">=7.73.0 <=7.78.0", - "expected_vers": "vers:conan1/>=7.73.0|<=7.78.0" + "expected_vers": "vers:conan1/>=7.73.0|<=7.78.0", + "gitlab_scheme": "conan" }, { "test_index": 171, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 172, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 173, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 174, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 175, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 176, "scheme": "conan1", "native": "<=1.0.8", - "expected_vers": "vers:conan1/<=1.0.8" + "expected_vers": "vers:conan1/<=1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 177, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 178, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 179, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 180, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 181, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 182, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 183, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 184, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 185, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 186, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 187, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 188, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 189, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 190, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 191, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 192, "scheme": "conan1", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8" + "expected_vers": "vers:conan1/1.0.8", + "gitlab_scheme": "conan" }, { "test_index": 193, "scheme": "conan1", "native": "=1.0.9", - "expected_vers": "vers:conan1/1.0.9" + "expected_vers": "vers:conan1/1.0.9", + "gitlab_scheme": "conan" }, { "test_index": 194, "scheme": "conan1", "native": "=0.4.0", - "expected_vers": "vers:conan1/0.4.0" + "expected_vers": "vers:conan1/0.4.0", + "gitlab_scheme": "conan" }, { "test_index": 195, "scheme": "conan1", "native": "=0.4.0", - "expected_vers": "vers:conan1/0.4.0" + "expected_vers": "vers:conan1/0.4.0", + "gitlab_scheme": "conan" }, { "test_index": 196, "scheme": "conan1", "native": "=0.4.1", - "expected_vers": "vers:conan1/0.4.1" + "expected_vers": "vers:conan1/0.4.1", + "gitlab_scheme": "conan" }, { "test_index": 197, "scheme": "conan1", "native": "<0.28.4", - "expected_vers": "vers:conan1/<0.28.4" + "expected_vers": "vers:conan1/<0.28.4", + "gitlab_scheme": "conan" }, { "test_index": 198, "scheme": "conan1", "native": "<0.28.4", - "expected_vers": "vers:conan1/<0.28.4" + "expected_vers": "vers:conan1/<0.28.4", + "gitlab_scheme": "conan" }, { "test_index": 199, "scheme": "conan1", "native": "=2.0.4", - "expected_vers": "vers:conan1/2.0.4" + "expected_vers": "vers:conan1/2.0.4", + "gitlab_scheme": "conan" }, { "test_index": 200, "scheme": "conan1", "native": "<2.0.4", - "expected_vers": "vers:conan1/<2.0.4" + "expected_vers": "vers:conan1/<2.0.4", + "gitlab_scheme": "conan" }, { "test_index": 201, "scheme": "conan1", "native": "=2.0.90", - "expected_vers": "vers:conan1/2.0.90" + "expected_vers": "vers:conan1/2.0.90", + "gitlab_scheme": "conan" }, { "test_index": 202, "scheme": "conan1", "native": ">1.5.3 <=2.0.90", - "expected_vers": "vers:conan1/>1.5.3|<=2.0.90" + "expected_vers": "vers:conan1/>1.5.3|<=2.0.90", + "gitlab_scheme": "conan" }, { "test_index": 203, "scheme": "conan1", "native": "<9d", - "expected_vers": "vers:conan1/<9.0.0-d" + "expected_vers": "vers:conan1/<9.0.0-d", + "gitlab_scheme": "conan" }, { "test_index": 204, "scheme": "conan1", "native": "<9d", - "expected_vers": "vers:conan1/<9.0.0-d" + "expected_vers": "vers:conan1/<9.0.0-d", + "gitlab_scheme": "conan" }, { "test_index": 205, "scheme": "conan1", "native": "<1.64", - "expected_vers": "vers:conan1/<1.64.0" + "expected_vers": "vers:conan1/<1.64.0", + "gitlab_scheme": "conan" }, { "test_index": 206, "scheme": "conan1", "native": "<3.1.7", - "expected_vers": "vers:conan1/<3.1.7" + "expected_vers": "vers:conan1/<3.1.7", + "gitlab_scheme": "conan" }, { "test_index": 207, "scheme": "conan1", "native": "=1.6.0", - "expected_vers": "vers:conan1/1.6.0" + "expected_vers": "vers:conan1/1.6.0", + "gitlab_scheme": "conan" }, { "test_index": 208, "scheme": "conan1", "native": "<0.20", - "expected_vers": "vers:conan1/<0.20.0" + "expected_vers": "vers:conan1/<0.20.0", + "gitlab_scheme": "conan" }, { "test_index": 209, "scheme": "conan1", "native": "<=0.20", - "expected_vers": "vers:conan1/<=0.20.0" + "expected_vers": "vers:conan1/<=0.20.0", + "gitlab_scheme": "conan" }, { "test_index": 210, "scheme": "conan1", "native": "<0.20.1", - "expected_vers": "vers:conan1/<0.20.1" + "expected_vers": "vers:conan1/<0.20.1", + "gitlab_scheme": "conan" }, { "test_index": 211, "scheme": "conan1", "native": "<0.20.0", - "expected_vers": "vers:conan1/<0.20.0" + "expected_vers": "vers:conan1/<0.20.0", + "gitlab_scheme": "conan" }, { "test_index": 212, "scheme": "conan1", "native": "=0.20.0", - "expected_vers": "vers:conan1/0.20.0" + "expected_vers": "vers:conan1/0.20.0", + "gitlab_scheme": "conan" }, { "test_index": 213, "scheme": "conan1", "native": "<=3.4.0", - "expected_vers": "vers:conan1/<=3.4.0" + "expected_vers": "vers:conan1/<=3.4.0", + "gitlab_scheme": "conan" }, { "test_index": 214, "scheme": "conan1", "native": "=1.0.30", - "expected_vers": "vers:conan1/1.0.30" + "expected_vers": "vers:conan1/1.0.30", + "gitlab_scheme": "conan" }, { "test_index": 215, "scheme": "conan1", "native": "=1.1.10", - "expected_vers": "vers:conan1/1.1.10" + "expected_vers": "vers:conan1/1.1.10", + "gitlab_scheme": "conan" }, { "test_index": 216, "scheme": "conan1", "native": "<4.2.0", - "expected_vers": "vers:conan1/<4.2.0" + "expected_vers": "vers:conan1/<4.2.0", + "gitlab_scheme": "conan" }, { "test_index": 217, "scheme": "conan1", "native": "<4.2.0", - "expected_vers": "vers:conan1/<4.2.0" + "expected_vers": "vers:conan1/<4.2.0", + "gitlab_scheme": "conan" }, { "test_index": 218, "scheme": "conan1", "native": "<4.2.0", - "expected_vers": "vers:conan1/<4.2.0" + "expected_vers": "vers:conan1/<4.2.0", + "gitlab_scheme": "conan" }, { "test_index": 219, "scheme": "conan1", "native": "<4.2.0", - "expected_vers": "vers:conan1/<4.2.0" + "expected_vers": "vers:conan1/<4.2.0", + "gitlab_scheme": "conan" }, { "test_index": 220, "scheme": "conan1", "native": ">=3.9.0 <=4.3.0", - "expected_vers": "vers:conan1/>=3.9.0|<=4.3.0" + "expected_vers": "vers:conan1/>=3.9.0|<=4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 221, "scheme": "conan1", "native": ">=4.0.0 <=4.3.0", - "expected_vers": "vers:conan1/>=4.0.0|<=4.3.0" + "expected_vers": "vers:conan1/>=4.0.0|<=4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 222, "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0" + "expected_vers": "vers:conan1/4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 223, "scheme": "conan1", "native": ">=3.9.0 <=4.3.0", - "expected_vers": "vers:conan1/>=3.9.0|<=4.3.0" + "expected_vers": "vers:conan1/>=3.9.0|<=4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 224, "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0" + "expected_vers": "vers:conan1/4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 225, "scheme": "conan1", "native": "<=4.3.0", - "expected_vers": "vers:conan1/<=4.3.0" + "expected_vers": "vers:conan1/<=4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 226, "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0" + "expected_vers": "vers:conan1/4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 227, "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0" + "expected_vers": "vers:conan1/4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 228, "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0" + "expected_vers": "vers:conan1/4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 229, "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0" + "expected_vers": "vers:conan1/4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 230, "scheme": "conan1", "native": "<4.4.0", - "expected_vers": "vers:conan1/<4.4.0" + "expected_vers": "vers:conan1/<4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 231, "scheme": "conan1", "native": "<4.4.0", - "expected_vers": "vers:conan1/<4.4.0" + "expected_vers": "vers:conan1/<4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 232, "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0" + "expected_vers": "vers:conan1/4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 233, "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0" + "expected_vers": "vers:conan1/4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 234, "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0" + "expected_vers": "vers:conan1/4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 235, "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0" + "expected_vers": "vers:conan1/4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 236, "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0" + "expected_vers": "vers:conan1/4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 237, "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0" + "expected_vers": "vers:conan1/4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 238, "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0" + "expected_vers": "vers:conan1/4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 239, "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0" + "expected_vers": "vers:conan1/4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 240, "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0" + "expected_vers": "vers:conan1/4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 241, "scheme": "conan1", "native": "<4.4.0", - "expected_vers": "vers:conan1/<4.4.0" + "expected_vers": "vers:conan1/<4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 242, "scheme": "conan1", "native": "<4.4.0", - "expected_vers": "vers:conan1/<4.4.0" + "expected_vers": "vers:conan1/<4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 243, "scheme": "conan1", "native": "<4.4.0", - "expected_vers": "vers:conan1/<4.4.0" + "expected_vers": "vers:conan1/<4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 244, "scheme": "conan1", "native": "<=4.4.0", - "expected_vers": "vers:conan1/<=4.4.0" + "expected_vers": "vers:conan1/<=4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 245, "scheme": "conan1", "native": "=4.0.3-35", - "expected_vers": "vers:conan1/4.0.3-35" + "expected_vers": "vers:conan1/4.0.3-35", + "gitlab_scheme": "conan" }, { "test_index": 246, "scheme": "conan1", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0" + "expected_vers": "vers:conan1/4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 247, "scheme": "conan1", "native": ">=3.9.0 <=4.4.0", - "expected_vers": "vers:conan1/>=3.9.0|<=4.4.0" + "expected_vers": "vers:conan1/>=3.9.0|<=4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 248, "scheme": "conan1", "native": "<=4.4.0", - "expected_vers": "vers:conan1/<=4.4.0" + "expected_vers": "vers:conan1/<=4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 249, "scheme": "conan1", "native": "<=4.4.0", - "expected_vers": "vers:conan1/<=4.4.0" + "expected_vers": "vers:conan1/<=4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 250, "scheme": "conan1", "native": "<=4.4.0", - "expected_vers": "vers:conan1/<=4.4.0" + "expected_vers": "vers:conan1/<=4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 251, "scheme": "conan1", "native": "<=4.4.0", - "expected_vers": "vers:conan1/<=4.4.0" + "expected_vers": "vers:conan1/<=4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 252, "scheme": "conan1", "native": "<=4.4.0", - "expected_vers": "vers:conan1/<=4.4.0" + "expected_vers": "vers:conan1/<=4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 253, "scheme": "conan1", "native": "<4.5.0", - "expected_vers": "vers:conan1/<4.5.0" + "expected_vers": "vers:conan1/<4.5.0", + "gitlab_scheme": "conan" }, { "test_index": 254, "scheme": "conan1", "native": "<1.0.1", - "expected_vers": "vers:conan1/<1.0.1" + "expected_vers": "vers:conan1/<1.0.1", + "gitlab_scheme": "conan" }, { "test_index": 255, "scheme": "conan1", "native": "<1.0.1", - "expected_vers": "vers:conan1/<1.0.1" + "expected_vers": "vers:conan1/<1.0.1", + "gitlab_scheme": "conan" }, { "test_index": 256, "scheme": "conan1", "native": "<1.0.1", - "expected_vers": "vers:conan1/<1.0.1" + "expected_vers": "vers:conan1/<1.0.1", + "gitlab_scheme": "conan" }, { "test_index": 257, "scheme": "conan1", "native": "<1.0.1", - "expected_vers": "vers:conan1/<1.0.1" + "expected_vers": "vers:conan1/<1.0.1", + "gitlab_scheme": "conan" }, { "test_index": 258, "scheme": "conan1", "native": "<1.0.1", - "expected_vers": "vers:conan1/<1.0.1" + "expected_vers": "vers:conan1/<1.0.1", + "gitlab_scheme": "conan" }, { "test_index": 259, "scheme": "conan1", "native": "=2.9.10", - "expected_vers": "vers:conan1/2.9.10" + "expected_vers": "vers:conan1/2.9.10", + "gitlab_scheme": "conan" }, { "test_index": 260, "scheme": "conan1", "native": "=2.9.10", - "expected_vers": "vers:conan1/2.9.10" + "expected_vers": "vers:conan1/2.9.10", + "gitlab_scheme": "conan" }, { "test_index": 261, "scheme": "conan1", "native": "<2.9.11", - "expected_vers": "vers:conan1/<2.9.11" + "expected_vers": "vers:conan1/<2.9.11", + "gitlab_scheme": "conan" }, { "test_index": 262, "scheme": "conan1", "native": "<2.9.11", - "expected_vers": "vers:conan1/<2.9.11" + "expected_vers": "vers:conan1/<2.9.11", + "gitlab_scheme": "conan" }, { "test_index": 263, "scheme": "conan1", "native": "<2.9.11", - "expected_vers": "vers:conan1/<2.9.11" + "expected_vers": "vers:conan1/<2.9.11", + "gitlab_scheme": "conan" }, { "test_index": 264, "scheme": "conan1", "native": "<2.9.11", - "expected_vers": "vers:conan1/<2.9.11" + "expected_vers": "vers:conan1/<2.9.11", + "gitlab_scheme": "conan" }, { "test_index": 265, "scheme": "conan1", "native": "<2.9.11", - "expected_vers": "vers:conan1/<2.9.11" + "expected_vers": "vers:conan1/<2.9.11", + "gitlab_scheme": "conan" }, { "test_index": 266, "scheme": "conan1", "native": "<2.9.13", - "expected_vers": "vers:conan1/<2.9.13" + "expected_vers": "vers:conan1/<2.9.13", + "gitlab_scheme": "conan" }, { "test_index": 267, "scheme": "conan1", "native": "<2.9.14", - "expected_vers": "vers:conan1/<2.9.14" + "expected_vers": "vers:conan1/<2.9.14", + "gitlab_scheme": "conan" }, { "test_index": 268, "scheme": "conan1", "native": "<2.10.3", - "expected_vers": "vers:conan1/<2.10.3" + "expected_vers": "vers:conan1/<2.10.3", + "gitlab_scheme": "conan" }, { "test_index": 269, "scheme": "conan1", "native": "<2.10.3", - "expected_vers": "vers:conan1/<2.10.3" + "expected_vers": "vers:conan1/<2.10.3", + "gitlab_scheme": "conan" }, { "test_index": 270, "scheme": "conan1", "native": "<1.1.35", - "expected_vers": "vers:conan1/<1.1.35" + "expected_vers": "vers:conan1/<1.1.35", + "gitlab_scheme": "conan" }, { "test_index": 271, "scheme": "conan1", "native": "<=0.11.4", - "expected_vers": "vers:conan1/<=0.11.4" + "expected_vers": "vers:conan1/<=0.11.4", + "gitlab_scheme": "conan" }, { "test_index": 272, "scheme": "conan1", "native": "<0.12.1", - "expected_vers": "vers:conan1/<0.12.1" + "expected_vers": "vers:conan1/<0.12.1", + "gitlab_scheme": "conan" }, { "test_index": 273, "scheme": "conan1", "native": "<0.12.1", - "expected_vers": "vers:conan1/<0.12.1" + "expected_vers": "vers:conan1/<0.12.1", + "gitlab_scheme": "conan" }, { "test_index": 274, "scheme": "conan1", "native": "<=0.12.1", - "expected_vers": "vers:conan1/<=0.12.1" + "expected_vers": "vers:conan1/<=0.12.1", + "gitlab_scheme": "conan" }, { "test_index": 275, "scheme": "conan1", "native": "<=0.12.1", - "expected_vers": "vers:conan1/<=0.12.1" + "expected_vers": "vers:conan1/<=0.12.1", + "gitlab_scheme": "conan" }, { "test_index": 276, "scheme": "conan1", "native": "<=0.12.1", - "expected_vers": "vers:conan1/<=0.12.1" + "expected_vers": "vers:conan1/<=0.12.1", + "gitlab_scheme": "conan" }, { "test_index": 277, "scheme": "conan1", "native": "=0.12.1", - "expected_vers": "vers:conan1/0.12.1" + "expected_vers": "vers:conan1/0.12.1", + "gitlab_scheme": "conan" }, { "test_index": 278, "scheme": "conan1", "native": "=0.12.1", - "expected_vers": "vers:conan1/0.12.1" + "expected_vers": "vers:conan1/0.12.1", + "gitlab_scheme": "conan" }, { "test_index": 279, "scheme": "conan1", "native": "=0.12.1", - "expected_vers": "vers:conan1/0.12.1" + "expected_vers": "vers:conan1/0.12.1", + "gitlab_scheme": "conan" }, { "test_index": 280, "scheme": "conan1", "native": "<=5.4.0", - "expected_vers": "vers:conan1/<=5.4.0" + "expected_vers": "vers:conan1/<=5.4.0", + "gitlab_scheme": "conan" }, { "test_index": 281, "scheme": "conan1", "native": "=5.4.0", - "expected_vers": "vers:conan1/5.4.0" + "expected_vers": "vers:conan1/5.4.0", + "gitlab_scheme": "conan" }, { "test_index": 282, "scheme": "conan1", "native": "<=5.4.0", - "expected_vers": "vers:conan1/<=5.4.0" + "expected_vers": "vers:conan1/<=5.4.0", + "gitlab_scheme": "conan" }, { "test_index": 283, "scheme": "conan1", "native": "=5.4.0", - "expected_vers": "vers:conan1/5.4.0" + "expected_vers": "vers:conan1/5.4.0", + "gitlab_scheme": "conan" }, { "test_index": 284, "scheme": "conan1", "native": "=5.4.0", - "expected_vers": "vers:conan1/5.4.0" + "expected_vers": "vers:conan1/5.4.0", + "gitlab_scheme": "conan" }, { "test_index": 285, "scheme": "conan1", "native": "=5.4.0", - "expected_vers": "vers:conan1/5.4.0" + "expected_vers": "vers:conan1/5.4.0", + "gitlab_scheme": "conan" }, { "test_index": 286, "scheme": "conan1", "native": "=5.4.0", - "expected_vers": "vers:conan1/5.4.0" + "expected_vers": "vers:conan1/5.4.0", + "gitlab_scheme": "conan" }, { "test_index": 287, "scheme": "conan1", "native": ">=5.1.0 <5.3.5||>=5.4.0 <5.4.4", - "expected_vers": "vers:conan1/>=5.1.0|<5.3.5|>=5.4.0|<5.4.4" + "expected_vers": "vers:conan1/>=5.1.0|<5.3.5|>=5.4.0|<5.4.4", + "gitlab_scheme": "conan" }, { "test_index": 288, "scheme": "conan1", "native": "=5.4.3", - "expected_vers": "vers:conan1/5.4.3" + "expected_vers": "vers:conan1/5.4.3", + "gitlab_scheme": "conan" }, { "test_index": 289, "scheme": "conan1", "native": ">=5.4.0 <=5.4.3", - "expected_vers": "vers:conan1/>=5.4.0|<=5.4.3" + "expected_vers": "vers:conan1/>=5.4.0|<=5.4.3", + "gitlab_scheme": "conan" }, { "test_index": 290, "scheme": "conan1", "native": ">=5.4.0 <=5.4.4", - "expected_vers": "vers:conan1/>=5.4.0|<=5.4.4" + "expected_vers": "vers:conan1/>=5.4.0|<=5.4.4", + "gitlab_scheme": "conan" }, { "test_index": 291, "scheme": "conan1", "native": ">=5.4.2 <=5.4.4", - "expected_vers": "vers:conan1/>=5.4.2|<=5.4.4" + "expected_vers": "vers:conan1/>=5.4.2|<=5.4.4", + "gitlab_scheme": "conan" }, { "test_index": 292, "scheme": "conan1", "native": "=1.8.3", - "expected_vers": "vers:conan1/1.8.3" + "expected_vers": "vers:conan1/1.8.3", + "gitlab_scheme": "conan" }, { "test_index": 293, "scheme": "conan1", "native": "<2.7.17||>=2.8.0 <2.16.8||>=2.17.0 <2.24.0", - "expected_vers": "vers:conan1/<2.7.17|>=2.8.0|<2.16.8|>=2.17.0|<2.24.0" + "expected_vers": "vers:conan1/<2.7.17|>=2.8.0|<2.16.8|>=2.17.0|<2.24.0", + "gitlab_scheme": "conan" }, { "test_index": 294, "scheme": "conan1", "native": "=4.0.0", - "expected_vers": "vers:conan1/4.0.0" + "expected_vers": "vers:conan1/4.0.0", + "gitlab_scheme": "conan" }, { "test_index": 295, "scheme": "conan1", "native": "<=6.2.1", - "expected_vers": "vers:conan1/<=6.2.1" + "expected_vers": "vers:conan1/<=6.2.1", + "gitlab_scheme": "conan" }, { "test_index": 296, "scheme": "conan1", "native": "<6.3", - "expected_vers": "vers:conan1/<6.3.0" + "expected_vers": "vers:conan1/<6.3.0", + "gitlab_scheme": "conan" }, { "test_index": 297, "scheme": "conan1", "native": "<3.7.2", - "expected_vers": "vers:conan1/<3.7.2" + "expected_vers": "vers:conan1/<3.7.2", + "gitlab_scheme": "conan" }, { "test_index": 298, "scheme": "conan1", "native": "<3.7.3", - "expected_vers": "vers:conan1/<3.7.3" + "expected_vers": "vers:conan1/<3.7.3", + "gitlab_scheme": "conan" }, { "test_index": 299, "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1", + "gitlab_scheme": "conan" }, { "test_index": 300, "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1", + "gitlab_scheme": "conan" }, { "test_index": 301, "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1", + "gitlab_scheme": "conan" }, { "test_index": 302, "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1", + "gitlab_scheme": "conan" }, { "test_index": 303, "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1", + "gitlab_scheme": "conan" }, { "test_index": 304, "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1", + "gitlab_scheme": "conan" }, { "test_index": 305, "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1", + "gitlab_scheme": "conan" }, { "test_index": 306, "scheme": "conan1", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1" + "expected_vers": "vers:conan1/<2.4.1", + "gitlab_scheme": "conan" }, { "test_index": 307, "scheme": "conan1", "native": "<2.5.2", - "expected_vers": "vers:conan1/<2.5.2" + "expected_vers": "vers:conan1/<2.5.2", + "gitlab_scheme": "conan" }, { "test_index": 308, "scheme": "conan1", "native": "<2.5.2", - "expected_vers": "vers:conan1/<2.5.2" + "expected_vers": "vers:conan1/<2.5.2", + "gitlab_scheme": "conan" }, { "test_index": 309, "scheme": "conan1", "native": "<2.5.2", - "expected_vers": "vers:conan1/<2.5.2" + "expected_vers": "vers:conan1/<2.5.2", + "gitlab_scheme": "conan" }, { "test_index": 310, "scheme": "conan1", "native": "=2.3.0", - "expected_vers": "vers:conan1/2.3.0" + "expected_vers": "vers:conan1/2.3.0", + "gitlab_scheme": "conan" }, { "test_index": 311, "scheme": "conan1", "native": "=2.3.0", - "expected_vers": "vers:conan1/2.3.0" + "expected_vers": "vers:conan1/2.3.0", + "gitlab_scheme": "conan" }, { "test_index": 312, "scheme": "conan1", "native": "=2.3.0", - "expected_vers": "vers:conan1/2.3.0" + "expected_vers": "vers:conan1/2.3.0", + "gitlab_scheme": "conan" }, { "test_index": 313, "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "gitlab_scheme": "conan" }, { "test_index": 314, "scheme": "conan1", "native": "<=2.5.7", - "expected_vers": "vers:conan1/<=2.5.7" + "expected_vers": "vers:conan1/<=2.5.7", + "gitlab_scheme": "conan" }, { "test_index": 315, "scheme": "conan1", "native": "<2.5.4", - "expected_vers": "vers:conan1/<2.5.4" + "expected_vers": "vers:conan1/<2.5.4", + "gitlab_scheme": "conan" }, { "test_index": 316, "scheme": "conan1", "native": "<2.5.4", - "expected_vers": "vers:conan1/<2.5.4" + "expected_vers": "vers:conan1/<2.5.4", + "gitlab_scheme": "conan" }, { "test_index": 317, "scheme": "conan1", "native": "<2.5.4", - "expected_vers": "vers:conan1/<2.5.4" + "expected_vers": "vers:conan1/<2.5.4", + "gitlab_scheme": "conan" }, { "test_index": 318, "scheme": "conan1", "native": "<2.5.4", - "expected_vers": "vers:conan1/<2.5.4" + "expected_vers": "vers:conan1/<2.5.4", + "gitlab_scheme": "conan" }, { "test_index": 319, "scheme": "conan1", "native": "<=2.5.7", - "expected_vers": "vers:conan1/<=2.5.7" + "expected_vers": "vers:conan1/<=2.5.7", + "gitlab_scheme": "conan" }, { "test_index": 320, "scheme": "conan1", "native": "<3.0.1", - "expected_vers": "vers:conan1/<3.0.1" + "expected_vers": "vers:conan1/<3.0.1", + "gitlab_scheme": "conan" }, { "test_index": 321, "scheme": "conan1", "native": "<3.0.1", - "expected_vers": "vers:conan1/<3.0.1" + "expected_vers": "vers:conan1/<3.0.1", + "gitlab_scheme": "conan" }, { "test_index": 322, "scheme": "conan1", "native": "<3.0.1", - "expected_vers": "vers:conan1/<3.0.1" + "expected_vers": "vers:conan1/<3.0.1", + "gitlab_scheme": "conan" }, { "test_index": 323, "scheme": "conan1", "native": "<3.0.1", - "expected_vers": "vers:conan1/<3.0.1" + "expected_vers": "vers:conan1/<3.0.1", + "gitlab_scheme": "conan" }, { "test_index": 324, "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "gitlab_scheme": "conan" }, { "test_index": 325, "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "gitlab_scheme": "conan" }, { "test_index": 326, "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "gitlab_scheme": "conan" }, { "test_index": 327, "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "gitlab_scheme": "conan" }, { "test_index": 328, "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "gitlab_scheme": "conan" }, { "test_index": 329, "scheme": "conan1", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4" + "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "gitlab_scheme": "conan" }, { "test_index": 330, "scheme": "conan1", "native": "<3.0.5", - "expected_vers": "vers:conan1/<3.0.5" + "expected_vers": "vers:conan1/<3.0.5", + "gitlab_scheme": "conan" }, { "test_index": 331, "scheme": "conan1", "native": "<3.0.5", - "expected_vers": "vers:conan1/<3.0.5" + "expected_vers": "vers:conan1/<3.0.5", + "gitlab_scheme": "conan" }, { "test_index": 332, "scheme": "conan1", "native": "<3.1.2", - "expected_vers": "vers:conan1/<3.1.2" + "expected_vers": "vers:conan1/<3.1.2", + "gitlab_scheme": "conan" }, { "test_index": 333, "scheme": "conan1", "native": "=3.1.2", - "expected_vers": "vers:conan1/3.1.2" + "expected_vers": "vers:conan1/3.1.2", + "gitlab_scheme": "conan" }, { "test_index": 334, "scheme": "conan1", "native": ">=3.1.0 <3.1.4", - "expected_vers": "vers:conan1/>=3.1.0|<3.1.4" + "expected_vers": "vers:conan1/>=3.1.0|<3.1.4", + "gitlab_scheme": "conan" }, { "test_index": 335, "scheme": "conan1", "native": "<=2.3.1", - "expected_vers": "vers:conan1/<=2.3.1" + "expected_vers": "vers:conan1/<=2.3.1", + "gitlab_scheme": "conan" }, { "test_index": 336, "scheme": "conan1", "native": "<=1.5.1||>=2.0.0 <2.4.0", - "expected_vers": "vers:conan1/<=1.5.1|>=2.0.0|<2.4.0" + "expected_vers": "vers:conan1/<=1.5.1|>=2.0.0|<2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 337, "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 338, "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 339, "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 340, "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 341, "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 342, "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 343, "scheme": "conan1", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0" + "expected_vers": "vers:conan1/<2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 344, "scheme": "conan1", "native": "<=2.3.1", - "expected_vers": "vers:conan1/<=2.3.1" + "expected_vers": "vers:conan1/<=2.3.1", + "gitlab_scheme": "conan" }, { "test_index": 345, "scheme": "conan1", "native": "=2.3.1", - "expected_vers": "vers:conan1/2.3.1" + "expected_vers": "vers:conan1/2.3.1", + "gitlab_scheme": "conan" }, { "test_index": 346, "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0" + "expected_vers": "vers:conan1/2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 347, "scheme": "conan1", "native": "<=2.4.0", - "expected_vers": "vers:conan1/<=2.4.0" + "expected_vers": "vers:conan1/<=2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 348, "scheme": "conan1", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0" + "expected_vers": "vers:conan1/2.4.0", + "gitlab_scheme": "conan" }, { "test_index": 349, "scheme": "conan1", "native": ">=1.1.1d <=1.1.1f", - "expected_vers": "vers:conan1/>=1.1.1-d|<=1.1.1-f" + "expected_vers": "vers:conan1/>=1.1.1-d|<=1.1.1-f", + "gitlab_scheme": "conan" }, { "test_index": 350, "scheme": "conan1", "native": ">=1.0.2 <=1.0.2v", - "expected_vers": "vers:conan1/>=1.0.2|<=1.0.2" + "expected_vers": "vers:conan1/>=1.0.2|<=1.0.2", + "gitlab_scheme": "conan" }, { "test_index": 351, "scheme": "conan1", "native": ">=1.0.2 <=1.0.2w||>=1.1.1 <=1.1.1h", - "expected_vers": "vers:conan1/<=1.0.2-w|>=1.0.2|<=1.1.1-h|>=1.1.1" + "expected_vers": "vers:conan1/<=1.0.2-w|>=1.0.2|<=1.1.1-h|>=1.1.1", + "gitlab_scheme": "conan" }, { "test_index": 352, "scheme": "conan1", "native": "=1.0.2s", - "expected_vers": "vers:conan1/1.0.2-s" + "expected_vers": "vers:conan1/1.0.2-s", + "gitlab_scheme": "conan" }, { "test_index": 353, "scheme": "conan1", "native": ">=1.0.2 <1.0.2y||>=1.1.1 <1.1.1j", - "expected_vers": "vers:conan1/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1" + "expected_vers": "vers:conan1/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1", + "gitlab_scheme": "conan" }, { "test_index": 354, "scheme": "conan1", "native": ">=1.0.2 <1.0.2y||>=1.1.1 <1.1.1j", - "expected_vers": "vers:conan1/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1" + "expected_vers": "vers:conan1/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1", + "gitlab_scheme": "conan" }, { "test_index": 355, "scheme": "conan1", "native": "<0", - "expected_vers": "vers:conan1/<0.0.0" + "expected_vers": "vers:conan1/<0.0.0", + "gitlab_scheme": "conan" }, { "test_index": 356, "scheme": "conan1", "native": ">=1.1.1 <1.1.1k", - "expected_vers": "vers:conan1/<1.1.1-k|>=1.1.1" + "expected_vers": "vers:conan1/<1.1.1-k|>=1.1.1", + "gitlab_scheme": "conan" }, { "test_index": 357, "scheme": "conan1", "native": ">=1.1.1h <1.1.1k", - "expected_vers": "vers:conan1/>=1.1.1-h|<1.1.1-k" + "expected_vers": "vers:conan1/>=1.1.1-h|<1.1.1-k", + "gitlab_scheme": "conan" }, { "test_index": 358, "scheme": "conan1", "native": ">=1.1.1 <1.1.1l", - "expected_vers": "vers:conan1/<1.1.1-l|>=1.1.1" + "expected_vers": "vers:conan1/<1.1.1-l|>=1.1.1", + "gitlab_scheme": "conan" }, { "test_index": 359, "scheme": "conan1", "native": ">=1.0.2 <1.0.2za||>=1.1.1 <1.1.1l", - "expected_vers": "vers:conan1/<1.0.2-za|>=1.0.2|<1.1.1-l|>=1.1.1" + "expected_vers": "vers:conan1/<1.0.2-za|>=1.0.2|<1.1.1-l|>=1.1.1", + "gitlab_scheme": "conan" }, { "test_index": 360, "scheme": "conan1", "native": "<1.0.2||=1.1.0||=3.0.0", - "expected_vers": "vers:conan1/<1.0.2|1.1.0|3.0.0" + "expected_vers": "vers:conan1/<1.0.2|1.1.0|3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 361, "scheme": "conan1", "native": ">=1.0.2 <1.1.1m||=3.0.0", - "expected_vers": "vers:conan1/>=1.0.2|<1.1.1-m|3.0.0" + "expected_vers": "vers:conan1/>=1.0.2|<1.1.1-m|3.0.0", + "gitlab_scheme": "conan" }, { "test_index": 362, "scheme": "conan1", "native": ">=1.0.2 <1.0.2zd||>=1.1.0 <1.1.1n||>=3.0.0 <3.0.2", - "expected_vers": "vers:conan1/<1.0.2-zd|>=1.0.2|>=1.1.0|<1.1.1-n|>=3.0.0|<3.0.2" + "expected_vers": "vers:conan1/<1.0.2-zd|>=1.0.2|>=1.1.0|<1.1.1-n|>=3.0.0|<3.0.2", + "gitlab_scheme": "conan" }, { "test_index": 363, "scheme": "conan1", "native": ">=1.0.2 <1.0.2ze||>=1.1.1 <1.1.1o||>=3.0.0 <3.0.3", - "expected_vers": "vers:conan1/<1.0.2-ze|>=1.0.2|<1.1.1-o|>=1.1.1|>=3.0.0|<3.0.3" + "expected_vers": "vers:conan1/<1.0.2-ze|>=1.0.2|<1.1.1-o|>=1.1.1|>=3.0.0|<3.0.3", + "gitlab_scheme": "conan" }, { "test_index": 364, "scheme": "conan1", "native": ">=3.0.0 <3.0.3", - "expected_vers": "vers:conan1/>=3.0.0|<3.0.3" + "expected_vers": "vers:conan1/>=3.0.0|<3.0.3", + "gitlab_scheme": "conan" }, { "test_index": 365, "scheme": "conan1", "native": ">=3.0.0 <3.0.3", - "expected_vers": "vers:conan1/>=3.0.0|<3.0.3" + "expected_vers": "vers:conan1/>=3.0.0|<3.0.3", + "gitlab_scheme": "conan" }, { "test_index": 366, "scheme": "conan1", "native": ">=3.0.0 <3.0.3", - "expected_vers": "vers:conan1/>=3.0.0|<3.0.3" + "expected_vers": "vers:conan1/>=3.0.0|<3.0.3", + "gitlab_scheme": "conan" }, { "test_index": 367, "scheme": "conan1", "native": ">=1.0.2 <1.0.2zf||>=1.1.1 <1.1.1p||>=3.0.0 <3.0.4", - "expected_vers": "vers:conan1/<1.0.2-zf|>=1.0.2|<1.1.1-p|>=1.1.1|>=3.0.0|<3.0.4" + "expected_vers": "vers:conan1/<1.0.2-zf|>=1.0.2|<1.1.1-p|>=1.1.1|>=3.0.0|<3.0.4", + "gitlab_scheme": "conan" }, { "test_index": 368, "scheme": "conan1", "native": ">=1.1.1 <1.1.1q||>=3.0.0 <3.0.5", - "expected_vers": "vers:conan1/<1.1.1-q|>=1.1.1|>=3.0.0|<3.0.5" + "expected_vers": "vers:conan1/<1.1.1-q|>=1.1.1|>=3.0.0|<3.0.5", + "gitlab_scheme": "conan" }, { "test_index": 369, "scheme": "conan1", "native": "=3.0.4", - "expected_vers": "vers:conan1/3.0.4" + "expected_vers": "vers:conan1/3.0.4", + "gitlab_scheme": "conan" }, { "test_index": 370, "scheme": "conan1", "native": ">=3.0.0 <3.0.6", - "expected_vers": "vers:conan1/>=3.0.0|<3.0.6" + "expected_vers": "vers:conan1/>=3.0.0|<3.0.6", + "gitlab_scheme": "conan" }, { "test_index": 371, "scheme": "conan1", "native": ">=3.0.0 <3.0.7", - "expected_vers": "vers:conan1/>=3.0.0|<3.0.7" + "expected_vers": "vers:conan1/>=3.0.0|<3.0.7", + "gitlab_scheme": "conan" }, { "test_index": 372, "scheme": "conan1", "native": ">=3.0.0 <3.0.7", - "expected_vers": "vers:conan1/>=3.0.0|<3.0.7" + "expected_vers": "vers:conan1/>=3.0.0|<3.0.7", + "gitlab_scheme": "conan" }, { "test_index": 373, "scheme": "conan1", "native": ">=3.0.0 <=3.0.7", - "expected_vers": "vers:conan1/>=3.0.0|<=3.0.7" + "expected_vers": "vers:conan1/>=3.0.0|<=3.0.7", + "gitlab_scheme": "conan" }, { "test_index": 374, "scheme": "conan1", "native": "<8.44", - "expected_vers": "vers:conan1/<8.44.0" + "expected_vers": "vers:conan1/<8.44.0", + "gitlab_scheme": "conan" }, { "test_index": 375, "scheme": "conan1", "native": "<10.40", - "expected_vers": "vers:conan1/<10.40.0" + "expected_vers": "vers:conan1/<10.40.0", + "gitlab_scheme": "conan" }, { "test_index": 376, "scheme": "conan1", "native": "<10.40", - "expected_vers": "vers:conan1/<10.40.0" + "expected_vers": "vers:conan1/<10.40.0", + "gitlab_scheme": "conan" }, { "test_index": 377, "scheme": "conan1", "native": "<3.15.0", - "expected_vers": "vers:conan1/<3.15.0" + "expected_vers": "vers:conan1/<3.15.0", + "gitlab_scheme": "conan" }, { "test_index": 378, "scheme": "conan1", "native": "<3.18.3||>=3.19.0 <3.19.5||>=3.20.0 <3.20.2||>=3.21.0 <3.21.6", - "expected_vers": "vers:conan1/<3.18.3|>=3.19.0|<3.19.5|>=3.20.0|<3.20.2|>=3.21.0|<3.21.6" + "expected_vers": "vers:conan1/<3.18.3|>=3.19.0|<3.19.5|>=3.20.0|<3.20.2|>=3.21.0|<3.21.6", + "gitlab_scheme": "conan" }, { "test_index": 379, "scheme": "conan1", "native": "=1.3", - "expected_vers": "vers:conan1/1.3.0" + "expected_vers": "vers:conan1/1.3.0", + "gitlab_scheme": "conan" }, { "test_index": 380, "scheme": "conan1", "native": "=2.2", - "expected_vers": "vers:conan1/2.2.0" + "expected_vers": "vers:conan1/2.2.0", + "gitlab_scheme": "conan" }, { "test_index": 381, "scheme": "conan1", "native": "<=1.5.0", - "expected_vers": "vers:conan1/<=1.5.0" + "expected_vers": "vers:conan1/<=1.5.0", + "gitlab_scheme": "conan" }, { "test_index": 382, "scheme": "conan1", "native": ">=4.0 <4.4.1", - "expected_vers": "vers:conan1/>=4.0.0|<4.4.1" + "expected_vers": "vers:conan1/>=4.0.0|<4.4.1", + "gitlab_scheme": "conan" }, { "test_index": 383, "scheme": "conan1", "native": ">=4.0 <4.4.3", - "expected_vers": "vers:conan1/>=4.0.0|<4.4.3" + "expected_vers": "vers:conan1/>=4.0.0|<4.4.3", + "gitlab_scheme": "conan" }, { "test_index": 384, "scheme": "conan1", "native": "<=2.0.1", - "expected_vers": "vers:conan1/<=2.0.1" + "expected_vers": "vers:conan1/<=2.0.1", + "gitlab_scheme": "conan" }, { "test_index": 385, "scheme": "conan1", "native": "=cci.20200203", - "expected_vers": null + "expected_vers": null, + "gitlab_scheme": "conan" }, { "test_index": 386, "scheme": "conan1", "native": "=2.27", - "expected_vers": "vers:conan1/2.27.0" + "expected_vers": "vers:conan1/2.27.0", + "gitlab_scheme": "conan" }, { "test_index": 387, "scheme": "conan1", "native": "=2.27", - "expected_vers": "vers:conan1/2.27.0" + "expected_vers": "vers:conan1/2.27.0", + "gitlab_scheme": "conan" }, { "test_index": 388, "scheme": "conan1", "native": "=8.6.11", - "expected_vers": "vers:conan1/8.6.11" + "expected_vers": "vers:conan1/8.6.11", + "gitlab_scheme": "conan" }, { "test_index": 389, "scheme": "conan1", "native": "=5.0.0", - "expected_vers": "vers:conan1/5.0.0" + "expected_vers": "vers:conan1/5.0.0", + "gitlab_scheme": "conan" }, { "test_index": 390, "scheme": "conan1", "native": ">=0.9.3 <=0.13.0", - "expected_vers": "vers:conan1/>=0.9.3|<=0.13.0" + "expected_vers": "vers:conan1/>=0.9.3|<=0.13.0", + "gitlab_scheme": "conan" }, { "test_index": 391, "scheme": "conan1", "native": "<2021.02.22.00", - "expected_vers": "vers:conan1/<2021.2.22+00" + "expected_vers": "vers:conan1/<2021.2.22+00", + "gitlab_scheme": "conan" }, { "test_index": 392, "scheme": "conan1", "native": "<1.05.01", - "expected_vers": "vers:conan1/<1.5.1" + "expected_vers": "vers:conan1/<1.5.1", + "gitlab_scheme": "conan" }, { "test_index": 393, "scheme": "conan1", "native": "<0.9.6", - "expected_vers": "vers:conan1/<0.9.6" + "expected_vers": "vers:conan1/<0.9.6", + "gitlab_scheme": "conan" }, { "test_index": 394, "scheme": "conan1", "native": "<0.9.6", - "expected_vers": "vers:conan1/<0.9.6" + "expected_vers": "vers:conan1/<0.9.6", + "gitlab_scheme": "conan" }, { "test_index": 395, "scheme": "conan1", "native": ">=19.0.0 <=20.8.0", - "expected_vers": "vers:conan1/>=19.0.0|<=20.8.0" + "expected_vers": "vers:conan1/>=19.0.0|<=20.8.0", + "gitlab_scheme": "conan" }, { "test_index": 396, "scheme": "conan1", "native": ">=0.19.0 <0.30.0", - "expected_vers": "vers:conan1/>=0.19.0|<0.30.0" + "expected_vers": "vers:conan1/>=0.19.0|<0.30.0", + "gitlab_scheme": "conan" }, { "test_index": 397, "scheme": "conan1", "native": ">=0.26.0 <0.30.0", - "expected_vers": "vers:conan1/>=0.26.0|<0.30.0" + "expected_vers": "vers:conan1/>=0.26.0|<0.30.0", + "gitlab_scheme": "conan" }, { "test_index": 398, "scheme": "conan1", "native": "<0.30.0", - "expected_vers": "vers:conan1/<0.30.0" + "expected_vers": "vers:conan1/<0.30.0", + "gitlab_scheme": "conan" }, { "test_index": 399, "scheme": "conan1", "native": "<0.33.1||>0.33.1 <0.34.1", - "expected_vers": "vers:conan1/<0.33.1|>0.33.1|<0.34.1" + "expected_vers": "vers:conan1/<0.33.1|>0.33.1|<0.34.1", + "gitlab_scheme": "conan" }, { "test_index": 400, "scheme": "conan1", "native": ">=0.34.0 <0.34.2||>=0.35.0 <0.35.2", - "expected_vers": "vers:conan1/>=0.34.0|<0.34.2|>=0.35.0|<0.35.2" + "expected_vers": "vers:conan1/>=0.34.0|<0.34.2|>=0.35.0|<0.35.2", + "gitlab_scheme": "conan" }, { "test_index": 401, "scheme": "conan1", "native": "<0.38.1", - "expected_vers": "vers:conan1/<0.38.1" + "expected_vers": "vers:conan1/<0.38.1", + "gitlab_scheme": "conan" }, { "test_index": 402, "scheme": "conan1", "native": ">=0.37.0 <0.38.2", - "expected_vers": "vers:conan1/>=0.37.0|<0.38.2" + "expected_vers": "vers:conan1/>=0.37.0|<0.38.2", + "gitlab_scheme": "conan" }, { "test_index": 403, "scheme": "conan1", "native": "<0.38.1", - "expected_vers": "vers:conan1/<0.38.1" + "expected_vers": "vers:conan1/<0.38.1", + "gitlab_scheme": "conan" }, { "test_index": 404, "scheme": "conan1", "native": "<1.0.2||>=2.0.0 <2.0.2", - "expected_vers": "vers:conan1/<1.0.2|>=2.0.0|<2.0.2" + "expected_vers": "vers:conan1/<1.0.2|>=2.0.0|<2.0.2", + "gitlab_scheme": "conan" }, { "test_index": 405, "scheme": "conan1", "native": "<1.0.2||>=2.0.0 <2.0.2", - "expected_vers": "vers:conan1/<1.0.2|>=2.0.0|<2.0.2" + "expected_vers": "vers:conan1/<1.0.2|>=2.0.0|<2.0.2", + "gitlab_scheme": "conan" }, { "test_index": 406, "scheme": "conan1", "native": "<1.0.2||>=2.0.0 <2.0.2", - "expected_vers": "vers:conan1/<1.0.2|>=2.0.0|<2.0.2" + "expected_vers": "vers:conan1/<1.0.2|>=2.0.0|<2.0.2", + "gitlab_scheme": "conan" }, { "test_index": 407, "scheme": "conan1", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0" + "expected_vers": "vers:conan1/4.3.0", + "gitlab_scheme": "conan" }, { "test_index": 408, "scheme": "conan1", "native": "<4.4.0", - "expected_vers": "vers:conan1/<4.4.0" + "expected_vers": "vers:conan1/<4.4.0", + "gitlab_scheme": "conan" }, { "test_index": 409, "scheme": "conan1", "native": "<4.5.0", - "expected_vers": "vers:conan1/<4.5.0" + "expected_vers": "vers:conan1/<4.5.0", + "gitlab_scheme": "conan" }, { "test_index": 410, "scheme": "conan1", "native": "<4.5.0", - "expected_vers": "vers:conan1/<4.5.0" + "expected_vers": "vers:conan1/<4.5.0", + "gitlab_scheme": "conan" }, { "test_index": 411, "scheme": "conan1", "native": "<4.5.0", - "expected_vers": "vers:conan1/<4.5.0" + "expected_vers": "vers:conan1/<4.5.0", + "gitlab_scheme": "conan" }, { "test_index": 412, "scheme": "conan1", "native": "<4.5.0", - "expected_vers": "vers:conan1/<4.5.0" + "expected_vers": "vers:conan1/<4.5.0", + "gitlab_scheme": "conan" }, { "test_index": 413, "scheme": "conan1", "native": "<4.6.0", - "expected_vers": "vers:conan1/<4.6.0" + "expected_vers": "vers:conan1/<4.6.0", + "gitlab_scheme": "conan" }, { "test_index": 414, "scheme": "conan1", "native": "<4.6.0", - "expected_vers": "vers:conan1/<4.6.0" + "expected_vers": "vers:conan1/<4.6.0", + "gitlab_scheme": "conan" }, { "test_index": 415, "scheme": "conan1", "native": "<4.7.0", - "expected_vers": "vers:conan1/<4.7.0" + "expected_vers": "vers:conan1/<4.7.0", + "gitlab_scheme": "conan" }, { "test_index": 416, "scheme": "conan1", "native": ">=4.6.0 <4.8.0", - "expected_vers": "vers:conan1/>=4.6.0|<4.8.0" + "expected_vers": "vers:conan1/>=4.6.0|<4.8.0", + "gitlab_scheme": "conan" }, { "test_index": 417, "scheme": "conan1", "native": "<4.8.1", - "expected_vers": "vers:conan1/<4.8.1" + "expected_vers": "vers:conan1/<4.8.1", + "gitlab_scheme": "conan" }, { "test_index": 418, "scheme": "conan1", "native": "<=5.0.0", - "expected_vers": "vers:conan1/<=5.0.0" + "expected_vers": "vers:conan1/<=5.0.0", + "gitlab_scheme": "conan" }, { "test_index": 419, "scheme": "conan1", "native": ">=5.0.0 <5.1.1", - "expected_vers": "vers:conan1/>=5.0.0|<5.1.1" + "expected_vers": "vers:conan1/>=5.0.0|<5.1.1", + "gitlab_scheme": "conan" }, { "test_index": 420, "scheme": "conan1", "native": "<5.2.0", - "expected_vers": "vers:conan1/<5.2.0" + "expected_vers": "vers:conan1/<5.2.0", + "gitlab_scheme": "conan" }, { "test_index": 421, "scheme": "conan1", "native": "<5.2.0", - "expected_vers": "vers:conan1/<5.2.0" + "expected_vers": "vers:conan1/<5.2.0", + "gitlab_scheme": "conan" }, { "test_index": 422, "scheme": "conan1", "native": "<5.4.0", - "expected_vers": "vers:conan1/<5.4.0" + "expected_vers": "vers:conan1/<5.4.0", + "gitlab_scheme": "conan" }, { "test_index": 423, "scheme": "conan1", "native": "<5.5.0", - "expected_vers": "vers:conan1/<5.5.0" + "expected_vers": "vers:conan1/<5.5.0", + "gitlab_scheme": "conan" }, { "test_index": 424, "scheme": "conan1", "native": "=5.3.0", - "expected_vers": "vers:conan1/5.3.0" + "expected_vers": "vers:conan1/5.3.0", + "gitlab_scheme": "conan" }, { "test_index": 425, "scheme": "conan1", "native": "<5.5.1", - "expected_vers": "vers:conan1/<5.5.1" + "expected_vers": "vers:conan1/<5.5.1", + "gitlab_scheme": "conan" }, { "test_index": 426, "scheme": "conan1", "native": "<5.5.2", - "expected_vers": "vers:conan1/<5.5.2" + "expected_vers": "vers:conan1/<5.5.2", + "gitlab_scheme": "conan" }, { "test_index": 427, "scheme": "conan1", "native": "<5.5.0", - "expected_vers": "vers:conan1/<5.5.0" + "expected_vers": "vers:conan1/<5.5.0", + "gitlab_scheme": "conan" }, { "test_index": 428, "scheme": "conan1", "native": "<4.3.3", - "expected_vers": "vers:conan1/<4.3.3" + "expected_vers": "vers:conan1/<4.3.3", + "gitlab_scheme": "conan" } ] diff --git a/tests/test_version_range.py b/tests/test_version_range.py index ccae53d1..4b45fbe2 100644 --- a/tests/test_version_range.py +++ b/tests/test_version_range.py @@ -362,7 +362,7 @@ def test_conan_gitlab_version_range_parse(test_case): Conan1VersionRange.from_native(string=test_case["native"]) return result = from_gitlab_native( - gitlab_scheme=test_case["scheme"], + gitlab_scheme=test_case["gitlab_scheme"], string=test_case["native"], ) assert str(result) == test_case["expected_vers"] From f6dda4c0411ca5e5ed8b3ee6602a2e0d7b02256b Mon Sep 17 00:00:00 2001 From: James Date: Mon, 27 Feb 2023 18:10:44 +0100 Subject: [PATCH 70/78] verbose tracebacks (#13226) --- conans/errors.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/conans/errors.py b/conans/errors.py index 6d624234..31957028 100644 --- a/conans/errors.py +++ b/conans/errors.py @@ -10,8 +10,6 @@ """ from contextlib import contextmanager -from conans.util.env import get_env - @contextmanager def conanfile_remove_attr(conanfile, names, method): @@ -42,6 +40,10 @@ def conanfile_exception_formatter(conanfile_name, func_name): """ def _raise_conanfile_exc(e): + from conan.api.output import LEVEL_DEBUG, conan_output_level + if conan_output_level <= LEVEL_DEBUG: + import traceback + raise ConanExceptionInUserConanfileMethod(traceback.format_exc()) m = _format_conanfile_exception(conanfile_name, func_name, e) raise ConanExceptionInUserConanfileMethod(m) @@ -72,8 +74,6 @@ def _format_conanfile_exception(scope, method, exception): """ import sys import traceback - if get_env("CONAN_VERBOSE_TRACEBACK", False): - return traceback.format_exc() try: conanfile_reached = False tb = sys.exc_info()[2] From c3d57cef49ced373141f4e9786ac307fe21aac5b Mon Sep 17 00:00:00 2001 From: "John M. Horan" Date: Tue, 28 Feb 2023 17:47:05 -0800 Subject: [PATCH 71/78] Change references from 'conan1' to 'conan' #101 Reference: https://github.com/nexB/univers/issues/101 Signed-off-by: John M. Horan --- src/univers/version_range.py | 10 +- tests/data/conan_advisory.json | 1710 ++++++++++++++++---------------- tests/test_version_range.py | 8 +- 3 files changed, 864 insertions(+), 864 deletions(-) diff --git a/src/univers/version_range.py b/src/univers/version_range.py index 6c16b978..1405ad6a 100644 --- a/src/univers/version_range.py +++ b/src/univers/version_range.py @@ -377,8 +377,8 @@ def from_native(cls, string): return cls(constraints=constraints) -class Conan1VersionRange(NpmVersionRange): - scheme = "conan1" +class ConanVersionRange(NpmVersionRange): + scheme = "conan" version_class = versions.SemverVersion @@ -1106,7 +1106,7 @@ def from_gitlab_native(gitlab_scheme, string): purl_scheme = PURL_TYPE_BY_GITLAB_SCHEME[gitlab_scheme] vrc = RANGE_CLASS_BY_SCHEMES[purl_scheme] supported_native_implementations = [ - Conan1VersionRange, + ConanVersionRange, ] if vrc in supported_native_implementations: return vrc.from_native(string) @@ -1233,7 +1233,7 @@ def build_range_from_github_advisory_constraint(scheme: str, string: str): "nginx": NginxVersionRange, "openssl": OpensslVersionRange, "mattermost": MattermostVersionRange, - "conan1": Conan1VersionRange, + "conan": ConanVersionRange, } PURL_TYPE_BY_GITLAB_SCHEME = { @@ -1244,5 +1244,5 @@ def build_range_from_github_advisory_constraint(scheme: str, string: str): "nuget": "nuget", "pypi": "pypi", "packagist": "composer", - "conan": "conan1", + "conan": "conan", } diff --git a/tests/data/conan_advisory.json b/tests/data/conan_advisory.json index cdd552c3..4a7c42d8 100644 --- a/tests/data/conan_advisory.json +++ b/tests/data/conan_advisory.json @@ -1,2998 +1,2998 @@ [ { "test_index": 1, - "scheme": "conan1", + "scheme": "conan", "native": ">=5.1.0 <=5.1.1", - "expected_vers": "vers:conan1/>=5.1.0|<=5.1.1", + "expected_vers": "vers:conan/>=5.1.0|<=5.1.1", "gitlab_scheme": "conan" }, { "test_index": 2, - "scheme": "conan1", + "scheme": "conan", "native": "=5.2.5", - "expected_vers": "vers:conan1/5.2.5", + "expected_vers": "vers:conan/5.2.5", "gitlab_scheme": "conan" }, { "test_index": 3, - "scheme": "conan1", + "scheme": "conan", "native": "<3.5.4", - "expected_vers": "vers:conan1/<3.5.4", + "expected_vers": "vers:conan/<3.5.4", "gitlab_scheme": "conan" }, { "test_index": 4, - "scheme": "conan1", + "scheme": "conan", "native": "=3.7", - "expected_vers": "vers:conan1/3.7.0", + "expected_vers": "vers:conan/3.7.0", "gitlab_scheme": "conan" }, { "test_index": 5, - "scheme": "conan1", + "scheme": "conan", "native": "<0", - "expected_vers": "vers:conan1/<0.0.0", + "expected_vers": "vers:conan/<0.0.0", "gitlab_scheme": "conan" }, { "test_index": 6, - "scheme": "conan1", + "scheme": "conan", "native": "<2.17.3", - "expected_vers": "vers:conan1/<2.17.3", + "expected_vers": "vers:conan/<2.17.3", "gitlab_scheme": "conan" }, { "test_index": 7, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.18.1", - "expected_vers": "vers:conan1/<=2.18.1", + "expected_vers": "vers:conan/<=2.18.1", "gitlab_scheme": "conan" }, { "test_index": 8, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.11.34 <2.19.3", - "expected_vers": "vers:conan1/>=1.11.34|<2.19.3", + "expected_vers": "vers:conan/>=1.11.34|<2.19.3", "gitlab_scheme": "conan" }, { "test_index": 9, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.8", - "expected_vers": "vers:conan1/<1.0.8", + "expected_vers": "vers:conan/<1.0.8", "gitlab_scheme": "conan" }, { "test_index": 10, - "scheme": "conan1", + "scheme": "conan", "native": "=1.16.0", - "expected_vers": "vers:conan1/1.16.0", + "expected_vers": "vers:conan/1.16.0", "gitlab_scheme": "conan" }, { "test_index": 11, - "scheme": "conan1", + "scheme": "conan", "native": "<1.16.0", - "expected_vers": "vers:conan1/<1.16.0", + "expected_vers": "vers:conan/<1.16.0", "gitlab_scheme": "conan" }, { "test_index": 12, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.0.0 <1.17.2", - "expected_vers": "vers:conan1/>=1.0.0|<1.17.2", + "expected_vers": "vers:conan/>=1.0.0|<1.17.2", "gitlab_scheme": "conan" }, { "test_index": 13, - "scheme": "conan1", + "scheme": "conan", "native": "<1.17.4", - "expected_vers": "vers:conan1/<1.17.4", + "expected_vers": "vers:conan/<1.17.4", "gitlab_scheme": "conan" }, { "test_index": 14, - "scheme": "conan1", + "scheme": "conan", "native": "<0.13.7||>=0.14.0 <0.14.11||>=0.15.0 <0.15.2", - "expected_vers": "vers:conan1/<0.13.7|>=0.14.0|<0.14.11|>=0.15.0|<0.15.2", + "expected_vers": "vers:conan/<0.13.7|>=0.14.0|<0.14.11|>=0.15.0|<0.15.2", "gitlab_scheme": "conan" }, { "test_index": 15, - "scheme": "conan1", + "scheme": "conan", "native": "<=1.3.0", - "expected_vers": "vers:conan1/<=1.3.0", + "expected_vers": "vers:conan/<=1.3.0", "gitlab_scheme": "conan" }, { "test_index": 16, - "scheme": "conan1", + "scheme": "conan", "native": "<=1.3.0", - "expected_vers": "vers:conan1/<=1.3.0", + "expected_vers": "vers:conan/<=1.3.0", "gitlab_scheme": "conan" }, { "test_index": 17, - "scheme": "conan1", + "scheme": "conan", "native": "<2.9.3", - "expected_vers": "vers:conan1/<2.9.3", + "expected_vers": "vers:conan/<2.9.3", "gitlab_scheme": "conan" }, { "test_index": 18, - "scheme": "conan1", + "scheme": "conan", "native": "<3.1.0", - "expected_vers": "vers:conan1/<3.1.0", + "expected_vers": "vers:conan/<3.1.0", "gitlab_scheme": "conan" }, { "test_index": 19, - "scheme": "conan1", + "scheme": "conan", "native": "<=0.5.8", - "expected_vers": "vers:conan1/<=0.5.8", + "expected_vers": "vers:conan/<=0.5.8", "gitlab_scheme": "conan" }, { "test_index": 20, - "scheme": "conan1", + "scheme": "conan", "native": "<=0.1.12", - "expected_vers": "vers:conan1/<=0.1.12", + "expected_vers": "vers:conan/<=0.1.12", "gitlab_scheme": "conan" }, { "test_index": 21, - "scheme": "conan1", + "scheme": "conan", "native": "<=0.1.12", - "expected_vers": "vers:conan1/<=0.1.12", + "expected_vers": "vers:conan/<=0.1.12", "gitlab_scheme": "conan" }, { "test_index": 22, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.1.27", - "expected_vers": "vers:conan1/<=2.1.27", + "expected_vers": "vers:conan/<=2.1.27", "gitlab_scheme": "conan" }, { "test_index": 23, - "scheme": "conan1", + "scheme": "conan", "native": ">=2.1.17 <=2.1.27", - "expected_vers": "vers:conan1/>=2.1.17|<=2.1.27", + "expected_vers": "vers:conan/>=2.1.17|<=2.1.27", "gitlab_scheme": "conan" }, { "test_index": 24, - "scheme": "conan1", + "scheme": "conan", "native": "<=3.6.6", - "expected_vers": "vers:conan1/<=3.6.6", + "expected_vers": "vers:conan/<=3.6.6", "gitlab_scheme": "conan" }, { "test_index": 25, - "scheme": "conan1", + "scheme": "conan", "native": "<=3.6.6", - "expected_vers": "vers:conan1/<=3.6.6", + "expected_vers": "vers:conan/<=3.6.6", "gitlab_scheme": "conan" }, { "test_index": 26, - "scheme": "conan1", + "scheme": "conan", "native": "<=3.6.6", - "expected_vers": "vers:conan1/<=3.6.6", + "expected_vers": "vers:conan/<=3.6.6", "gitlab_scheme": "conan" }, { "test_index": 27, - "scheme": "conan1", + "scheme": "conan", "native": "<=3.6.6", - "expected_vers": "vers:conan1/<=3.6.6", + "expected_vers": "vers:conan/<=3.6.6", "gitlab_scheme": "conan" }, { "test_index": 28, - "scheme": "conan1", + "scheme": "conan", "native": "<3.6.7", - "expected_vers": "vers:conan1/<3.6.7", + "expected_vers": "vers:conan/<3.6.7", "gitlab_scheme": "conan" }, { "test_index": 29, - "scheme": "conan1", + "scheme": "conan", "native": "<3.6.7", - "expected_vers": "vers:conan1/<3.6.7", + "expected_vers": "vers:conan/<3.6.7", "gitlab_scheme": "conan" }, { "test_index": 30, - "scheme": "conan1", + "scheme": "conan", "native": "<3.6.7", - "expected_vers": "vers:conan1/<3.6.7", + "expected_vers": "vers:conan/<3.6.7", "gitlab_scheme": "conan" }, { "test_index": 31, - "scheme": "conan1", + "scheme": "conan", "native": "=3.6.7", - "expected_vers": "vers:conan1/3.6.7", + "expected_vers": "vers:conan/3.6.7", "gitlab_scheme": "conan" }, { "test_index": 32, - "scheme": "conan1", + "scheme": "conan", "native": "<2021.07.22.00", - "expected_vers": "vers:conan1/<2021.7.22+00", + "expected_vers": "vers:conan/<2021.7.22+00", "gitlab_scheme": "conan" }, { "test_index": 33, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.12", - "expected_vers": "vers:conan1/<1.0.12", + "expected_vers": "vers:conan/<1.0.12", "gitlab_scheme": "conan" }, { "test_index": 34, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.12", - "expected_vers": "vers:conan1/<1.0.12", + "expected_vers": "vers:conan/<1.0.12", "gitlab_scheme": "conan" }, { "test_index": 35, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.12", - "expected_vers": "vers:conan1/<1.0.12", + "expected_vers": "vers:conan/<1.0.12", "gitlab_scheme": "conan" }, { "test_index": 36, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.3.0 <=3.4.0", - "expected_vers": "vers:conan1/>=3.3.0|<=3.4.0", + "expected_vers": "vers:conan/>=3.3.0|<=3.4.0", "gitlab_scheme": "conan" }, { "test_index": 37, - "scheme": "conan1", + "scheme": "conan", "native": "=2.42.6", - "expected_vers": "vers:conan1/2.42.6", + "expected_vers": "vers:conan/2.42.6", "gitlab_scheme": "conan" }, { "test_index": 38, - "scheme": "conan1", + "scheme": "conan", "native": "<=5.1.4", - "expected_vers": "vers:conan1/<=5.1.4", + "expected_vers": "vers:conan/<=5.1.4", "gitlab_scheme": "conan" }, { "test_index": 39, - "scheme": "conan1", + "scheme": "conan", "native": "=5.1.4", - "expected_vers": "vers:conan1/5.1.4", + "expected_vers": "vers:conan/5.1.4", "gitlab_scheme": "conan" }, { "test_index": 40, - "scheme": "conan1", + "scheme": "conan", "native": "=5.2.1", - "expected_vers": "vers:conan1/5.2.1", + "expected_vers": "vers:conan/5.2.1", "gitlab_scheme": "conan" }, { "test_index": 41, - "scheme": "conan1", + "scheme": "conan", "native": "<2.65.3", - "expected_vers": "vers:conan1/<2.65.3", + "expected_vers": "vers:conan/<2.65.3", "gitlab_scheme": "conan" }, { "test_index": 42, - "scheme": "conan1", + "scheme": "conan", "native": ">=2.60.0 <=2.62.4", - "expected_vers": "vers:conan1/>=2.60.0|<=2.62.4", + "expected_vers": "vers:conan/>=2.60.0|<=2.62.4", "gitlab_scheme": "conan" }, { "test_index": 43, - "scheme": "conan1", + "scheme": "conan", "native": "<2.66.7||>=2.67.0 <2.67.4", - "expected_vers": "vers:conan1/<2.66.7|>=2.67.0|<2.67.4", + "expected_vers": "vers:conan/<2.66.7|>=2.67.0|<2.67.4", "gitlab_scheme": "conan" }, { "test_index": 44, - "scheme": "conan1", + "scheme": "conan", "native": "<2.66.6||>=2.67.0 <2.67.3", - "expected_vers": "vers:conan1/<2.66.6|>=2.67.0|<2.67.3", + "expected_vers": "vers:conan/<2.66.6|>=2.67.0|<2.67.3", "gitlab_scheme": "conan" }, { "test_index": 45, - "scheme": "conan1", + "scheme": "conan", "native": "<2.66.8", - "expected_vers": "vers:conan1/<2.66.8", + "expected_vers": "vers:conan/<2.66.8", "gitlab_scheme": "conan" }, { "test_index": 46, - "scheme": "conan1", + "scheme": "conan", "native": "<2.63.6", - "expected_vers": "vers:conan1/<2.63.6", + "expected_vers": "vers:conan/<2.63.6", "gitlab_scheme": "conan" }, { "test_index": 47, - "scheme": "conan1", + "scheme": "conan", "native": "<=3.2", - "expected_vers": "vers:conan1/<=3.2.0", + "expected_vers": "vers:conan/<=3.2.0", "gitlab_scheme": "conan" }, { "test_index": 48, - "scheme": "conan1", + "scheme": "conan", "native": "<=3.2", - "expected_vers": "vers:conan1/<=3.2.0", + "expected_vers": "vers:conan/<=3.2.0", "gitlab_scheme": "conan" }, { "test_index": 49, - "scheme": "conan1", + "scheme": "conan", "native": "=2.8.107", - "expected_vers": "vers:conan1/2.8.107", + "expected_vers": "vers:conan/2.8.107", "gitlab_scheme": "conan" }, { "test_index": 50, - "scheme": "conan1", + "scheme": "conan", "native": "=2.8.107", - "expected_vers": "vers:conan1/2.8.107", + "expected_vers": "vers:conan/2.8.107", "gitlab_scheme": "conan" }, { "test_index": 51, - "scheme": "conan1", + "scheme": "conan", "native": "=2.8.107", - "expected_vers": "vers:conan1/2.8.107", + "expected_vers": "vers:conan/2.8.107", "gitlab_scheme": "conan" }, { "test_index": 52, - "scheme": "conan1", + "scheme": "conan", "native": "=2.8.107", - "expected_vers": "vers:conan1/2.8.107", + "expected_vers": "vers:conan/2.8.107", "gitlab_scheme": "conan" }, { "test_index": 53, - "scheme": "conan1", + "scheme": "conan", "native": "=2.8.107", - "expected_vers": "vers:conan1/2.8.107", + "expected_vers": "vers:conan/2.8.107", "gitlab_scheme": "conan" }, { "test_index": 54, - "scheme": "conan1", + "scheme": "conan", "native": "=2.8.107", - "expected_vers": "vers:conan1/2.8.107", + "expected_vers": "vers:conan/2.8.107", "gitlab_scheme": "conan" }, { "test_index": 55, - "scheme": "conan1", + "scheme": "conan", "native": "=2.9.0", - "expected_vers": "vers:conan1/2.9.0", + "expected_vers": "vers:conan/2.9.0", "gitlab_scheme": "conan" }, { "test_index": 56, - "scheme": "conan1", + "scheme": "conan", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0", + "expected_vers": "vers:conan/4.3.0", "gitlab_scheme": "conan" }, { "test_index": 57, - "scheme": "conan1", + "scheme": "conan", "native": "<=1.12.0", - "expected_vers": "vers:conan1/<=1.12.0", + "expected_vers": "vers:conan/<=1.12.0", "gitlab_scheme": "conan" }, { "test_index": 58, - "scheme": "conan1", + "scheme": "conan", "native": "<=1.12.0", - "expected_vers": "vers:conan1/<=1.12.0", + "expected_vers": "vers:conan/<=1.12.0", "gitlab_scheme": "conan" }, { "test_index": 59, - "scheme": "conan1", + "scheme": "conan", "native": "<=1.12.0", - "expected_vers": "vers:conan1/<=1.12.0", + "expected_vers": "vers:conan/<=1.12.0", "gitlab_scheme": "conan" }, { "test_index": 60, - "scheme": "conan1", + "scheme": "conan", "native": "<=1.12.0", - "expected_vers": "vers:conan1/<=1.12.0", + "expected_vers": "vers:conan/<=1.12.0", "gitlab_scheme": "conan" }, { "test_index": 61, - "scheme": "conan1", + "scheme": "conan", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1", "gitlab_scheme": "conan" }, { "test_index": 62, - "scheme": "conan1", + "scheme": "conan", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1", "gitlab_scheme": "conan" }, { "test_index": 63, - "scheme": "conan1", + "scheme": "conan", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1", "gitlab_scheme": "conan" }, { "test_index": 64, - "scheme": "conan1", + "scheme": "conan", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1", "gitlab_scheme": "conan" }, { "test_index": 65, - "scheme": "conan1", + "scheme": "conan", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1", "gitlab_scheme": "conan" }, { "test_index": 66, - "scheme": "conan1", + "scheme": "conan", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1", "gitlab_scheme": "conan" }, { "test_index": 67, - "scheme": "conan1", + "scheme": "conan", "native": "=1.13.1-1", - "expected_vers": "vers:conan1/1.13.1-1", + "expected_vers": "vers:conan/1.13.1-1", "gitlab_scheme": "conan" }, { "test_index": 68, - "scheme": "conan1", + "scheme": "conan", "native": "=1.10.4", - "expected_vers": "vers:conan1/1.10.4", + "expected_vers": "vers:conan/1.10.4", "gitlab_scheme": "conan" }, { "test_index": 69, - "scheme": "conan1", + "scheme": "conan", "native": "=1.10.4", - "expected_vers": "vers:conan1/1.10.4", + "expected_vers": "vers:conan/1.10.4", "gitlab_scheme": "conan" }, { "test_index": 70, - "scheme": "conan1", + "scheme": "conan", "native": "=1.10.4", - "expected_vers": "vers:conan1/1.10.4", + "expected_vers": "vers:conan/1.10.4", "gitlab_scheme": "conan" }, { "test_index": 71, - "scheme": "conan1", + "scheme": "conan", "native": "<=0.14.0", - "expected_vers": "vers:conan1/<=0.14.0", + "expected_vers": "vers:conan/<=0.14.0", "gitlab_scheme": "conan" }, { "test_index": 72, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.13.1", - "expected_vers": "vers:conan1/<=2.13.1", + "expected_vers": "vers:conan/<=2.13.1", "gitlab_scheme": "conan" }, { "test_index": 73, - "scheme": "conan1", + "scheme": "conan", "native": "<2.0.23", - "expected_vers": "vers:conan1/<2.0.23", + "expected_vers": "vers:conan/<2.0.23", "gitlab_scheme": "conan" }, { "test_index": 74, - "scheme": "conan1", + "scheme": "conan", "native": "<2.0.25", - "expected_vers": "vers:conan1/<2.0.25", + "expected_vers": "vers:conan/<2.0.25", "gitlab_scheme": "conan" }, { "test_index": 75, - "scheme": "conan1", + "scheme": "conan", "native": "<2.0.25", - "expected_vers": "vers:conan1/<2.0.25", + "expected_vers": "vers:conan/<2.0.25", "gitlab_scheme": "conan" }, { "test_index": 76, - "scheme": "conan1", + "scheme": "conan", "native": ">=2.0.0 <2.0.17", - "expected_vers": "vers:conan1/>=2.0.0|<2.0.17", + "expected_vers": "vers:conan/>=2.0.0|<2.0.17", "gitlab_scheme": "conan" }, { "test_index": 77, - "scheme": "conan1", + "scheme": "conan", "native": "=2.0.24", - "expected_vers": "vers:conan1/2.0.24", + "expected_vers": "vers:conan/2.0.24", "gitlab_scheme": "conan" }, { "test_index": 78, - "scheme": "conan1", + "scheme": "conan", "native": "<2.0.27", - "expected_vers": "vers:conan1/<2.0.27", + "expected_vers": "vers:conan/<2.0.27", "gitlab_scheme": "conan" }, { "test_index": 79, - "scheme": "conan1", + "scheme": "conan", "native": "<2.0.26", - "expected_vers": "vers:conan1/<2.0.26", + "expected_vers": "vers:conan/<2.0.26", "gitlab_scheme": "conan" }, { "test_index": 80, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.6", - "expected_vers": "vers:conan1/3.0.6", + "expected_vers": "vers:conan/3.0.6", "gitlab_scheme": "conan" }, { "test_index": 81, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.6", - "expected_vers": "vers:conan1/3.0.6", + "expected_vers": "vers:conan/3.0.6", "gitlab_scheme": "conan" }, { "test_index": 82, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 83, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 84, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 85, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 86, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 87, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 88, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 89, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 90, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 91, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 92, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 93, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 94, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 95, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 96, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 97, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 98, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 99, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 100, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 101, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2.0", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 102, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.3.0", - "expected_vers": "vers:conan1/<=2.3.0", + "expected_vers": "vers:conan/<=2.3.0", "gitlab_scheme": "conan" }, { "test_index": 103, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.3.0", - "expected_vers": "vers:conan1/<=2.3.0", + "expected_vers": "vers:conan/<=2.3.0", "gitlab_scheme": "conan" }, { "test_index": 104, - "scheme": "conan1", + "scheme": "conan", "native": "=2.3.0", - "expected_vers": "vers:conan1/2.3.0", + "expected_vers": "vers:conan/2.3.0", "gitlab_scheme": "conan" }, { "test_index": 105, - "scheme": "conan1", + "scheme": "conan", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0", + "expected_vers": "vers:conan/2.4.0", "gitlab_scheme": "conan" }, { "test_index": 106, - "scheme": "conan1", + "scheme": "conan", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0", + "expected_vers": "vers:conan/2.4.0", "gitlab_scheme": "conan" }, { "test_index": 107, - "scheme": "conan1", + "scheme": "conan", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0", + "expected_vers": "vers:conan/2.4.0", "gitlab_scheme": "conan" }, { "test_index": 108, - "scheme": "conan1", + "scheme": "conan", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0", + "expected_vers": "vers:conan/2.4.0", "gitlab_scheme": "conan" }, { "test_index": 109, - "scheme": "conan1", + "scheme": "conan", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0", + "expected_vers": "vers:conan/2.4.0", "gitlab_scheme": "conan" }, { "test_index": 110, - "scheme": "conan1", + "scheme": "conan", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0", + "expected_vers": "vers:conan/2.4.0", "gitlab_scheme": "conan" }, { "test_index": 111, - "scheme": "conan1", + "scheme": "conan", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0", + "expected_vers": "vers:conan/2.4.0", "gitlab_scheme": "conan" }, { "test_index": 112, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.4.0", - "expected_vers": "vers:conan1/<=2.4.0", + "expected_vers": "vers:conan/<=2.4.0", "gitlab_scheme": "conan" }, { "test_index": 113, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.4.0", - "expected_vers": "vers:conan1/<=2.4.0", + "expected_vers": "vers:conan/<=2.4.0", "gitlab_scheme": "conan" }, { "test_index": 114, - "scheme": "conan1", + "scheme": "conan", "native": "", - "expected_vers": "vers:conan1/", + "expected_vers": "vers:conan/", "gitlab_scheme": "conan" }, { "test_index": 115, - "scheme": "conan1", + "scheme": "conan", "native": "<2021-10-15", - "expected_vers": "vers:conan1/<2021.0.0-10-15", + "expected_vers": "vers:conan/<2021.0.0-10-15", "gitlab_scheme": "conan" }, { "test_index": 116, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.4.0", - "expected_vers": "vers:conan1/<=2.4.0", + "expected_vers": "vers:conan/<=2.4.0", "gitlab_scheme": "conan" }, { "test_index": 117, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 118, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 119, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 120, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 121, - "scheme": "conan1", + "scheme": "conan", "native": "=2.3.0", - "expected_vers": "vers:conan1/2.3.0", + "expected_vers": "vers:conan/2.3.0", "gitlab_scheme": "conan" }, { "test_index": 122, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 123, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 124, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 125, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 126, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 127, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 128, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 129, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 130, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 131, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 132, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 133, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 134, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 135, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 136, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 137, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 138, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 139, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 140, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 141, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 142, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 143, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.0", - "expected_vers": "vers:conan1/3.0.0", + "expected_vers": "vers:conan/3.0.0", "gitlab_scheme": "conan" }, { "test_index": 144, - "scheme": "conan1", + "scheme": "conan", "native": "", - "expected_vers": "vers:conan1/", + "expected_vers": "vers:conan/", "gitlab_scheme": "conan" }, { "test_index": 145, - "scheme": "conan1", + "scheme": "conan", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0", + "expected_vers": "vers:conan/2.4.0", "gitlab_scheme": "conan" }, { "test_index": 146, - "scheme": "conan1", + "scheme": "conan", "native": "<=0.14", - "expected_vers": "vers:conan1/<=0.14.0", + "expected_vers": "vers:conan/<=0.14.0", "gitlab_scheme": "conan" }, { "test_index": 147, - "scheme": "conan1", + "scheme": "conan", "native": "<1.80.0", - "expected_vers": "vers:conan1/<1.80.0", + "expected_vers": "vers:conan/<1.80.0", "gitlab_scheme": "conan" }, { "test_index": 148, - "scheme": "conan1", + "scheme": "conan", "native": "<1.80.0", - "expected_vers": "vers:conan1/<1.80.0", + "expected_vers": "vers:conan/<1.80.0", "gitlab_scheme": "conan" }, { "test_index": 149, - "scheme": "conan1", + "scheme": "conan", "native": "<1.80.0", - "expected_vers": "vers:conan1/<1.80.0", + "expected_vers": "vers:conan/<1.80.0", "gitlab_scheme": "conan" }, { "test_index": 150, - "scheme": "conan1", + "scheme": "conan", "native": "<1.80.0", - "expected_vers": "vers:conan1/<1.80.0", + "expected_vers": "vers:conan/<1.80.0", "gitlab_scheme": "conan" }, { "test_index": 151, - "scheme": "conan1", + "scheme": "conan", "native": "<1.80.0", - "expected_vers": "vers:conan1/<1.80.0", + "expected_vers": "vers:conan/<1.80.0", "gitlab_scheme": "conan" }, { "test_index": 152, - "scheme": "conan1", + "scheme": "conan", "native": "<1.80.0", - "expected_vers": "vers:conan1/<1.80.0", + "expected_vers": "vers:conan/<1.80.0", "gitlab_scheme": "conan" }, { "test_index": 153, - "scheme": "conan1", + "scheme": "conan", "native": "=3.4.1", - "expected_vers": "vers:conan1/3.4.1", + "expected_vers": "vers:conan/3.4.1", "gitlab_scheme": "conan" }, { "test_index": 154, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.4.0 <3.4.2", - "expected_vers": "vers:conan1/>=3.4.0|<3.4.2", + "expected_vers": "vers:conan/>=3.4.0|<3.4.2", "gitlab_scheme": "conan" }, { "test_index": 155, - "scheme": "conan1", + "scheme": "conan", "native": "<3.5.2", - "expected_vers": "vers:conan1/<3.5.2", + "expected_vers": "vers:conan/<3.5.2", "gitlab_scheme": "conan" }, { "test_index": 156, - "scheme": "conan1", + "scheme": "conan", "native": "<3.5.2", - "expected_vers": "vers:conan1/<3.5.2", + "expected_vers": "vers:conan/<3.5.2", "gitlab_scheme": "conan" }, { "test_index": 157, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.4.1 <=3.5.2", - "expected_vers": "vers:conan1/>=3.4.1|<=3.5.2", + "expected_vers": "vers:conan/>=3.4.1|<=3.5.2", "gitlab_scheme": "conan" }, { "test_index": 158, - "scheme": "conan1", + "scheme": "conan", "native": "=3.6.0", - "expected_vers": "vers:conan1/3.6.0", + "expected_vers": "vers:conan/3.6.0", "gitlab_scheme": "conan" }, { "test_index": 159, - "scheme": "conan1", + "scheme": "conan", "native": "=3.6.0", - "expected_vers": "vers:conan1/3.6.0", + "expected_vers": "vers:conan/3.6.0", "gitlab_scheme": "conan" }, { "test_index": 160, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.0.0 <3.6.2", - "expected_vers": "vers:conan1/>=3.0.0|<3.6.2", + "expected_vers": "vers:conan/>=3.0.0|<3.6.2", "gitlab_scheme": "conan" }, { "test_index": 161, - "scheme": "conan1", + "scheme": "conan", "native": ">=0.6.0 <=0.6.1", - "expected_vers": "vers:conan1/>=0.6.0|<=0.6.1", + "expected_vers": "vers:conan/>=0.6.0|<=0.6.1", "gitlab_scheme": "conan" }, { "test_index": 162, - "scheme": "conan1", + "scheme": "conan", "native": ">=0.6.0 <=0.6.1", - "expected_vers": "vers:conan1/>=0.6.0|<=0.6.1", + "expected_vers": "vers:conan/>=0.6.0|<=0.6.1", "gitlab_scheme": "conan" }, { "test_index": 163, - "scheme": "conan1", + "scheme": "conan", "native": "=3.3", - "expected_vers": "vers:conan1/3.3.0", + "expected_vers": "vers:conan/3.3.0", "gitlab_scheme": "conan" }, { "test_index": 164, - "scheme": "conan1", + "scheme": "conan", "native": ">=7.29.0 <=7.71.1", - "expected_vers": "vers:conan1/>=7.29.0|<=7.71.1", + "expected_vers": "vers:conan/>=7.29.0|<=7.71.1", "gitlab_scheme": "conan" }, { "test_index": 165, - "scheme": "conan1", + "scheme": "conan", "native": ">=7.21.0 <7.74.0", - "expected_vers": "vers:conan1/>=7.21.0|<7.74.0", + "expected_vers": "vers:conan/>=7.21.0|<7.74.0", "gitlab_scheme": "conan" }, { "test_index": 166, - "scheme": "conan1", + "scheme": "conan", "native": ">=7.41.0 <7.74.0", - "expected_vers": "vers:conan1/>=7.41.0|<7.74.0", + "expected_vers": "vers:conan/>=7.41.0|<7.74.0", "gitlab_scheme": "conan" }, { "test_index": 167, - "scheme": "conan1", + "scheme": "conan", "native": ">=7.1.1 <=7.75.0", - "expected_vers": "vers:conan1/>=7.1.1|<=7.75.0", + "expected_vers": "vers:conan/>=7.1.1|<=7.75.0", "gitlab_scheme": "conan" }, { "test_index": 168, - "scheme": "conan1", + "scheme": "conan", "native": ">=7.63.0 <=7.75.0", - "expected_vers": "vers:conan1/>=7.63.0|<=7.75.0", + "expected_vers": "vers:conan/>=7.63.0|<=7.75.0", "gitlab_scheme": "conan" }, { "test_index": 169, - "scheme": "conan1", + "scheme": "conan", "native": ">=7.10.4 <7.77.0", - "expected_vers": "vers:conan1/>=7.10.4|<7.77.0", + "expected_vers": "vers:conan/>=7.10.4|<7.77.0", "gitlab_scheme": "conan" }, { "test_index": 170, - "scheme": "conan1", + "scheme": "conan", "native": ">=7.73.0 <=7.78.0", - "expected_vers": "vers:conan1/>=7.73.0|<=7.78.0", + "expected_vers": "vers:conan/>=7.73.0|<=7.78.0", "gitlab_scheme": "conan" }, { "test_index": 171, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 172, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 173, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 174, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 175, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 176, - "scheme": "conan1", + "scheme": "conan", "native": "<=1.0.8", - "expected_vers": "vers:conan1/<=1.0.8", + "expected_vers": "vers:conan/<=1.0.8", "gitlab_scheme": "conan" }, { "test_index": 177, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 178, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 179, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 180, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 181, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 182, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 183, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 184, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 185, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 186, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 187, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 188, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 189, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 190, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 191, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 192, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.8", - "expected_vers": "vers:conan1/1.0.8", + "expected_vers": "vers:conan/1.0.8", "gitlab_scheme": "conan" }, { "test_index": 193, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.9", - "expected_vers": "vers:conan1/1.0.9", + "expected_vers": "vers:conan/1.0.9", "gitlab_scheme": "conan" }, { "test_index": 194, - "scheme": "conan1", + "scheme": "conan", "native": "=0.4.0", - "expected_vers": "vers:conan1/0.4.0", + "expected_vers": "vers:conan/0.4.0", "gitlab_scheme": "conan" }, { "test_index": 195, - "scheme": "conan1", + "scheme": "conan", "native": "=0.4.0", - "expected_vers": "vers:conan1/0.4.0", + "expected_vers": "vers:conan/0.4.0", "gitlab_scheme": "conan" }, { "test_index": 196, - "scheme": "conan1", + "scheme": "conan", "native": "=0.4.1", - "expected_vers": "vers:conan1/0.4.1", + "expected_vers": "vers:conan/0.4.1", "gitlab_scheme": "conan" }, { "test_index": 197, - "scheme": "conan1", + "scheme": "conan", "native": "<0.28.4", - "expected_vers": "vers:conan1/<0.28.4", + "expected_vers": "vers:conan/<0.28.4", "gitlab_scheme": "conan" }, { "test_index": 198, - "scheme": "conan1", + "scheme": "conan", "native": "<0.28.4", - "expected_vers": "vers:conan1/<0.28.4", + "expected_vers": "vers:conan/<0.28.4", "gitlab_scheme": "conan" }, { "test_index": 199, - "scheme": "conan1", + "scheme": "conan", "native": "=2.0.4", - "expected_vers": "vers:conan1/2.0.4", + "expected_vers": "vers:conan/2.0.4", "gitlab_scheme": "conan" }, { "test_index": 200, - "scheme": "conan1", + "scheme": "conan", "native": "<2.0.4", - "expected_vers": "vers:conan1/<2.0.4", + "expected_vers": "vers:conan/<2.0.4", "gitlab_scheme": "conan" }, { "test_index": 201, - "scheme": "conan1", + "scheme": "conan", "native": "=2.0.90", - "expected_vers": "vers:conan1/2.0.90", + "expected_vers": "vers:conan/2.0.90", "gitlab_scheme": "conan" }, { "test_index": 202, - "scheme": "conan1", + "scheme": "conan", "native": ">1.5.3 <=2.0.90", - "expected_vers": "vers:conan1/>1.5.3|<=2.0.90", + "expected_vers": "vers:conan/>1.5.3|<=2.0.90", "gitlab_scheme": "conan" }, { "test_index": 203, - "scheme": "conan1", + "scheme": "conan", "native": "<9d", - "expected_vers": "vers:conan1/<9.0.0-d", + "expected_vers": "vers:conan/<9.0.0-d", "gitlab_scheme": "conan" }, { "test_index": 204, - "scheme": "conan1", + "scheme": "conan", "native": "<9d", - "expected_vers": "vers:conan1/<9.0.0-d", + "expected_vers": "vers:conan/<9.0.0-d", "gitlab_scheme": "conan" }, { "test_index": 205, - "scheme": "conan1", + "scheme": "conan", "native": "<1.64", - "expected_vers": "vers:conan1/<1.64.0", + "expected_vers": "vers:conan/<1.64.0", "gitlab_scheme": "conan" }, { "test_index": 206, - "scheme": "conan1", + "scheme": "conan", "native": "<3.1.7", - "expected_vers": "vers:conan1/<3.1.7", + "expected_vers": "vers:conan/<3.1.7", "gitlab_scheme": "conan" }, { "test_index": 207, - "scheme": "conan1", + "scheme": "conan", "native": "=1.6.0", - "expected_vers": "vers:conan1/1.6.0", + "expected_vers": "vers:conan/1.6.0", "gitlab_scheme": "conan" }, { "test_index": 208, - "scheme": "conan1", + "scheme": "conan", "native": "<0.20", - "expected_vers": "vers:conan1/<0.20.0", + "expected_vers": "vers:conan/<0.20.0", "gitlab_scheme": "conan" }, { "test_index": 209, - "scheme": "conan1", + "scheme": "conan", "native": "<=0.20", - "expected_vers": "vers:conan1/<=0.20.0", + "expected_vers": "vers:conan/<=0.20.0", "gitlab_scheme": "conan" }, { "test_index": 210, - "scheme": "conan1", + "scheme": "conan", "native": "<0.20.1", - "expected_vers": "vers:conan1/<0.20.1", + "expected_vers": "vers:conan/<0.20.1", "gitlab_scheme": "conan" }, { "test_index": 211, - "scheme": "conan1", + "scheme": "conan", "native": "<0.20.0", - "expected_vers": "vers:conan1/<0.20.0", + "expected_vers": "vers:conan/<0.20.0", "gitlab_scheme": "conan" }, { "test_index": 212, - "scheme": "conan1", + "scheme": "conan", "native": "=0.20.0", - "expected_vers": "vers:conan1/0.20.0", + "expected_vers": "vers:conan/0.20.0", "gitlab_scheme": "conan" }, { "test_index": 213, - "scheme": "conan1", + "scheme": "conan", "native": "<=3.4.0", - "expected_vers": "vers:conan1/<=3.4.0", + "expected_vers": "vers:conan/<=3.4.0", "gitlab_scheme": "conan" }, { "test_index": 214, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.30", - "expected_vers": "vers:conan1/1.0.30", + "expected_vers": "vers:conan/1.0.30", "gitlab_scheme": "conan" }, { "test_index": 215, - "scheme": "conan1", + "scheme": "conan", "native": "=1.1.10", - "expected_vers": "vers:conan1/1.1.10", + "expected_vers": "vers:conan/1.1.10", "gitlab_scheme": "conan" }, { "test_index": 216, - "scheme": "conan1", + "scheme": "conan", "native": "<4.2.0", - "expected_vers": "vers:conan1/<4.2.0", + "expected_vers": "vers:conan/<4.2.0", "gitlab_scheme": "conan" }, { "test_index": 217, - "scheme": "conan1", + "scheme": "conan", "native": "<4.2.0", - "expected_vers": "vers:conan1/<4.2.0", + "expected_vers": "vers:conan/<4.2.0", "gitlab_scheme": "conan" }, { "test_index": 218, - "scheme": "conan1", + "scheme": "conan", "native": "<4.2.0", - "expected_vers": "vers:conan1/<4.2.0", + "expected_vers": "vers:conan/<4.2.0", "gitlab_scheme": "conan" }, { "test_index": 219, - "scheme": "conan1", + "scheme": "conan", "native": "<4.2.0", - "expected_vers": "vers:conan1/<4.2.0", + "expected_vers": "vers:conan/<4.2.0", "gitlab_scheme": "conan" }, { "test_index": 220, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.9.0 <=4.3.0", - "expected_vers": "vers:conan1/>=3.9.0|<=4.3.0", + "expected_vers": "vers:conan/>=3.9.0|<=4.3.0", "gitlab_scheme": "conan" }, { "test_index": 221, - "scheme": "conan1", + "scheme": "conan", "native": ">=4.0.0 <=4.3.0", - "expected_vers": "vers:conan1/>=4.0.0|<=4.3.0", + "expected_vers": "vers:conan/>=4.0.0|<=4.3.0", "gitlab_scheme": "conan" }, { "test_index": 222, - "scheme": "conan1", + "scheme": "conan", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0", + "expected_vers": "vers:conan/4.3.0", "gitlab_scheme": "conan" }, { "test_index": 223, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.9.0 <=4.3.0", - "expected_vers": "vers:conan1/>=3.9.0|<=4.3.0", + "expected_vers": "vers:conan/>=3.9.0|<=4.3.0", "gitlab_scheme": "conan" }, { "test_index": 224, - "scheme": "conan1", + "scheme": "conan", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0", + "expected_vers": "vers:conan/4.3.0", "gitlab_scheme": "conan" }, { "test_index": 225, - "scheme": "conan1", + "scheme": "conan", "native": "<=4.3.0", - "expected_vers": "vers:conan1/<=4.3.0", + "expected_vers": "vers:conan/<=4.3.0", "gitlab_scheme": "conan" }, { "test_index": 226, - "scheme": "conan1", + "scheme": "conan", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0", + "expected_vers": "vers:conan/4.3.0", "gitlab_scheme": "conan" }, { "test_index": 227, - "scheme": "conan1", + "scheme": "conan", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0", + "expected_vers": "vers:conan/4.3.0", "gitlab_scheme": "conan" }, { "test_index": 228, - "scheme": "conan1", + "scheme": "conan", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0", + "expected_vers": "vers:conan/4.3.0", "gitlab_scheme": "conan" }, { "test_index": 229, - "scheme": "conan1", + "scheme": "conan", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0", + "expected_vers": "vers:conan/4.3.0", "gitlab_scheme": "conan" }, { "test_index": 230, - "scheme": "conan1", + "scheme": "conan", "native": "<4.4.0", - "expected_vers": "vers:conan1/<4.4.0", + "expected_vers": "vers:conan/<4.4.0", "gitlab_scheme": "conan" }, { "test_index": 231, - "scheme": "conan1", + "scheme": "conan", "native": "<4.4.0", - "expected_vers": "vers:conan1/<4.4.0", + "expected_vers": "vers:conan/<4.4.0", "gitlab_scheme": "conan" }, { "test_index": 232, - "scheme": "conan1", + "scheme": "conan", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0", + "expected_vers": "vers:conan/4.3.0", "gitlab_scheme": "conan" }, { "test_index": 233, - "scheme": "conan1", + "scheme": "conan", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0", + "expected_vers": "vers:conan/4.3.0", "gitlab_scheme": "conan" }, { "test_index": 234, - "scheme": "conan1", + "scheme": "conan", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0", + "expected_vers": "vers:conan/4.4.0", "gitlab_scheme": "conan" }, { "test_index": 235, - "scheme": "conan1", + "scheme": "conan", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0", + "expected_vers": "vers:conan/4.4.0", "gitlab_scheme": "conan" }, { "test_index": 236, - "scheme": "conan1", + "scheme": "conan", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0", + "expected_vers": "vers:conan/4.4.0", "gitlab_scheme": "conan" }, { "test_index": 237, - "scheme": "conan1", + "scheme": "conan", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0", + "expected_vers": "vers:conan/4.3.0", "gitlab_scheme": "conan" }, { "test_index": 238, - "scheme": "conan1", + "scheme": "conan", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0", + "expected_vers": "vers:conan/4.4.0", "gitlab_scheme": "conan" }, { "test_index": 239, - "scheme": "conan1", + "scheme": "conan", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0", + "expected_vers": "vers:conan/4.4.0", "gitlab_scheme": "conan" }, { "test_index": 240, - "scheme": "conan1", + "scheme": "conan", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0", + "expected_vers": "vers:conan/4.4.0", "gitlab_scheme": "conan" }, { "test_index": 241, - "scheme": "conan1", + "scheme": "conan", "native": "<4.4.0", - "expected_vers": "vers:conan1/<4.4.0", + "expected_vers": "vers:conan/<4.4.0", "gitlab_scheme": "conan" }, { "test_index": 242, - "scheme": "conan1", + "scheme": "conan", "native": "<4.4.0", - "expected_vers": "vers:conan1/<4.4.0", + "expected_vers": "vers:conan/<4.4.0", "gitlab_scheme": "conan" }, { "test_index": 243, - "scheme": "conan1", + "scheme": "conan", "native": "<4.4.0", - "expected_vers": "vers:conan1/<4.4.0", + "expected_vers": "vers:conan/<4.4.0", "gitlab_scheme": "conan" }, { "test_index": 244, - "scheme": "conan1", + "scheme": "conan", "native": "<=4.4.0", - "expected_vers": "vers:conan1/<=4.4.0", + "expected_vers": "vers:conan/<=4.4.0", "gitlab_scheme": "conan" }, { "test_index": 245, - "scheme": "conan1", + "scheme": "conan", "native": "=4.0.3-35", - "expected_vers": "vers:conan1/4.0.3-35", + "expected_vers": "vers:conan/4.0.3-35", "gitlab_scheme": "conan" }, { "test_index": 246, - "scheme": "conan1", + "scheme": "conan", "native": "=4.4.0", - "expected_vers": "vers:conan1/4.4.0", + "expected_vers": "vers:conan/4.4.0", "gitlab_scheme": "conan" }, { "test_index": 247, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.9.0 <=4.4.0", - "expected_vers": "vers:conan1/>=3.9.0|<=4.4.0", + "expected_vers": "vers:conan/>=3.9.0|<=4.4.0", "gitlab_scheme": "conan" }, { "test_index": 248, - "scheme": "conan1", + "scheme": "conan", "native": "<=4.4.0", - "expected_vers": "vers:conan1/<=4.4.0", + "expected_vers": "vers:conan/<=4.4.0", "gitlab_scheme": "conan" }, { "test_index": 249, - "scheme": "conan1", + "scheme": "conan", "native": "<=4.4.0", - "expected_vers": "vers:conan1/<=4.4.0", + "expected_vers": "vers:conan/<=4.4.0", "gitlab_scheme": "conan" }, { "test_index": 250, - "scheme": "conan1", + "scheme": "conan", "native": "<=4.4.0", - "expected_vers": "vers:conan1/<=4.4.0", + "expected_vers": "vers:conan/<=4.4.0", "gitlab_scheme": "conan" }, { "test_index": 251, - "scheme": "conan1", + "scheme": "conan", "native": "<=4.4.0", - "expected_vers": "vers:conan1/<=4.4.0", + "expected_vers": "vers:conan/<=4.4.0", "gitlab_scheme": "conan" }, { "test_index": 252, - "scheme": "conan1", + "scheme": "conan", "native": "<=4.4.0", - "expected_vers": "vers:conan1/<=4.4.0", + "expected_vers": "vers:conan/<=4.4.0", "gitlab_scheme": "conan" }, { "test_index": 253, - "scheme": "conan1", + "scheme": "conan", "native": "<4.5.0", - "expected_vers": "vers:conan1/<4.5.0", + "expected_vers": "vers:conan/<4.5.0", "gitlab_scheme": "conan" }, { "test_index": 254, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.1", - "expected_vers": "vers:conan1/<1.0.1", + "expected_vers": "vers:conan/<1.0.1", "gitlab_scheme": "conan" }, { "test_index": 255, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.1", - "expected_vers": "vers:conan1/<1.0.1", + "expected_vers": "vers:conan/<1.0.1", "gitlab_scheme": "conan" }, { "test_index": 256, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.1", - "expected_vers": "vers:conan1/<1.0.1", + "expected_vers": "vers:conan/<1.0.1", "gitlab_scheme": "conan" }, { "test_index": 257, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.1", - "expected_vers": "vers:conan1/<1.0.1", + "expected_vers": "vers:conan/<1.0.1", "gitlab_scheme": "conan" }, { "test_index": 258, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.1", - "expected_vers": "vers:conan1/<1.0.1", + "expected_vers": "vers:conan/<1.0.1", "gitlab_scheme": "conan" }, { "test_index": 259, - "scheme": "conan1", + "scheme": "conan", "native": "=2.9.10", - "expected_vers": "vers:conan1/2.9.10", + "expected_vers": "vers:conan/2.9.10", "gitlab_scheme": "conan" }, { "test_index": 260, - "scheme": "conan1", + "scheme": "conan", "native": "=2.9.10", - "expected_vers": "vers:conan1/2.9.10", + "expected_vers": "vers:conan/2.9.10", "gitlab_scheme": "conan" }, { "test_index": 261, - "scheme": "conan1", + "scheme": "conan", "native": "<2.9.11", - "expected_vers": "vers:conan1/<2.9.11", + "expected_vers": "vers:conan/<2.9.11", "gitlab_scheme": "conan" }, { "test_index": 262, - "scheme": "conan1", + "scheme": "conan", "native": "<2.9.11", - "expected_vers": "vers:conan1/<2.9.11", + "expected_vers": "vers:conan/<2.9.11", "gitlab_scheme": "conan" }, { "test_index": 263, - "scheme": "conan1", + "scheme": "conan", "native": "<2.9.11", - "expected_vers": "vers:conan1/<2.9.11", + "expected_vers": "vers:conan/<2.9.11", "gitlab_scheme": "conan" }, { "test_index": 264, - "scheme": "conan1", + "scheme": "conan", "native": "<2.9.11", - "expected_vers": "vers:conan1/<2.9.11", + "expected_vers": "vers:conan/<2.9.11", "gitlab_scheme": "conan" }, { "test_index": 265, - "scheme": "conan1", + "scheme": "conan", "native": "<2.9.11", - "expected_vers": "vers:conan1/<2.9.11", + "expected_vers": "vers:conan/<2.9.11", "gitlab_scheme": "conan" }, { "test_index": 266, - "scheme": "conan1", + "scheme": "conan", "native": "<2.9.13", - "expected_vers": "vers:conan1/<2.9.13", + "expected_vers": "vers:conan/<2.9.13", "gitlab_scheme": "conan" }, { "test_index": 267, - "scheme": "conan1", + "scheme": "conan", "native": "<2.9.14", - "expected_vers": "vers:conan1/<2.9.14", + "expected_vers": "vers:conan/<2.9.14", "gitlab_scheme": "conan" }, { "test_index": 268, - "scheme": "conan1", + "scheme": "conan", "native": "<2.10.3", - "expected_vers": "vers:conan1/<2.10.3", + "expected_vers": "vers:conan/<2.10.3", "gitlab_scheme": "conan" }, { "test_index": 269, - "scheme": "conan1", + "scheme": "conan", "native": "<2.10.3", - "expected_vers": "vers:conan1/<2.10.3", + "expected_vers": "vers:conan/<2.10.3", "gitlab_scheme": "conan" }, { "test_index": 270, - "scheme": "conan1", + "scheme": "conan", "native": "<1.1.35", - "expected_vers": "vers:conan1/<1.1.35", + "expected_vers": "vers:conan/<1.1.35", "gitlab_scheme": "conan" }, { "test_index": 271, - "scheme": "conan1", + "scheme": "conan", "native": "<=0.11.4", - "expected_vers": "vers:conan1/<=0.11.4", + "expected_vers": "vers:conan/<=0.11.4", "gitlab_scheme": "conan" }, { "test_index": 272, - "scheme": "conan1", + "scheme": "conan", "native": "<0.12.1", - "expected_vers": "vers:conan1/<0.12.1", + "expected_vers": "vers:conan/<0.12.1", "gitlab_scheme": "conan" }, { "test_index": 273, - "scheme": "conan1", + "scheme": "conan", "native": "<0.12.1", - "expected_vers": "vers:conan1/<0.12.1", + "expected_vers": "vers:conan/<0.12.1", "gitlab_scheme": "conan" }, { "test_index": 274, - "scheme": "conan1", + "scheme": "conan", "native": "<=0.12.1", - "expected_vers": "vers:conan1/<=0.12.1", + "expected_vers": "vers:conan/<=0.12.1", "gitlab_scheme": "conan" }, { "test_index": 275, - "scheme": "conan1", + "scheme": "conan", "native": "<=0.12.1", - "expected_vers": "vers:conan1/<=0.12.1", + "expected_vers": "vers:conan/<=0.12.1", "gitlab_scheme": "conan" }, { "test_index": 276, - "scheme": "conan1", + "scheme": "conan", "native": "<=0.12.1", - "expected_vers": "vers:conan1/<=0.12.1", + "expected_vers": "vers:conan/<=0.12.1", "gitlab_scheme": "conan" }, { "test_index": 277, - "scheme": "conan1", + "scheme": "conan", "native": "=0.12.1", - "expected_vers": "vers:conan1/0.12.1", + "expected_vers": "vers:conan/0.12.1", "gitlab_scheme": "conan" }, { "test_index": 278, - "scheme": "conan1", + "scheme": "conan", "native": "=0.12.1", - "expected_vers": "vers:conan1/0.12.1", + "expected_vers": "vers:conan/0.12.1", "gitlab_scheme": "conan" }, { "test_index": 279, - "scheme": "conan1", + "scheme": "conan", "native": "=0.12.1", - "expected_vers": "vers:conan1/0.12.1", + "expected_vers": "vers:conan/0.12.1", "gitlab_scheme": "conan" }, { "test_index": 280, - "scheme": "conan1", + "scheme": "conan", "native": "<=5.4.0", - "expected_vers": "vers:conan1/<=5.4.0", + "expected_vers": "vers:conan/<=5.4.0", "gitlab_scheme": "conan" }, { "test_index": 281, - "scheme": "conan1", + "scheme": "conan", "native": "=5.4.0", - "expected_vers": "vers:conan1/5.4.0", + "expected_vers": "vers:conan/5.4.0", "gitlab_scheme": "conan" }, { "test_index": 282, - "scheme": "conan1", + "scheme": "conan", "native": "<=5.4.0", - "expected_vers": "vers:conan1/<=5.4.0", + "expected_vers": "vers:conan/<=5.4.0", "gitlab_scheme": "conan" }, { "test_index": 283, - "scheme": "conan1", + "scheme": "conan", "native": "=5.4.0", - "expected_vers": "vers:conan1/5.4.0", + "expected_vers": "vers:conan/5.4.0", "gitlab_scheme": "conan" }, { "test_index": 284, - "scheme": "conan1", + "scheme": "conan", "native": "=5.4.0", - "expected_vers": "vers:conan1/5.4.0", + "expected_vers": "vers:conan/5.4.0", "gitlab_scheme": "conan" }, { "test_index": 285, - "scheme": "conan1", + "scheme": "conan", "native": "=5.4.0", - "expected_vers": "vers:conan1/5.4.0", + "expected_vers": "vers:conan/5.4.0", "gitlab_scheme": "conan" }, { "test_index": 286, - "scheme": "conan1", + "scheme": "conan", "native": "=5.4.0", - "expected_vers": "vers:conan1/5.4.0", + "expected_vers": "vers:conan/5.4.0", "gitlab_scheme": "conan" }, { "test_index": 287, - "scheme": "conan1", + "scheme": "conan", "native": ">=5.1.0 <5.3.5||>=5.4.0 <5.4.4", - "expected_vers": "vers:conan1/>=5.1.0|<5.3.5|>=5.4.0|<5.4.4", + "expected_vers": "vers:conan/>=5.1.0|<5.3.5|>=5.4.0|<5.4.4", "gitlab_scheme": "conan" }, { "test_index": 288, - "scheme": "conan1", + "scheme": "conan", "native": "=5.4.3", - "expected_vers": "vers:conan1/5.4.3", + "expected_vers": "vers:conan/5.4.3", "gitlab_scheme": "conan" }, { "test_index": 289, - "scheme": "conan1", + "scheme": "conan", "native": ">=5.4.0 <=5.4.3", - "expected_vers": "vers:conan1/>=5.4.0|<=5.4.3", + "expected_vers": "vers:conan/>=5.4.0|<=5.4.3", "gitlab_scheme": "conan" }, { "test_index": 290, - "scheme": "conan1", + "scheme": "conan", "native": ">=5.4.0 <=5.4.4", - "expected_vers": "vers:conan1/>=5.4.0|<=5.4.4", + "expected_vers": "vers:conan/>=5.4.0|<=5.4.4", "gitlab_scheme": "conan" }, { "test_index": 291, - "scheme": "conan1", + "scheme": "conan", "native": ">=5.4.2 <=5.4.4", - "expected_vers": "vers:conan1/>=5.4.2|<=5.4.4", + "expected_vers": "vers:conan/>=5.4.2|<=5.4.4", "gitlab_scheme": "conan" }, { "test_index": 292, - "scheme": "conan1", + "scheme": "conan", "native": "=1.8.3", - "expected_vers": "vers:conan1/1.8.3", + "expected_vers": "vers:conan/1.8.3", "gitlab_scheme": "conan" }, { "test_index": 293, - "scheme": "conan1", + "scheme": "conan", "native": "<2.7.17||>=2.8.0 <2.16.8||>=2.17.0 <2.24.0", - "expected_vers": "vers:conan1/<2.7.17|>=2.8.0|<2.16.8|>=2.17.0|<2.24.0", + "expected_vers": "vers:conan/<2.7.17|>=2.8.0|<2.16.8|>=2.17.0|<2.24.0", "gitlab_scheme": "conan" }, { "test_index": 294, - "scheme": "conan1", + "scheme": "conan", "native": "=4.0.0", - "expected_vers": "vers:conan1/4.0.0", + "expected_vers": "vers:conan/4.0.0", "gitlab_scheme": "conan" }, { "test_index": 295, - "scheme": "conan1", + "scheme": "conan", "native": "<=6.2.1", - "expected_vers": "vers:conan1/<=6.2.1", + "expected_vers": "vers:conan/<=6.2.1", "gitlab_scheme": "conan" }, { "test_index": 296, - "scheme": "conan1", + "scheme": "conan", "native": "<6.3", - "expected_vers": "vers:conan1/<6.3.0", + "expected_vers": "vers:conan/<6.3.0", "gitlab_scheme": "conan" }, { "test_index": 297, - "scheme": "conan1", + "scheme": "conan", "native": "<3.7.2", - "expected_vers": "vers:conan1/<3.7.2", + "expected_vers": "vers:conan/<3.7.2", "gitlab_scheme": "conan" }, { "test_index": 298, - "scheme": "conan1", + "scheme": "conan", "native": "<3.7.3", - "expected_vers": "vers:conan1/<3.7.3", + "expected_vers": "vers:conan/<3.7.3", "gitlab_scheme": "conan" }, { "test_index": 299, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1", + "expected_vers": "vers:conan/<2.4.1", "gitlab_scheme": "conan" }, { "test_index": 300, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1", + "expected_vers": "vers:conan/<2.4.1", "gitlab_scheme": "conan" }, { "test_index": 301, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1", + "expected_vers": "vers:conan/<2.4.1", "gitlab_scheme": "conan" }, { "test_index": 302, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1", + "expected_vers": "vers:conan/<2.4.1", "gitlab_scheme": "conan" }, { "test_index": 303, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1", + "expected_vers": "vers:conan/<2.4.1", "gitlab_scheme": "conan" }, { "test_index": 304, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1", + "expected_vers": "vers:conan/<2.4.1", "gitlab_scheme": "conan" }, { "test_index": 305, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1", + "expected_vers": "vers:conan/<2.4.1", "gitlab_scheme": "conan" }, { "test_index": 306, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.1", - "expected_vers": "vers:conan1/<2.4.1", + "expected_vers": "vers:conan/<2.4.1", "gitlab_scheme": "conan" }, { "test_index": 307, - "scheme": "conan1", + "scheme": "conan", "native": "<2.5.2", - "expected_vers": "vers:conan1/<2.5.2", + "expected_vers": "vers:conan/<2.5.2", "gitlab_scheme": "conan" }, { "test_index": 308, - "scheme": "conan1", + "scheme": "conan", "native": "<2.5.2", - "expected_vers": "vers:conan1/<2.5.2", + "expected_vers": "vers:conan/<2.5.2", "gitlab_scheme": "conan" }, { "test_index": 309, - "scheme": "conan1", + "scheme": "conan", "native": "<2.5.2", - "expected_vers": "vers:conan1/<2.5.2", + "expected_vers": "vers:conan/<2.5.2", "gitlab_scheme": "conan" }, { "test_index": 310, - "scheme": "conan1", + "scheme": "conan", "native": "=2.3.0", - "expected_vers": "vers:conan1/2.3.0", + "expected_vers": "vers:conan/2.3.0", "gitlab_scheme": "conan" }, { "test_index": 311, - "scheme": "conan1", + "scheme": "conan", "native": "=2.3.0", - "expected_vers": "vers:conan1/2.3.0", + "expected_vers": "vers:conan/2.3.0", "gitlab_scheme": "conan" }, { "test_index": 312, - "scheme": "conan1", + "scheme": "conan", "native": "=2.3.0", - "expected_vers": "vers:conan1/2.3.0", + "expected_vers": "vers:conan/2.3.0", "gitlab_scheme": "conan" }, { "test_index": 313, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4", "gitlab_scheme": "conan" }, { "test_index": 314, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.5.7", - "expected_vers": "vers:conan1/<=2.5.7", + "expected_vers": "vers:conan/<=2.5.7", "gitlab_scheme": "conan" }, { "test_index": 315, - "scheme": "conan1", + "scheme": "conan", "native": "<2.5.4", - "expected_vers": "vers:conan1/<2.5.4", + "expected_vers": "vers:conan/<2.5.4", "gitlab_scheme": "conan" }, { "test_index": 316, - "scheme": "conan1", + "scheme": "conan", "native": "<2.5.4", - "expected_vers": "vers:conan1/<2.5.4", + "expected_vers": "vers:conan/<2.5.4", "gitlab_scheme": "conan" }, { "test_index": 317, - "scheme": "conan1", + "scheme": "conan", "native": "<2.5.4", - "expected_vers": "vers:conan1/<2.5.4", + "expected_vers": "vers:conan/<2.5.4", "gitlab_scheme": "conan" }, { "test_index": 318, - "scheme": "conan1", + "scheme": "conan", "native": "<2.5.4", - "expected_vers": "vers:conan1/<2.5.4", + "expected_vers": "vers:conan/<2.5.4", "gitlab_scheme": "conan" }, { "test_index": 319, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.5.7", - "expected_vers": "vers:conan1/<=2.5.7", + "expected_vers": "vers:conan/<=2.5.7", "gitlab_scheme": "conan" }, { "test_index": 320, - "scheme": "conan1", + "scheme": "conan", "native": "<3.0.1", - "expected_vers": "vers:conan1/<3.0.1", + "expected_vers": "vers:conan/<3.0.1", "gitlab_scheme": "conan" }, { "test_index": 321, - "scheme": "conan1", + "scheme": "conan", "native": "<3.0.1", - "expected_vers": "vers:conan1/<3.0.1", + "expected_vers": "vers:conan/<3.0.1", "gitlab_scheme": "conan" }, { "test_index": 322, - "scheme": "conan1", + "scheme": "conan", "native": "<3.0.1", - "expected_vers": "vers:conan1/<3.0.1", + "expected_vers": "vers:conan/<3.0.1", "gitlab_scheme": "conan" }, { "test_index": 323, - "scheme": "conan1", + "scheme": "conan", "native": "<3.0.1", - "expected_vers": "vers:conan1/<3.0.1", + "expected_vers": "vers:conan/<3.0.1", "gitlab_scheme": "conan" }, { "test_index": 324, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4", "gitlab_scheme": "conan" }, { "test_index": 325, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4", "gitlab_scheme": "conan" }, { "test_index": 326, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4", "gitlab_scheme": "conan" }, { "test_index": 327, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4", "gitlab_scheme": "conan" }, { "test_index": 328, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4", "gitlab_scheme": "conan" }, { "test_index": 329, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.3||>=2.5.0 <2.5.4", - "expected_vers": "vers:conan1/<2.4.3|>=2.5.0|<2.5.4", + "expected_vers": "vers:conan/<2.4.3|>=2.5.0|<2.5.4", "gitlab_scheme": "conan" }, { "test_index": 330, - "scheme": "conan1", + "scheme": "conan", "native": "<3.0.5", - "expected_vers": "vers:conan1/<3.0.5", + "expected_vers": "vers:conan/<3.0.5", "gitlab_scheme": "conan" }, { "test_index": 331, - "scheme": "conan1", + "scheme": "conan", "native": "<3.0.5", - "expected_vers": "vers:conan1/<3.0.5", + "expected_vers": "vers:conan/<3.0.5", "gitlab_scheme": "conan" }, { "test_index": 332, - "scheme": "conan1", + "scheme": "conan", "native": "<3.1.2", - "expected_vers": "vers:conan1/<3.1.2", + "expected_vers": "vers:conan/<3.1.2", "gitlab_scheme": "conan" }, { "test_index": 333, - "scheme": "conan1", + "scheme": "conan", "native": "=3.1.2", - "expected_vers": "vers:conan1/3.1.2", + "expected_vers": "vers:conan/3.1.2", "gitlab_scheme": "conan" }, { "test_index": 334, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.1.0 <3.1.4", - "expected_vers": "vers:conan1/>=3.1.0|<3.1.4", + "expected_vers": "vers:conan/>=3.1.0|<3.1.4", "gitlab_scheme": "conan" }, { "test_index": 335, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.3.1", - "expected_vers": "vers:conan1/<=2.3.1", + "expected_vers": "vers:conan/<=2.3.1", "gitlab_scheme": "conan" }, { "test_index": 336, - "scheme": "conan1", + "scheme": "conan", "native": "<=1.5.1||>=2.0.0 <2.4.0", - "expected_vers": "vers:conan1/<=1.5.1|>=2.0.0|<2.4.0", + "expected_vers": "vers:conan/<=1.5.1|>=2.0.0|<2.4.0", "gitlab_scheme": "conan" }, { "test_index": 337, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0", + "expected_vers": "vers:conan/<2.4.0", "gitlab_scheme": "conan" }, { "test_index": 338, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0", + "expected_vers": "vers:conan/<2.4.0", "gitlab_scheme": "conan" }, { "test_index": 339, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0", + "expected_vers": "vers:conan/<2.4.0", "gitlab_scheme": "conan" }, { "test_index": 340, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0", + "expected_vers": "vers:conan/<2.4.0", "gitlab_scheme": "conan" }, { "test_index": 341, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0", + "expected_vers": "vers:conan/<2.4.0", "gitlab_scheme": "conan" }, { "test_index": 342, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0", + "expected_vers": "vers:conan/<2.4.0", "gitlab_scheme": "conan" }, { "test_index": 343, - "scheme": "conan1", + "scheme": "conan", "native": "<2.4.0", - "expected_vers": "vers:conan1/<2.4.0", + "expected_vers": "vers:conan/<2.4.0", "gitlab_scheme": "conan" }, { "test_index": 344, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.3.1", - "expected_vers": "vers:conan1/<=2.3.1", + "expected_vers": "vers:conan/<=2.3.1", "gitlab_scheme": "conan" }, { "test_index": 345, - "scheme": "conan1", + "scheme": "conan", "native": "=2.3.1", - "expected_vers": "vers:conan1/2.3.1", + "expected_vers": "vers:conan/2.3.1", "gitlab_scheme": "conan" }, { "test_index": 346, - "scheme": "conan1", + "scheme": "conan", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0", + "expected_vers": "vers:conan/2.4.0", "gitlab_scheme": "conan" }, { "test_index": 347, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.4.0", - "expected_vers": "vers:conan1/<=2.4.0", + "expected_vers": "vers:conan/<=2.4.0", "gitlab_scheme": "conan" }, { "test_index": 348, - "scheme": "conan1", + "scheme": "conan", "native": "=2.4.0", - "expected_vers": "vers:conan1/2.4.0", + "expected_vers": "vers:conan/2.4.0", "gitlab_scheme": "conan" }, { "test_index": 349, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.1.1d <=1.1.1f", - "expected_vers": "vers:conan1/>=1.1.1-d|<=1.1.1-f", + "expected_vers": "vers:conan/>=1.1.1-d|<=1.1.1-f", "gitlab_scheme": "conan" }, { "test_index": 350, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.0.2 <=1.0.2v", - "expected_vers": "vers:conan1/>=1.0.2|<=1.0.2", + "expected_vers": "vers:conan/>=1.0.2|<=1.0.2", "gitlab_scheme": "conan" }, { "test_index": 351, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.0.2 <=1.0.2w||>=1.1.1 <=1.1.1h", - "expected_vers": "vers:conan1/<=1.0.2-w|>=1.0.2|<=1.1.1-h|>=1.1.1", + "expected_vers": "vers:conan/<=1.0.2-w|>=1.0.2|<=1.1.1-h|>=1.1.1", "gitlab_scheme": "conan" }, { "test_index": 352, - "scheme": "conan1", + "scheme": "conan", "native": "=1.0.2s", - "expected_vers": "vers:conan1/1.0.2-s", + "expected_vers": "vers:conan/1.0.2-s", "gitlab_scheme": "conan" }, { "test_index": 353, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.0.2 <1.0.2y||>=1.1.1 <1.1.1j", - "expected_vers": "vers:conan1/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1", + "expected_vers": "vers:conan/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1", "gitlab_scheme": "conan" }, { "test_index": 354, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.0.2 <1.0.2y||>=1.1.1 <1.1.1j", - "expected_vers": "vers:conan1/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1", + "expected_vers": "vers:conan/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1", "gitlab_scheme": "conan" }, { "test_index": 355, - "scheme": "conan1", + "scheme": "conan", "native": "<0", - "expected_vers": "vers:conan1/<0.0.0", + "expected_vers": "vers:conan/<0.0.0", "gitlab_scheme": "conan" }, { "test_index": 356, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.1.1 <1.1.1k", - "expected_vers": "vers:conan1/<1.1.1-k|>=1.1.1", + "expected_vers": "vers:conan/<1.1.1-k|>=1.1.1", "gitlab_scheme": "conan" }, { "test_index": 357, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.1.1h <1.1.1k", - "expected_vers": "vers:conan1/>=1.1.1-h|<1.1.1-k", + "expected_vers": "vers:conan/>=1.1.1-h|<1.1.1-k", "gitlab_scheme": "conan" }, { "test_index": 358, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.1.1 <1.1.1l", - "expected_vers": "vers:conan1/<1.1.1-l|>=1.1.1", + "expected_vers": "vers:conan/<1.1.1-l|>=1.1.1", "gitlab_scheme": "conan" }, { "test_index": 359, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.0.2 <1.0.2za||>=1.1.1 <1.1.1l", - "expected_vers": "vers:conan1/<1.0.2-za|>=1.0.2|<1.1.1-l|>=1.1.1", + "expected_vers": "vers:conan/<1.0.2-za|>=1.0.2|<1.1.1-l|>=1.1.1", "gitlab_scheme": "conan" }, { "test_index": 360, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.2||=1.1.0||=3.0.0", - "expected_vers": "vers:conan1/<1.0.2|1.1.0|3.0.0", + "expected_vers": "vers:conan/<1.0.2|1.1.0|3.0.0", "gitlab_scheme": "conan" }, { "test_index": 361, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.0.2 <1.1.1m||=3.0.0", - "expected_vers": "vers:conan1/>=1.0.2|<1.1.1-m|3.0.0", + "expected_vers": "vers:conan/>=1.0.2|<1.1.1-m|3.0.0", "gitlab_scheme": "conan" }, { "test_index": 362, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.0.2 <1.0.2zd||>=1.1.0 <1.1.1n||>=3.0.0 <3.0.2", - "expected_vers": "vers:conan1/<1.0.2-zd|>=1.0.2|>=1.1.0|<1.1.1-n|>=3.0.0|<3.0.2", + "expected_vers": "vers:conan/<1.0.2-zd|>=1.0.2|>=1.1.0|<1.1.1-n|>=3.0.0|<3.0.2", "gitlab_scheme": "conan" }, { "test_index": 363, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.0.2 <1.0.2ze||>=1.1.1 <1.1.1o||>=3.0.0 <3.0.3", - "expected_vers": "vers:conan1/<1.0.2-ze|>=1.0.2|<1.1.1-o|>=1.1.1|>=3.0.0|<3.0.3", + "expected_vers": "vers:conan/<1.0.2-ze|>=1.0.2|<1.1.1-o|>=1.1.1|>=3.0.0|<3.0.3", "gitlab_scheme": "conan" }, { "test_index": 364, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.0.0 <3.0.3", - "expected_vers": "vers:conan1/>=3.0.0|<3.0.3", + "expected_vers": "vers:conan/>=3.0.0|<3.0.3", "gitlab_scheme": "conan" }, { "test_index": 365, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.0.0 <3.0.3", - "expected_vers": "vers:conan1/>=3.0.0|<3.0.3", + "expected_vers": "vers:conan/>=3.0.0|<3.0.3", "gitlab_scheme": "conan" }, { "test_index": 366, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.0.0 <3.0.3", - "expected_vers": "vers:conan1/>=3.0.0|<3.0.3", + "expected_vers": "vers:conan/>=3.0.0|<3.0.3", "gitlab_scheme": "conan" }, { "test_index": 367, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.0.2 <1.0.2zf||>=1.1.1 <1.1.1p||>=3.0.0 <3.0.4", - "expected_vers": "vers:conan1/<1.0.2-zf|>=1.0.2|<1.1.1-p|>=1.1.1|>=3.0.0|<3.0.4", + "expected_vers": "vers:conan/<1.0.2-zf|>=1.0.2|<1.1.1-p|>=1.1.1|>=3.0.0|<3.0.4", "gitlab_scheme": "conan" }, { "test_index": 368, - "scheme": "conan1", + "scheme": "conan", "native": ">=1.1.1 <1.1.1q||>=3.0.0 <3.0.5", - "expected_vers": "vers:conan1/<1.1.1-q|>=1.1.1|>=3.0.0|<3.0.5", + "expected_vers": "vers:conan/<1.1.1-q|>=1.1.1|>=3.0.0|<3.0.5", "gitlab_scheme": "conan" }, { "test_index": 369, - "scheme": "conan1", + "scheme": "conan", "native": "=3.0.4", - "expected_vers": "vers:conan1/3.0.4", + "expected_vers": "vers:conan/3.0.4", "gitlab_scheme": "conan" }, { "test_index": 370, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.0.0 <3.0.6", - "expected_vers": "vers:conan1/>=3.0.0|<3.0.6", + "expected_vers": "vers:conan/>=3.0.0|<3.0.6", "gitlab_scheme": "conan" }, { "test_index": 371, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.0.0 <3.0.7", - "expected_vers": "vers:conan1/>=3.0.0|<3.0.7", + "expected_vers": "vers:conan/>=3.0.0|<3.0.7", "gitlab_scheme": "conan" }, { "test_index": 372, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.0.0 <3.0.7", - "expected_vers": "vers:conan1/>=3.0.0|<3.0.7", + "expected_vers": "vers:conan/>=3.0.0|<3.0.7", "gitlab_scheme": "conan" }, { "test_index": 373, - "scheme": "conan1", + "scheme": "conan", "native": ">=3.0.0 <=3.0.7", - "expected_vers": "vers:conan1/>=3.0.0|<=3.0.7", + "expected_vers": "vers:conan/>=3.0.0|<=3.0.7", "gitlab_scheme": "conan" }, { "test_index": 374, - "scheme": "conan1", + "scheme": "conan", "native": "<8.44", - "expected_vers": "vers:conan1/<8.44.0", + "expected_vers": "vers:conan/<8.44.0", "gitlab_scheme": "conan" }, { "test_index": 375, - "scheme": "conan1", + "scheme": "conan", "native": "<10.40", - "expected_vers": "vers:conan1/<10.40.0", + "expected_vers": "vers:conan/<10.40.0", "gitlab_scheme": "conan" }, { "test_index": 376, - "scheme": "conan1", + "scheme": "conan", "native": "<10.40", - "expected_vers": "vers:conan1/<10.40.0", + "expected_vers": "vers:conan/<10.40.0", "gitlab_scheme": "conan" }, { "test_index": 377, - "scheme": "conan1", + "scheme": "conan", "native": "<3.15.0", - "expected_vers": "vers:conan1/<3.15.0", + "expected_vers": "vers:conan/<3.15.0", "gitlab_scheme": "conan" }, { "test_index": 378, - "scheme": "conan1", + "scheme": "conan", "native": "<3.18.3||>=3.19.0 <3.19.5||>=3.20.0 <3.20.2||>=3.21.0 <3.21.6", - "expected_vers": "vers:conan1/<3.18.3|>=3.19.0|<3.19.5|>=3.20.0|<3.20.2|>=3.21.0|<3.21.6", + "expected_vers": "vers:conan/<3.18.3|>=3.19.0|<3.19.5|>=3.20.0|<3.20.2|>=3.21.0|<3.21.6", "gitlab_scheme": "conan" }, { "test_index": 379, - "scheme": "conan1", + "scheme": "conan", "native": "=1.3", - "expected_vers": "vers:conan1/1.3.0", + "expected_vers": "vers:conan/1.3.0", "gitlab_scheme": "conan" }, { "test_index": 380, - "scheme": "conan1", + "scheme": "conan", "native": "=2.2", - "expected_vers": "vers:conan1/2.2.0", + "expected_vers": "vers:conan/2.2.0", "gitlab_scheme": "conan" }, { "test_index": 381, - "scheme": "conan1", + "scheme": "conan", "native": "<=1.5.0", - "expected_vers": "vers:conan1/<=1.5.0", + "expected_vers": "vers:conan/<=1.5.0", "gitlab_scheme": "conan" }, { "test_index": 382, - "scheme": "conan1", + "scheme": "conan", "native": ">=4.0 <4.4.1", - "expected_vers": "vers:conan1/>=4.0.0|<4.4.1", + "expected_vers": "vers:conan/>=4.0.0|<4.4.1", "gitlab_scheme": "conan" }, { "test_index": 383, - "scheme": "conan1", + "scheme": "conan", "native": ">=4.0 <4.4.3", - "expected_vers": "vers:conan1/>=4.0.0|<4.4.3", + "expected_vers": "vers:conan/>=4.0.0|<4.4.3", "gitlab_scheme": "conan" }, { "test_index": 384, - "scheme": "conan1", + "scheme": "conan", "native": "<=2.0.1", - "expected_vers": "vers:conan1/<=2.0.1", + "expected_vers": "vers:conan/<=2.0.1", "gitlab_scheme": "conan" }, { "test_index": 385, - "scheme": "conan1", + "scheme": "conan", "native": "=cci.20200203", "expected_vers": null, "gitlab_scheme": "conan" }, { "test_index": 386, - "scheme": "conan1", + "scheme": "conan", "native": "=2.27", - "expected_vers": "vers:conan1/2.27.0", + "expected_vers": "vers:conan/2.27.0", "gitlab_scheme": "conan" }, { "test_index": 387, - "scheme": "conan1", + "scheme": "conan", "native": "=2.27", - "expected_vers": "vers:conan1/2.27.0", + "expected_vers": "vers:conan/2.27.0", "gitlab_scheme": "conan" }, { "test_index": 388, - "scheme": "conan1", + "scheme": "conan", "native": "=8.6.11", - "expected_vers": "vers:conan1/8.6.11", + "expected_vers": "vers:conan/8.6.11", "gitlab_scheme": "conan" }, { "test_index": 389, - "scheme": "conan1", + "scheme": "conan", "native": "=5.0.0", - "expected_vers": "vers:conan1/5.0.0", + "expected_vers": "vers:conan/5.0.0", "gitlab_scheme": "conan" }, { "test_index": 390, - "scheme": "conan1", + "scheme": "conan", "native": ">=0.9.3 <=0.13.0", - "expected_vers": "vers:conan1/>=0.9.3|<=0.13.0", + "expected_vers": "vers:conan/>=0.9.3|<=0.13.0", "gitlab_scheme": "conan" }, { "test_index": 391, - "scheme": "conan1", + "scheme": "conan", "native": "<2021.02.22.00", - "expected_vers": "vers:conan1/<2021.2.22+00", + "expected_vers": "vers:conan/<2021.2.22+00", "gitlab_scheme": "conan" }, { "test_index": 392, - "scheme": "conan1", + "scheme": "conan", "native": "<1.05.01", - "expected_vers": "vers:conan1/<1.5.1", + "expected_vers": "vers:conan/<1.5.1", "gitlab_scheme": "conan" }, { "test_index": 393, - "scheme": "conan1", + "scheme": "conan", "native": "<0.9.6", - "expected_vers": "vers:conan1/<0.9.6", + "expected_vers": "vers:conan/<0.9.6", "gitlab_scheme": "conan" }, { "test_index": 394, - "scheme": "conan1", + "scheme": "conan", "native": "<0.9.6", - "expected_vers": "vers:conan1/<0.9.6", + "expected_vers": "vers:conan/<0.9.6", "gitlab_scheme": "conan" }, { "test_index": 395, - "scheme": "conan1", + "scheme": "conan", "native": ">=19.0.0 <=20.8.0", - "expected_vers": "vers:conan1/>=19.0.0|<=20.8.0", + "expected_vers": "vers:conan/>=19.0.0|<=20.8.0", "gitlab_scheme": "conan" }, { "test_index": 396, - "scheme": "conan1", + "scheme": "conan", "native": ">=0.19.0 <0.30.0", - "expected_vers": "vers:conan1/>=0.19.0|<0.30.0", + "expected_vers": "vers:conan/>=0.19.0|<0.30.0", "gitlab_scheme": "conan" }, { "test_index": 397, - "scheme": "conan1", + "scheme": "conan", "native": ">=0.26.0 <0.30.0", - "expected_vers": "vers:conan1/>=0.26.0|<0.30.0", + "expected_vers": "vers:conan/>=0.26.0|<0.30.0", "gitlab_scheme": "conan" }, { "test_index": 398, - "scheme": "conan1", + "scheme": "conan", "native": "<0.30.0", - "expected_vers": "vers:conan1/<0.30.0", + "expected_vers": "vers:conan/<0.30.0", "gitlab_scheme": "conan" }, { "test_index": 399, - "scheme": "conan1", + "scheme": "conan", "native": "<0.33.1||>0.33.1 <0.34.1", - "expected_vers": "vers:conan1/<0.33.1|>0.33.1|<0.34.1", + "expected_vers": "vers:conan/<0.33.1|>0.33.1|<0.34.1", "gitlab_scheme": "conan" }, { "test_index": 400, - "scheme": "conan1", + "scheme": "conan", "native": ">=0.34.0 <0.34.2||>=0.35.0 <0.35.2", - "expected_vers": "vers:conan1/>=0.34.0|<0.34.2|>=0.35.0|<0.35.2", + "expected_vers": "vers:conan/>=0.34.0|<0.34.2|>=0.35.0|<0.35.2", "gitlab_scheme": "conan" }, { "test_index": 401, - "scheme": "conan1", + "scheme": "conan", "native": "<0.38.1", - "expected_vers": "vers:conan1/<0.38.1", + "expected_vers": "vers:conan/<0.38.1", "gitlab_scheme": "conan" }, { "test_index": 402, - "scheme": "conan1", + "scheme": "conan", "native": ">=0.37.0 <0.38.2", - "expected_vers": "vers:conan1/>=0.37.0|<0.38.2", + "expected_vers": "vers:conan/>=0.37.0|<0.38.2", "gitlab_scheme": "conan" }, { "test_index": 403, - "scheme": "conan1", + "scheme": "conan", "native": "<0.38.1", - "expected_vers": "vers:conan1/<0.38.1", + "expected_vers": "vers:conan/<0.38.1", "gitlab_scheme": "conan" }, { "test_index": 404, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.2||>=2.0.0 <2.0.2", - "expected_vers": "vers:conan1/<1.0.2|>=2.0.0|<2.0.2", + "expected_vers": "vers:conan/<1.0.2|>=2.0.0|<2.0.2", "gitlab_scheme": "conan" }, { "test_index": 405, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.2||>=2.0.0 <2.0.2", - "expected_vers": "vers:conan1/<1.0.2|>=2.0.0|<2.0.2", + "expected_vers": "vers:conan/<1.0.2|>=2.0.0|<2.0.2", "gitlab_scheme": "conan" }, { "test_index": 406, - "scheme": "conan1", + "scheme": "conan", "native": "<1.0.2||>=2.0.0 <2.0.2", - "expected_vers": "vers:conan1/<1.0.2|>=2.0.0|<2.0.2", + "expected_vers": "vers:conan/<1.0.2|>=2.0.0|<2.0.2", "gitlab_scheme": "conan" }, { "test_index": 407, - "scheme": "conan1", + "scheme": "conan", "native": "=4.3.0", - "expected_vers": "vers:conan1/4.3.0", + "expected_vers": "vers:conan/4.3.0", "gitlab_scheme": "conan" }, { "test_index": 408, - "scheme": "conan1", + "scheme": "conan", "native": "<4.4.0", - "expected_vers": "vers:conan1/<4.4.0", + "expected_vers": "vers:conan/<4.4.0", "gitlab_scheme": "conan" }, { "test_index": 409, - "scheme": "conan1", + "scheme": "conan", "native": "<4.5.0", - "expected_vers": "vers:conan1/<4.5.0", + "expected_vers": "vers:conan/<4.5.0", "gitlab_scheme": "conan" }, { "test_index": 410, - "scheme": "conan1", + "scheme": "conan", "native": "<4.5.0", - "expected_vers": "vers:conan1/<4.5.0", + "expected_vers": "vers:conan/<4.5.0", "gitlab_scheme": "conan" }, { "test_index": 411, - "scheme": "conan1", + "scheme": "conan", "native": "<4.5.0", - "expected_vers": "vers:conan1/<4.5.0", + "expected_vers": "vers:conan/<4.5.0", "gitlab_scheme": "conan" }, { "test_index": 412, - "scheme": "conan1", + "scheme": "conan", "native": "<4.5.0", - "expected_vers": "vers:conan1/<4.5.0", + "expected_vers": "vers:conan/<4.5.0", "gitlab_scheme": "conan" }, { "test_index": 413, - "scheme": "conan1", + "scheme": "conan", "native": "<4.6.0", - "expected_vers": "vers:conan1/<4.6.0", + "expected_vers": "vers:conan/<4.6.0", "gitlab_scheme": "conan" }, { "test_index": 414, - "scheme": "conan1", + "scheme": "conan", "native": "<4.6.0", - "expected_vers": "vers:conan1/<4.6.0", + "expected_vers": "vers:conan/<4.6.0", "gitlab_scheme": "conan" }, { "test_index": 415, - "scheme": "conan1", + "scheme": "conan", "native": "<4.7.0", - "expected_vers": "vers:conan1/<4.7.0", + "expected_vers": "vers:conan/<4.7.0", "gitlab_scheme": "conan" }, { "test_index": 416, - "scheme": "conan1", + "scheme": "conan", "native": ">=4.6.0 <4.8.0", - "expected_vers": "vers:conan1/>=4.6.0|<4.8.0", + "expected_vers": "vers:conan/>=4.6.0|<4.8.0", "gitlab_scheme": "conan" }, { "test_index": 417, - "scheme": "conan1", + "scheme": "conan", "native": "<4.8.1", - "expected_vers": "vers:conan1/<4.8.1", + "expected_vers": "vers:conan/<4.8.1", "gitlab_scheme": "conan" }, { "test_index": 418, - "scheme": "conan1", + "scheme": "conan", "native": "<=5.0.0", - "expected_vers": "vers:conan1/<=5.0.0", + "expected_vers": "vers:conan/<=5.0.0", "gitlab_scheme": "conan" }, { "test_index": 419, - "scheme": "conan1", + "scheme": "conan", "native": ">=5.0.0 <5.1.1", - "expected_vers": "vers:conan1/>=5.0.0|<5.1.1", + "expected_vers": "vers:conan/>=5.0.0|<5.1.1", "gitlab_scheme": "conan" }, { "test_index": 420, - "scheme": "conan1", + "scheme": "conan", "native": "<5.2.0", - "expected_vers": "vers:conan1/<5.2.0", + "expected_vers": "vers:conan/<5.2.0", "gitlab_scheme": "conan" }, { "test_index": 421, - "scheme": "conan1", + "scheme": "conan", "native": "<5.2.0", - "expected_vers": "vers:conan1/<5.2.0", + "expected_vers": "vers:conan/<5.2.0", "gitlab_scheme": "conan" }, { "test_index": 422, - "scheme": "conan1", + "scheme": "conan", "native": "<5.4.0", - "expected_vers": "vers:conan1/<5.4.0", + "expected_vers": "vers:conan/<5.4.0", "gitlab_scheme": "conan" }, { "test_index": 423, - "scheme": "conan1", + "scheme": "conan", "native": "<5.5.0", - "expected_vers": "vers:conan1/<5.5.0", + "expected_vers": "vers:conan/<5.5.0", "gitlab_scheme": "conan" }, { "test_index": 424, - "scheme": "conan1", + "scheme": "conan", "native": "=5.3.0", - "expected_vers": "vers:conan1/5.3.0", + "expected_vers": "vers:conan/5.3.0", "gitlab_scheme": "conan" }, { "test_index": 425, - "scheme": "conan1", + "scheme": "conan", "native": "<5.5.1", - "expected_vers": "vers:conan1/<5.5.1", + "expected_vers": "vers:conan/<5.5.1", "gitlab_scheme": "conan" }, { "test_index": 426, - "scheme": "conan1", + "scheme": "conan", "native": "<5.5.2", - "expected_vers": "vers:conan1/<5.5.2", + "expected_vers": "vers:conan/<5.5.2", "gitlab_scheme": "conan" }, { "test_index": 427, - "scheme": "conan1", + "scheme": "conan", "native": "<5.5.0", - "expected_vers": "vers:conan1/<5.5.0", + "expected_vers": "vers:conan/<5.5.0", "gitlab_scheme": "conan" }, { "test_index": 428, - "scheme": "conan1", + "scheme": "conan", "native": "<4.3.3", - "expected_vers": "vers:conan1/<4.3.3", + "expected_vers": "vers:conan/<4.3.3", "gitlab_scheme": "conan" } ] diff --git a/tests/test_version_range.py b/tests/test_version_range.py index 4b45fbe2..5449acb9 100644 --- a/tests/test_version_range.py +++ b/tests/test_version_range.py @@ -11,7 +11,7 @@ from univers.version_constraint import VersionConstraint from univers.version_range import RANGE_CLASS_BY_SCHEMES -from univers.version_range import Conan1VersionRange +from univers.version_range import ConanVersionRange from univers.version_range import GemVersionRange from univers.version_range import InvalidVersionRange from univers.version_range import MattermostVersionRange @@ -359,7 +359,7 @@ def test_pypi_gitlab_version_range_parse(test_case): def test_conan_gitlab_version_range_parse(test_case): if test_case["expected_vers"] is None: with pytest.raises(InvalidVersion): - Conan1VersionRange.from_native(string=test_case["native"]) + ConanVersionRange.from_native(string=test_case["native"]) return result = from_gitlab_native( gitlab_scheme=test_case["gitlab_scheme"], @@ -416,9 +416,9 @@ def test_npm_advisory_version_range_parse(test_case): def test_conan_advisory_version_range_parse(test_case): if test_case["expected_vers"] is None: with pytest.raises(InvalidVersion): - Conan1VersionRange.from_native(string=test_case["native"]) + ConanVersionRange.from_native(string=test_case["native"]) return - result = Conan1VersionRange.from_native( + result = ConanVersionRange.from_native( string=test_case["native"], ) assert str(result) == test_case["expected_vers"] From ad674bfe41ddef4715d02801514ee6702e12302a Mon Sep 17 00:00:00 2001 From: Tushar Goel Date: Wed, 1 Mar 2023 19:21:19 +0530 Subject: [PATCH 72/78] Restructure conan version and tests --- conans/test/unittests/model/version/__init__.py | 0 {conans => src/univers/conan}/errors.py | 0 {conans/model => src/univers/conan}/version.py | 0 {conans/model => src/univers/conan}/version_range.py | 0 .../test_version_bump.py => tests/test_conan_version_bump.py | 0 .../test_conan_version_comparison.py | 0 .../test_version_range.py => tests/test_conan_version_range.py | 0 7 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 conans/test/unittests/model/version/__init__.py rename {conans => src/univers/conan}/errors.py (100%) rename {conans/model => src/univers/conan}/version.py (100%) rename {conans/model => src/univers/conan}/version_range.py (100%) rename conans/test/unittests/model/version/test_version_bump.py => tests/test_conan_version_bump.py (100%) rename conans/test/unittests/model/version/test_version_comparison.py => tests/test_conan_version_comparison.py (100%) rename conans/test/unittests/model/version/test_version_range.py => tests/test_conan_version_range.py (100%) diff --git a/conans/test/unittests/model/version/__init__.py b/conans/test/unittests/model/version/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/conans/errors.py b/src/univers/conan/errors.py similarity index 100% rename from conans/errors.py rename to src/univers/conan/errors.py diff --git a/conans/model/version.py b/src/univers/conan/version.py similarity index 100% rename from conans/model/version.py rename to src/univers/conan/version.py diff --git a/conans/model/version_range.py b/src/univers/conan/version_range.py similarity index 100% rename from conans/model/version_range.py rename to src/univers/conan/version_range.py diff --git a/conans/test/unittests/model/version/test_version_bump.py b/tests/test_conan_version_bump.py similarity index 100% rename from conans/test/unittests/model/version/test_version_bump.py rename to tests/test_conan_version_bump.py diff --git a/conans/test/unittests/model/version/test_version_comparison.py b/tests/test_conan_version_comparison.py similarity index 100% rename from conans/test/unittests/model/version/test_version_comparison.py rename to tests/test_conan_version_comparison.py diff --git a/conans/test/unittests/model/version/test_version_range.py b/tests/test_conan_version_range.py similarity index 100% rename from conans/test/unittests/model/version/test_version_range.py rename to tests/test_conan_version_range.py From 308d645629515f65f9d21f6b2722b416eddbc0f6 Mon Sep 17 00:00:00 2001 From: Tushar Goel Date: Wed, 1 Mar 2023 19:30:58 +0530 Subject: [PATCH 73/78] Modify imports according to restructured code Signed-off-by: Tushar Goel --- src/univers/conan/version.py | 2 +- src/univers/conan/version_range.py | 4 ++-- tests/test_conan_version_bump.py | 2 +- tests/test_conan_version_comparison.py | 2 +- tests/test_conan_version_range.py | 6 +++--- 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/univers/conan/version.py b/src/univers/conan/version.py index 0c88069e..51a0e1be 100644 --- a/src/univers/conan/version.py +++ b/src/univers/conan/version.py @@ -1,6 +1,6 @@ from functools import total_ordering -from conans.errors import ConanException +from univers.conan.errors import ConanException @total_ordering diff --git a/src/univers/conan/version_range.py b/src/univers/conan/version_range.py index 1bdadbe7..ed04b58a 100644 --- a/src/univers/conan/version_range.py +++ b/src/univers/conan/version_range.py @@ -1,7 +1,7 @@ from collections import namedtuple -from conans.errors import ConanException -from conans.model.recipe_ref import Version +from univers.conan.errors import ConanException +from univers.conan.version import Version _Condition = namedtuple("_Condition", ["operator", "version"]) diff --git a/tests/test_conan_version_bump.py b/tests/test_conan_version_bump.py index 43b2e7cd..3a92c9b1 100644 --- a/tests/test_conan_version_bump.py +++ b/tests/test_conan_version_bump.py @@ -1,6 +1,6 @@ import pytest -from conans.model.recipe_ref import Version +from univers.conan.version import Version values = [ ['1.0.0', 0, "2.0.0"], diff --git a/tests/test_conan_version_comparison.py b/tests/test_conan_version_comparison.py index bbe2b6a2..cdc62463 100644 --- a/tests/test_conan_version_comparison.py +++ b/tests/test_conan_version_comparison.py @@ -1,6 +1,6 @@ import pytest -from conans.model.recipe_ref import Version +from univers.conan.version import Version v = [("1", "2"), ("1.0", "1.1"), diff --git a/tests/test_conan_version_range.py b/tests/test_conan_version_range.py index 1392d783..719e8a30 100644 --- a/tests/test_conan_version_range.py +++ b/tests/test_conan_version_range.py @@ -1,8 +1,8 @@ import pytest -from conans.errors import ConanException -from conans.model.recipe_ref import Version -from conans.model.version_range import VersionRange +from univers.conan.errors import ConanException +from univers.conan.version import Version +from univers.conan.version_range import VersionRange values = [ ['>1.0.0', [[['>', '1.0.0']]], ["1.0.1"], ["0.1"]], From ce76f0ecf24bf3cd04ef84d9df586463417496c2 Mon Sep 17 00:00:00 2001 From: Tushar Goel Date: Wed, 1 Mar 2023 19:32:41 +0530 Subject: [PATCH 74/78] Fix formatting errors Signed-off-by: Tushar Goel --- src/univers/conan/errors.py | 98 ++++++++++++++-------- src/univers/conan/version.py | 28 +++++-- src/univers/conan/version_range.py | 2 - tests/test_conan_version_bump.py | 10 +-- tests/test_conan_version_comparison.py | 108 +++++++++++++------------ tests/test_conan_version_range.py | 56 +++++++------ 6 files changed, 175 insertions(+), 127 deletions(-) diff --git a/src/univers/conan/errors.py b/src/univers/conan/errors.py index 31957028..21d5b380 100644 --- a/src/univers/conan/errors.py +++ b/src/univers/conan/errors.py @@ -13,7 +13,7 @@ @contextmanager def conanfile_remove_attr(conanfile, names, method): - """ remove some self.xxxx attribute from the class, so it raises an exception if used + """remove some self.xxxx attribute from the class, so it raises an exception if used within a given conanfile method """ original_class = type(conanfile) @@ -21,10 +21,11 @@ def conanfile_remove_attr(conanfile, names, method): def _prop(attr_name): def _m(_): raise ConanException(f"'self.{attr_name}' access in '{method}()' method is forbidden") + return property(_m) try: - new_class = type(original_class.__name__, (original_class, ), {}) + new_class = type(original_class.__name__, (original_class,), {}) conanfile.__class__ = new_class for name in names: setattr(new_class, name, _prop(name)) @@ -40,9 +41,12 @@ def conanfile_exception_formatter(conanfile_name, func_name): """ def _raise_conanfile_exc(e): - from conan.api.output import LEVEL_DEBUG, conan_output_level + from conan.api.output import LEVEL_DEBUG + from conan.api.output import conan_output_level + if conan_output_level <= LEVEL_DEBUG: import traceback + raise ConanExceptionInUserConanfileMethod(traceback.format_exc()) m = _format_conanfile_exception(conanfile_name, func_name, e) raise ConanExceptionInUserConanfileMethod(m) @@ -54,12 +58,17 @@ def _raise_conanfile_exc(e): msg = "{}: Invalid configuration: {}".format(str(conanfile_name), exc) raise ConanInvalidConfiguration(msg) except AttributeError as exc: - list_methods = [m for m in dir(list) if not m.startswith('__')] - if "NoneType" in str(exc) and func_name in ['layout', 'package_info'] and \ - any(method in str(exc) for method in list_methods): - raise ConanException("{}: {}. No default values are set for components. You are probably " - "trying to manipulate a component attribute in the '{}' method " - "without defining it previously".format(str(conanfile_name), exc, func_name)) + list_methods = [m for m in dir(list) if not m.startswith("__")] + if ( + "NoneType" in str(exc) + and func_name in ["layout", "package_info"] + and any(method in str(exc) for method in list_methods) + ): + raise ConanException( + "{}: {}. No default values are set for components. You are probably " + "trying to manipulate a component attribute in the '{}' method " + "without defining it previously".format(str(conanfile_name), exc, func_name) + ) else: _raise_conanfile_exc(exc) except Exception as exc: @@ -74,6 +83,7 @@ def _format_conanfile_exception(scope, method, exception): """ import sys import traceback + try: conanfile_reached = False tb = sys.exc_info()[2] @@ -91,8 +101,11 @@ def _format_conanfile_exception(scope, method, exception): msg = "%s: Error in %s() method" % (scope, method) msg += ", line %d\n\t%s" % (line, contents) else: - msg = ("while calling '%s', line %d\n\t%s" % (name, line, contents) - if line else "\n\t%s" % contents) + msg = ( + "while calling '%s', line %d\n\t%s" % (name, line, contents) + if line + else "\n\t%s" % contents + ) content_lines.append(msg) conanfile_reached = True index += 1 @@ -105,8 +118,9 @@ def _format_conanfile_exception(scope, method, exception): class ConanException(Exception): """ - Generic conans exception + Generic conans exception """ + def __init__(self, *args, **kwargs): self.info = None self.remote = kwargs.pop("remote", None) @@ -119,6 +133,7 @@ def remote_message(self): def __str__(self): from conans.util.files import exception_message_safe + msg = super(ConanException, self).__str__() if self.remote: return "{}.{}".format(exception_message_safe(msg), self.remote_message()) @@ -127,18 +142,20 @@ def __str__(self): class ConanReferenceDoesNotExistInDB(ConanException): - """ Reference does not exist in cache db """ + """Reference does not exist in cache db""" + pass class ConanReferenceAlreadyExistsInDB(ConanException): - """ Reference already exists in cache db """ + """Reference already exists in cache db""" + pass class NoRemoteAvailable(ConanException): - """ No default remote configured or the specified remote do not exists - """ + """No default remote configured or the specified remote do not exists""" + pass @@ -162,6 +179,7 @@ class ConanInvalidConfiguration(ConanExceptionInUserConanfileMethod): """ This binary, for the requested configuration and package-id cannot be built """ + pass @@ -172,35 +190,39 @@ class ConanMigrationError(ConanException): # Remote exceptions # class InternalErrorException(ConanException): """ - Generic 500 error + Generic 500 error """ + pass class RequestErrorException(ConanException): """ - Generic 400 error + Generic 400 error """ + pass class AuthenticationException(ConanException): # 401 """ - 401 error + 401 error """ + pass class ForbiddenException(ConanException): # 403 """ - 403 error + 403 error """ + pass class NotFoundException(ConanException): # 404 """ - 404 error + 404 error """ def __init__(self, *args, **kwargs): @@ -209,10 +231,12 @@ def __init__(self, *args, **kwargs): class RecipeNotFoundException(NotFoundException): - def __init__(self, ref, remote=None): from conans.model.recipe_ref import RecipeReference - assert isinstance(ref, RecipeReference), "RecipeNotFoundException requires a RecipeReference" + + assert isinstance( + ref, RecipeReference + ), "RecipeNotFoundException requires a RecipeReference" self.ref = ref super(RecipeNotFoundException, self).__init__(remote=remote) @@ -222,31 +246,35 @@ def __str__(self): class PackageNotFoundException(NotFoundException): - def __init__(self, pref, remote=None): from conans.model.package_ref import PkgReference + assert isinstance(pref, PkgReference), "PackageNotFoundException requires a PkgReference" self.pref = pref super(PackageNotFoundException, self).__init__(remote=remote) def __str__(self): - return "Binary package not found: '{}'{}".format(self.pref.repr_notime(), - self.remote_message()) + return "Binary package not found: '{}'{}".format( + self.pref.repr_notime(), self.remote_message() + ) class UserInterfaceErrorException(RequestErrorException): """ - 420 error + 420 error """ + pass -EXCEPTION_CODE_MAPPING = {InternalErrorException: 500, - RequestErrorException: 400, - AuthenticationException: 401, - ForbiddenException: 403, - NotFoundException: 404, - RecipeNotFoundException: 404, - PackageNotFoundException: 404, - UserInterfaceErrorException: 420} +EXCEPTION_CODE_MAPPING = { + InternalErrorException: 500, + RequestErrorException: 400, + AuthenticationException: 401, + ForbiddenException: 403, + NotFoundException: 404, + RecipeNotFoundException: 404, + PackageNotFoundException: 404, + UserInterfaceErrorException: 420, +} diff --git a/src/univers/conan/version.py b/src/univers/conan/version.py index 51a0e1be..0ac68a6e 100644 --- a/src/univers/conan/version.py +++ b/src/univers/conan/version.py @@ -5,9 +5,10 @@ @total_ordering class _VersionItem: - """ a single "digit" in a version, like X.Y.Z all X and Y and Z are VersionItems + """a single "digit" in a version, like X.Y.Z all X and Y and Z are VersionItems They can be int or strings """ + def __init__(self, item): try: self._v = int(item) @@ -51,6 +52,7 @@ class Version: This is NOT an implementation of semver, as users may use any pattern in their versions. It is just a helper to parse "." or "-" and compare taking into account integers when possible """ + def __init__(self, value): value = str(value) self._value = value @@ -93,7 +95,7 @@ def bump(self, index): # better not make it public yet, keep it internal items = list(self._items[:index]) try: - items.append(self._items[index]+1) + items.append(self._items[index] + 1) except TypeError: raise ConanException(f"Cannot bump '{self._value} version index {index}, not an int") items.extend([0] * (len(items) - index - 1)) @@ -166,8 +168,11 @@ def __eq__(self, other): if not isinstance(other, Version): other = Version(other) - return (self._nonzero_items, self._pre, self._build) ==\ - (other._nonzero_items, other._pre, other._build) + return (self._nonzero_items, self._pre, self._build) == ( + other._nonzero_items, + other._pre, + other._build, + ) def __hash__(self): return hash((self._nonzero_items, self._pre, self._build)) @@ -180,16 +185,23 @@ def __lt__(self, other): if self._pre: if other._pre: # both are pre-releases - return (self._nonzero_items, self._pre, self._build) < \ - (other._nonzero_items, other._pre, other._build) + return (self._nonzero_items, self._pre, self._build) < ( + other._nonzero_items, + other._pre, + other._build, + ) else: # Left hand is pre-release, right side is regular - if self._nonzero_items == other._nonzero_items: # Problem only happens if both equal + if ( + self._nonzero_items == other._nonzero_items + ): # Problem only happens if both equal return True else: return self._nonzero_items < other._nonzero_items else: if other._pre: # Left hand is regular, right side is pre-release - if self._nonzero_items == other._nonzero_items: # Problem only happens if both equal + if ( + self._nonzero_items == other._nonzero_items + ): # Problem only happens if both equal return False else: return self._nonzero_items < other._nonzero_items diff --git a/src/univers/conan/version_range.py b/src/univers/conan/version_range.py index ed04b58a..4008d7e5 100644 --- a/src/univers/conan/version_range.py +++ b/src/univers/conan/version_range.py @@ -3,12 +3,10 @@ from univers.conan.errors import ConanException from univers.conan.version import Version - _Condition = namedtuple("_Condition", ["operator", "version"]) class _ConditionSet: - def __init__(self, expression, prerelease): expressions = expression.split() self.prerelease = prerelease diff --git a/tests/test_conan_version_bump.py b/tests/test_conan_version_bump.py index 3a92c9b1..505bbda6 100644 --- a/tests/test_conan_version_bump.py +++ b/tests/test_conan_version_bump.py @@ -3,11 +3,11 @@ from univers.conan.version import Version values = [ - ['1.0.0', 0, "2.0.0"], - ['1.1.0', 0, "2.0.0"], - ['1.1.1-pre', 0, "2.0.0"], - ['1.1.1', 1, "1.2.0"], - ['1.1.1', 2, "1.1.2"], + ["1.0.0", 0, "2.0.0"], + ["1.1.0", 0, "2.0.0"], + ["1.1.1-pre", 0, "2.0.0"], + ["1.1.1", 1, "1.2.0"], + ["1.1.1", 2, "1.1.2"], ] diff --git a/tests/test_conan_version_comparison.py b/tests/test_conan_version_comparison.py index cdc62463..25ae3464 100644 --- a/tests/test_conan_version_comparison.py +++ b/tests/test_conan_version_comparison.py @@ -2,43 +2,44 @@ from univers.conan.version import Version -v = [("1", "2"), - ("1.0", "1.1"), - ("1.0.2", "1.1.0"), - ("1.3", "1.22"), - ("1.1.3", "1.1.22"), - ("1.1.1.3", "1.1.1.22"), - ("1.1.1.1.3", "1.1.1.1.22"), - # Different lengths - ("1.0", "2"), - ("1.2", "1.3.1"), - ("1.0.2", "1.1"), - # Now with letters - ("1.1.a", "1.1.b"), - ("1.1.1.abc", "1.1.1.abz"), - ("a.b.c", "b.c"), - ("1.1", "1.a"), - ("1.1", "1.1a"), - ("1.1", "1.1.a"), - ("1.1.a", "1.2"), - # Arterisk are before digits - ("1.1*", "1.20"), - ("1.1.*", "1.20"), - ("1.2.2", "1.3.*"), - ("1.2.2", "1.2.3*"), - # build is easy - ("1.1+b1", "1.1+b2"), - ("1.1", "1.1+b2"), - ("1.1+b1", "1.2"), - ("1.1+b.3", "1.1+b.22"), - # pre-release is challenging - ("1.1-pre1", "1.1-pre2"), - ("1.1-alpha.3", "1.1-alpha.22"), - ("1.1-alpha.3+b1", "1.1-alpha.3+b2"), - ("1.1-alpha.1", "1.1"), - ("1.1", "1.2-alpha1"), - ("1.1-alpha.1", "1.1.0"), # pre to the generic 1.1 is earlier than 1.1.0 - ("1.0.0-", "1.0.0-alpha1") +v = [ + ("1", "2"), + ("1.0", "1.1"), + ("1.0.2", "1.1.0"), + ("1.3", "1.22"), + ("1.1.3", "1.1.22"), + ("1.1.1.3", "1.1.1.22"), + ("1.1.1.1.3", "1.1.1.1.22"), + # Different lengths + ("1.0", "2"), + ("1.2", "1.3.1"), + ("1.0.2", "1.1"), + # Now with letters + ("1.1.a", "1.1.b"), + ("1.1.1.abc", "1.1.1.abz"), + ("a.b.c", "b.c"), + ("1.1", "1.a"), + ("1.1", "1.1a"), + ("1.1", "1.1.a"), + ("1.1.a", "1.2"), + # Arterisk are before digits + ("1.1*", "1.20"), + ("1.1.*", "1.20"), + ("1.2.2", "1.3.*"), + ("1.2.2", "1.2.3*"), + # build is easy + ("1.1+b1", "1.1+b2"), + ("1.1", "1.1+b2"), + ("1.1+b1", "1.2"), + ("1.1+b.3", "1.1+b.22"), + # pre-release is challenging + ("1.1-pre1", "1.1-pre2"), + ("1.1-alpha.3", "1.1-alpha.22"), + ("1.1-alpha.3+b1", "1.1-alpha.3+b2"), + ("1.1-alpha.1", "1.1"), + ("1.1", "1.2-alpha1"), + ("1.1-alpha.1", "1.1.0"), # pre to the generic 1.1 is earlier than 1.1.0 + ("1.0.0-", "1.0.0-alpha1"), ] @@ -64,22 +65,23 @@ def test_comparison_with_integer(): assert v1 != 14 -e = [("1", "1.0"), - ("1", "1.0.0"), - ("1.0", "1.0.0"), - ("1.0", "1.0.0.0"), - ("1-pre1", "1.0-pre1"), - ("1-pre1", "1.0.0-pre1"), - ("1.0-pre1", "1.0.0-pre1"), - ("1.0-pre1.0", "1.0.0-pre1"), - ("1-pre1+b1", "1.0-pre1+b1"), - ("1-pre1+b1", "1.0.0-pre1+b1"), - ("1.0-pre1+b1", "1.0.0-pre1+b1"), - ("1+b1", "1.0+b1"), - ("1+b1", "1.0+b1.0"), - ("1+b1", "1.0.0+b1"), - ("1.0+b1", "1.0.0+b1"), - ] +e = [ + ("1", "1.0"), + ("1", "1.0.0"), + ("1.0", "1.0.0"), + ("1.0", "1.0.0.0"), + ("1-pre1", "1.0-pre1"), + ("1-pre1", "1.0.0-pre1"), + ("1.0-pre1", "1.0.0-pre1"), + ("1.0-pre1.0", "1.0.0-pre1"), + ("1-pre1+b1", "1.0-pre1+b1"), + ("1-pre1+b1", "1.0.0-pre1+b1"), + ("1.0-pre1+b1", "1.0.0-pre1+b1"), + ("1+b1", "1.0+b1"), + ("1+b1", "1.0+b1.0"), + ("1+b1", "1.0.0+b1"), + ("1.0+b1", "1.0.0+b1"), +] @pytest.mark.parametrize("v1, v2", e) diff --git a/tests/test_conan_version_range.py b/tests/test_conan_version_range.py index 719e8a30..ecee8462 100644 --- a/tests/test_conan_version_range.py +++ b/tests/test_conan_version_range.py @@ -5,36 +5,44 @@ from univers.conan.version_range import VersionRange values = [ - ['>1.0.0', [[['>', '1.0.0']]], ["1.0.1"], ["0.1"]], - ['<2.0', [[['<', '2.0']]], ["1.0.1"], ["2.1"]], - ['>1 <2.0', [[['>', '1'], ['<', '2.0']]], ["1.5.1"], ["0.1", "2.1"]], + [">1.0.0", [[[">", "1.0.0"]]], ["1.0.1"], ["0.1"]], + ["<2.0", [[["<", "2.0"]]], ["1.0.1"], ["2.1"]], + [">1 <2.0", [[[">", "1"], ["<", "2.0"]]], ["1.5.1"], ["0.1", "2.1"]], # tilde - ['~2.5', [[['>=', '2.5'], ['<', '2.6-']]], ["2.5.0", "2.5.3"], ["2.7", "2.6.1"]], - ['~2.5.1', [[['>=', '2.5.1'], ['<', '2.6.0-']]], ["2.5.1", "2.5.3"], ["2.5", "2.6.1"]], - ['~1', [[['>=', '1'], ['<', '2-']]], ["1.3", "1.8.1"], ["0.8", "2.2"]], + ["~2.5", [[[">=", "2.5"], ["<", "2.6-"]]], ["2.5.0", "2.5.3"], ["2.7", "2.6.1"]], + ["~2.5.1", [[[">=", "2.5.1"], ["<", "2.6.0-"]]], ["2.5.1", "2.5.3"], ["2.5", "2.6.1"]], + ["~1", [[[">=", "1"], ["<", "2-"]]], ["1.3", "1.8.1"], ["0.8", "2.2"]], # caret - ['^1.2', [[['>=', '1.2'], ['<', '2.0-']]], ["1.2.1", "1.51"], ["1", "2", "2.0.1"]], - ['^1.2.3', [[['>=', '1.2.3'], ["<", '2.0.0-']]], ["1.2.3", "1.2.4"], ["2", "2.1", "2.0.1"]], - ['^0.1.2', [[['>=', '0.1.2'], ['<', '0.2.0-']]], ["0.1.3", "0.1.44"], ["1", "0.3", "0.2.1"]], + ["^1.2", [[[">=", "1.2"], ["<", "2.0-"]]], ["1.2.1", "1.51"], ["1", "2", "2.0.1"]], + ["^1.2.3", [[[">=", "1.2.3"], ["<", "2.0.0-"]]], ["1.2.3", "1.2.4"], ["2", "2.1", "2.0.1"]], + ["^0.1.2", [[[">=", "0.1.2"], ["<", "0.2.0-"]]], ["0.1.3", "0.1.44"], ["1", "0.3", "0.2.1"]], # Identity - ['1.0.0', [[["=", "1.0.0"]]], ["1.0.0"], ["2", "1.0.1"]], - ['=1.0.0', [[["=", "1.0.0"]]], ["1.0.0"], ["2", "1.0.1"]], + ["1.0.0", [[["=", "1.0.0"]]], ["1.0.0"], ["2", "1.0.1"]], + ["=1.0.0", [[["=", "1.0.0"]]], ["1.0.0"], ["2", "1.0.1"]], # Any - ['*', [[[">=", "0.0.0"]]], ["1.0", "a.b"], []], - ['', [[[">=", "0.0.0"]]], ["1.0", "a.b"], []], + ["*", [[[">=", "0.0.0"]]], ["1.0", "a.b"], []], + ["", [[[">=", "0.0.0"]]], ["1.0", "a.b"], []], # Unions - ['1.0.0 || 2.1.3', [[["=", "1.0.0"]], [["=", "2.1.3"]]], ["1.0.0", "2.1.3"], ["2", "1.0.1"]], - ['>1 <2.0 || ^3.2 ', [[['>', '1'], ['<', '2.0']], - [['>=', '3.2'], ['<', '4.0-']]], ["1.5", "3.3"], ["2.1", "0.1", "5"]], + ["1.0.0 || 2.1.3", [[["=", "1.0.0"]], [["=", "2.1.3"]]], ["1.0.0", "2.1.3"], ["2", "1.0.1"]], + [ + ">1 <2.0 || ^3.2 ", + [[[">", "1"], ["<", "2.0"]], [[">=", "3.2"], ["<", "4.0-"]]], + ["1.5", "3.3"], + ["2.1", "0.1", "5"], + ], # pre-releases - ['', [[[">=", "0.0.0"]]], ["1.0"], ["1.0-pre.1"]], - ['*, include_prerelease=True', [[[">=", "0.0.0"]]], ["1.0", "1.0-pre.1"], []], - ['*-', [[[">=", "0.0.0"]]], ["1.0", "1.0-pre.1"], []], - ['>1- <2.0', [[['>', '1'], ['<', '2.0']]], ["1.5.1-pre1"], ["2.1-pre1"]], - ['>1- <2.0 || ^3.2 ', [[['>', '1'], ['<', '2.0']], - [['>=', '3.2'], ['<', '4.0-']]], ["1.5-a1", "3.3"], ["3.3-a1"]], - ['^1.1.2-', [[['>=', '1.1.2'], ['<', '2.0.0-']]], ["1.2.3", "1.2.0-alpha1"], ["2.0.0-alpha1"]], - ['~1.1.2-', [[['>=', '1.1.2'], ['<', '1.2.0-']]], ["1.1.3", "1.1.3-alpha1"], ["1.2.0-alpha1"]], + ["", [[[">=", "0.0.0"]]], ["1.0"], ["1.0-pre.1"]], + ["*, include_prerelease=True", [[[">=", "0.0.0"]]], ["1.0", "1.0-pre.1"], []], + ["*-", [[[">=", "0.0.0"]]], ["1.0", "1.0-pre.1"], []], + [">1- <2.0", [[[">", "1"], ["<", "2.0"]]], ["1.5.1-pre1"], ["2.1-pre1"]], + [ + ">1- <2.0 || ^3.2 ", + [[[">", "1"], ["<", "2.0"]], [[">=", "3.2"], ["<", "4.0-"]]], + ["1.5-a1", "3.3"], + ["3.3-a1"], + ], + ["^1.1.2-", [[[">=", "1.1.2"], ["<", "2.0.0-"]]], ["1.2.3", "1.2.0-alpha1"], ["2.0.0-alpha1"]], + ["~1.1.2-", [[[">=", "1.1.2"], ["<", "1.2.0-"]]], ["1.1.3", "1.1.3-alpha1"], ["1.2.0-alpha1"]], ] From 2290ed2a0cc9c7e0911fbccc440679ee75d290a8 Mon Sep 17 00:00:00 2001 From: "John M. Horan" Date: Wed, 1 Mar 2023 10:02:02 -0800 Subject: [PATCH 75/78] Adjust conan code according to univers #101 Signed-off-by: John M. Horan --- src/univers/conan/version.py | 18 ++--- src/univers/conan/version_range.py | 12 ++-- src/univers/versions.py | 95 ++++++++++++++++++++++++++ tests/test_conan_version_bump.py | 4 +- tests/test_conan_version_comparison.py | 14 ++-- tests/test_conan_version_range.py | 6 +- 6 files changed, 122 insertions(+), 27 deletions(-) diff --git a/src/univers/conan/version.py b/src/univers/conan/version.py index 0ac68a6e..3dbd2dd8 100644 --- a/src/univers/conan/version.py +++ b/src/univers/conan/version.py @@ -47,7 +47,7 @@ def __lt__(self, other): @total_ordering -class Version: +class ConanVersion: """ This is NOT an implementation of semver, as users may use any pattern in their versions. It is just a helper to parse "." or "-" and compare taking into account integers when possible @@ -60,7 +60,7 @@ def __init__(self, value): items = value.rsplit("+", 1) # split for build if len(items) == 2: value, build = items - self._build = Version(build) # This is a nested version by itself + self._build = ConanVersion(build) # This is a nested version by itself else: value = items[0] self._build = None @@ -68,7 +68,7 @@ def __init__(self, value): items = value.rsplit("-", 1) # split for pre-release if len(items) == 2: value, pre = items - self._pre = Version(pre) # This is a nested version by itself + self._pre = ConanVersion(pre) # This is a nested version by itself else: value = items[0] self._pre = None @@ -101,7 +101,7 @@ def bump(self, index): items.extend([0] * (len(items) - index - 1)) v = ".".join(str(i) for i in items) # prerelease and build are dropped while bumping digits - result = Version(v) + result = ConanVersion(v) return result def upper_bound(self, index): @@ -113,7 +113,7 @@ def upper_bound(self, index): items.extend([0] * (len(items) - index - 1)) v = ".".join(str(i) for i in items) v += "-" # Exclude prereleases - result = Version(v) + result = ConanVersion(v) return result @property @@ -165,8 +165,8 @@ def __repr__(self): def __eq__(self, other): if other is None: return False - if not isinstance(other, Version): - other = Version(other) + if not isinstance(other, ConanVersion): + other = ConanVersion(other) return (self._nonzero_items, self._pre, self._build) == ( other._nonzero_items, @@ -180,8 +180,8 @@ def __hash__(self): def __lt__(self, other): if other is None: return False - if not isinstance(other, Version): - other = Version(other) + if not isinstance(other, ConanVersion): + other = ConanVersion(other) if self._pre: if other._pre: # both are pre-releases diff --git a/src/univers/conan/version_range.py b/src/univers/conan/version_range.py index 4008d7e5..0fe16748 100644 --- a/src/univers/conan/version_range.py +++ b/src/univers/conan/version_range.py @@ -1,7 +1,7 @@ from collections import namedtuple from univers.conan.errors import ConanException -from univers.conan.version import Version +from univers.conan.version import ConanVersion _Condition = namedtuple("_Condition", ["operator", "version"]) @@ -21,7 +21,7 @@ def __init__(self, expression, prerelease): @staticmethod def _parse_expression(expression): if expression == "" or expression == "*": - return [_Condition(">=", Version("0.0.0"))] + return [_Condition(">=", ConanVersion("0.0.0"))] operator = expression[0] if operator not in (">", "<", "^", "~", "="): @@ -37,11 +37,11 @@ def _parse_expression(expression): if version == "": raise ConanException(f"Error parsing version range {expression}") if operator == "~": # tilde minor - v = Version(version) + v = ConanVersion(version) index = 1 if len(v.main) > 1 else 0 return [_Condition(">=", v), _Condition("<", v.upper_bound(index))] elif operator == "^": # caret major - v = Version(version) + v = ConanVersion(version) def first_non_zero(main): for i, m in enumerate(main): @@ -52,7 +52,7 @@ def first_non_zero(main): initial_index = first_non_zero(v.main) return [_Condition(">=", v), _Condition("<", v.upper_bound(initial_index))] else: - return [_Condition(operator, Version(version))] + return [_Condition(operator, ConanVersion(version))] def valid(self, version): if version.pre: @@ -95,7 +95,7 @@ def __str__(self): return self._expression def __contains__(self, version): - assert isinstance(version, Version), type(version) + assert isinstance(version, ConanVersion), type(version) for condition_set in self.condition_sets: if condition_set.valid(version): return True diff --git a/src/univers/versions.py b/src/univers/versions.py index 7f996657..eded2892 100644 --- a/src/univers/versions.py +++ b/src/univers/versions.py @@ -18,6 +18,7 @@ from univers import maven from univers import nuget from univers import rpm +from univers.conan.version import ConanVersion as conan_version from univers.utils import remove_spaces """ @@ -139,6 +140,7 @@ def __eq__(self, other): def __lt__(self, other): if not isinstance(other, self.__class__): + print('Hello!') return NotImplemented return self.value.__lt__(other.value) @@ -650,3 +652,96 @@ def __ge__(self, other): return self.value.__ge__(other.value) # version value are of diff type, then semver one is always ahead of legacy return isinstance(self.value, SemverVersion) + +class ConanVersion(Version): + @classmethod + def build_value(cls, string): + return conan_version(string) + + # def __eq__(self, other): + # if not isinstance(other, self.__class__): + # return NotImplemented + # return conan_version.vercmp(self.value, other.value) == 0 + + def __eq__(self, other): + if other is None: + return False + if not isinstance(other, conan_version): + other = conan_version(other) + + @classmethod + def is_valid(cls, string): + try: + cls.build_value(string) + return True + except ValueError: + return False + + @property + def major(self): + return self.value and self.value.major + + @property + def minor(self): + return self.value and self.value.minor + + @property + def patch(self): + return self.value and self.value.patch + + @property + def prerelease(self): + return self.value and self.value.prerelease + + @property + def build(self): + return self.value and self.value.build + + def next_major(self): + return self.value and self.value.next_major() + + def next_minor(self): + return self.value and self.value.next_minor() + + def next_patch(self): + return self.value and self.value.next_patch() + + @property + def micro(self): + # self.value() + return self.value and self.value.micro + + @property + def pre(self): + return self.value and self.value._pre + + def __lt__(self, other): + if other is None: + return False + if not isinstance(other, conan_version): + other = conan_version(other) + + if self.value._pre: + if other._pre: # both are pre-releases + return (self.value._nonzero_items, self.value._pre, self.value._build) < ( + other._nonzero_items, + other._pre, + other._build, + ) + else: # Left hand is pre-release, right side is regular + if ( + self.value._nonzero_items == other._nonzero_items + ): # Problem only happens if both equal + return True + else: + return self.value._nonzero_items < other._nonzero_items + else: + if other._pre: # Left hand is regular, right side is pre-release + if ( + self.value._nonzero_items == other._nonzero_items + ): # Problem only happens if both equal + return False + else: + return self.value._nonzero_items < other._nonzero_items + else: # None of them is pre-release + return (self.value._nonzero_items, self.value._build) < (other._nonzero_items, other._build) diff --git a/tests/test_conan_version_bump.py b/tests/test_conan_version_bump.py index 505bbda6..1b5511b7 100644 --- a/tests/test_conan_version_bump.py +++ b/tests/test_conan_version_bump.py @@ -1,6 +1,6 @@ import pytest -from univers.conan.version import Version +from univers.conan.version import ConanVersion values = [ ["1.0.0", 0, "2.0.0"], @@ -13,6 +13,6 @@ @pytest.mark.parametrize("version, index, result", values) def test_version_bump(version, index, result): - r = Version(version) + r = ConanVersion(version) bumped = r.bump(index) assert bumped == result diff --git a/tests/test_conan_version_comparison.py b/tests/test_conan_version_comparison.py index 25ae3464..be5dcc19 100644 --- a/tests/test_conan_version_comparison.py +++ b/tests/test_conan_version_comparison.py @@ -1,6 +1,6 @@ import pytest -from univers.conan.version import Version +from univers.versions import ConanVersion v = [ ("1", "2"), @@ -45,8 +45,8 @@ @pytest.mark.parametrize("v1, v2", v) def test_comparison(v1, v2): - v1 = Version(v1) - v2 = Version(v2) + v1 = ConanVersion(v1) + v2 = ConanVersion(v2) assert v1 < v2 assert v2 > v1 assert v1 != v2 @@ -55,7 +55,7 @@ def test_comparison(v1, v2): def test_comparison_with_integer(): - v1 = Version("13.0") + v1 = ConanVersion("13.0") # Issue: https://github.com/conan-io/conan/issues/12907 assert v1 > 5 assert v1 >= 5 @@ -86,14 +86,14 @@ def test_comparison_with_integer(): @pytest.mark.parametrize("v1, v2", e) def test_equality(v1, v2): - v1 = Version(v1) - v2 = Version(v2) + v1 = ConanVersion(v1) + v2 = ConanVersion(v2) assert v1 == v2 assert not v1 != v2 def test_elem_comparison(): - v1 = Version("1.2.3b.4-pre.1.2b+build.1.1b") + v1 = ConanVersion("1.2.3b.4-pre.1.2b+build.1.1b") major = v1.major assert major < 2 assert major < "2" diff --git a/tests/test_conan_version_range.py b/tests/test_conan_version_range.py index ecee8462..de39cf88 100644 --- a/tests/test_conan_version_range.py +++ b/tests/test_conan_version_range.py @@ -1,7 +1,7 @@ import pytest from univers.conan.errors import ConanException -from univers.conan.version import Version +from univers.conan.version import ConanVersion from univers.conan.version_range import VersionRange values = [ @@ -55,10 +55,10 @@ def test_range(version_range, conditions, versions_in, versions_out): assert condition.version == expected_condition[1] for v in versions_in: - assert Version(v) in r + assert ConanVersion(v) in r for v in versions_out: - assert Version(v) not in r + assert ConanVersion(v) not in r def test_wrong_range_syntax(): From 48dc602399fc33608efe11495ac635794fa6019d Mon Sep 17 00:00:00 2001 From: Tushar Goel Date: Thu, 2 Mar 2023 22:56:59 +0530 Subject: [PATCH 76/78] Use conan 2.0 as default conan version Signed-off-by: Tushar Goel --- src/univers/conan/errors.py | 50 ++---------- src/univers/conan/version.py | 18 ++--- src/univers/conan/version_range.py | 2 +- src/univers/version_range.py | 23 +++++- src/univers/versions.py | 124 ++++++++++++++++++----------- tests/data/conan_advisory.json | 86 ++++++++++---------- tests/test_conan_version_bump.py | 2 +- tests/test_conan_version_range.py | 2 +- 8 files changed, 161 insertions(+), 146 deletions(-) diff --git a/src/univers/conan/errors.py b/src/univers/conan/errors.py index 21d5b380..dd445ceb 100644 --- a/src/univers/conan/errors.py +++ b/src/univers/conan/errors.py @@ -41,13 +41,6 @@ def conanfile_exception_formatter(conanfile_name, func_name): """ def _raise_conanfile_exc(e): - from conan.api.output import LEVEL_DEBUG - from conan.api.output import conan_output_level - - if conan_output_level <= LEVEL_DEBUG: - import traceback - - raise ConanExceptionInUserConanfileMethod(traceback.format_exc()) m = _format_conanfile_exception(conanfile_name, func_name, e) raise ConanExceptionInUserConanfileMethod(m) @@ -132,13 +125,18 @@ def remote_message(self): return "" def __str__(self): - from conans.util.files import exception_message_safe msg = super(ConanException, self).__str__() + + try: + msg = str(msg) + except Exception: + msg = repr(msg) + if self.remote: - return "{}.{}".format(exception_message_safe(msg), self.remote_message()) + return "{}.{}".format(msg, self.remote_message()) - return exception_message_safe(msg) + return msg class ConanReferenceDoesNotExistInDB(ConanException): @@ -230,36 +228,6 @@ def __init__(self, *args, **kwargs): super(NotFoundException, self).__init__(*args, **kwargs) -class RecipeNotFoundException(NotFoundException): - def __init__(self, ref, remote=None): - from conans.model.recipe_ref import RecipeReference - - assert isinstance( - ref, RecipeReference - ), "RecipeNotFoundException requires a RecipeReference" - self.ref = ref - super(RecipeNotFoundException, self).__init__(remote=remote) - - def __str__(self): - tmp = repr(self.ref) - return "Recipe not found: '{}'".format(tmp, self.remote_message()) - - -class PackageNotFoundException(NotFoundException): - def __init__(self, pref, remote=None): - from conans.model.package_ref import PkgReference - - assert isinstance(pref, PkgReference), "PackageNotFoundException requires a PkgReference" - self.pref = pref - - super(PackageNotFoundException, self).__init__(remote=remote) - - def __str__(self): - return "Binary package not found: '{}'{}".format( - self.pref.repr_notime(), self.remote_message() - ) - - class UserInterfaceErrorException(RequestErrorException): """ 420 error @@ -274,7 +242,5 @@ class UserInterfaceErrorException(RequestErrorException): AuthenticationException: 401, ForbiddenException: 403, NotFoundException: 404, - RecipeNotFoundException: 404, - PackageNotFoundException: 404, UserInterfaceErrorException: 420, } diff --git a/src/univers/conan/version.py b/src/univers/conan/version.py index 3dbd2dd8..0ac68a6e 100644 --- a/src/univers/conan/version.py +++ b/src/univers/conan/version.py @@ -47,7 +47,7 @@ def __lt__(self, other): @total_ordering -class ConanVersion: +class Version: """ This is NOT an implementation of semver, as users may use any pattern in their versions. It is just a helper to parse "." or "-" and compare taking into account integers when possible @@ -60,7 +60,7 @@ def __init__(self, value): items = value.rsplit("+", 1) # split for build if len(items) == 2: value, build = items - self._build = ConanVersion(build) # This is a nested version by itself + self._build = Version(build) # This is a nested version by itself else: value = items[0] self._build = None @@ -68,7 +68,7 @@ def __init__(self, value): items = value.rsplit("-", 1) # split for pre-release if len(items) == 2: value, pre = items - self._pre = ConanVersion(pre) # This is a nested version by itself + self._pre = Version(pre) # This is a nested version by itself else: value = items[0] self._pre = None @@ -101,7 +101,7 @@ def bump(self, index): items.extend([0] * (len(items) - index - 1)) v = ".".join(str(i) for i in items) # prerelease and build are dropped while bumping digits - result = ConanVersion(v) + result = Version(v) return result def upper_bound(self, index): @@ -113,7 +113,7 @@ def upper_bound(self, index): items.extend([0] * (len(items) - index - 1)) v = ".".join(str(i) for i in items) v += "-" # Exclude prereleases - result = ConanVersion(v) + result = Version(v) return result @property @@ -165,8 +165,8 @@ def __repr__(self): def __eq__(self, other): if other is None: return False - if not isinstance(other, ConanVersion): - other = ConanVersion(other) + if not isinstance(other, Version): + other = Version(other) return (self._nonzero_items, self._pre, self._build) == ( other._nonzero_items, @@ -180,8 +180,8 @@ def __hash__(self): def __lt__(self, other): if other is None: return False - if not isinstance(other, ConanVersion): - other = ConanVersion(other) + if not isinstance(other, Version): + other = Version(other) if self._pre: if other._pre: # both are pre-releases diff --git a/src/univers/conan/version_range.py b/src/univers/conan/version_range.py index 0fe16748..747a36fd 100644 --- a/src/univers/conan/version_range.py +++ b/src/univers/conan/version_range.py @@ -1,7 +1,7 @@ from collections import namedtuple from univers.conan.errors import ConanException -from univers.conan.version import ConanVersion +from univers.versions import ConanVersion _Condition = namedtuple("_Condition", ["operator", "version"]) diff --git a/src/univers/version_range.py b/src/univers/version_range.py index 1405ad6a..37138aae 100644 --- a/src/univers/version_range.py +++ b/src/univers/version_range.py @@ -14,6 +14,7 @@ from univers import gem from univers import maven from univers import versions +from univers.conan.version_range import VersionRange as conan_version_range from univers.utils import remove_spaces from univers.version_constraint import VersionConstraint from univers.version_constraint import contains_version @@ -377,9 +378,27 @@ def from_native(cls, string): return cls(constraints=constraints) -class ConanVersionRange(NpmVersionRange): +class ConanVersionRange(VersionRange): scheme = "conan" - version_class = versions.SemverVersion + version_class = versions.ConanVersion + + @classmethod + def from_native(cls, string): + """ + Return a VersionRange built from a conan range ``string``. + """ + condition_sets = conan_version_range(string).condition_sets + constraints = [] + for conditions in condition_sets: + for condition in conditions.conditions: + comparator = condition.operator + version = condition.version + constraints.append( + VersionConstraint( + comparator=comparator, version=cls.version_class(str(version)) + ) + ) + return cls(constraints=constraints) class GemVersionRange(VersionRange): diff --git a/src/univers/versions.py b/src/univers/versions.py index eded2892..b950af06 100644 --- a/src/univers/versions.py +++ b/src/univers/versions.py @@ -18,7 +18,7 @@ from univers import maven from univers import nuget from univers import rpm -from univers.conan.version import ConanVersion as conan_version +from univers.conan.version import Version as conan_version from univers.utils import remove_spaces """ @@ -140,7 +140,6 @@ def __eq__(self, other): def __lt__(self, other): if not isinstance(other, self.__class__): - print('Hello!') return NotImplemented return self.value.__lt__(other.value) @@ -653,22 +652,14 @@ def __ge__(self, other): # version value are of diff type, then semver one is always ahead of legacy return isinstance(self.value, SemverVersion) + +@attr.s(frozen=True, order=False, eq=False, hash=True) +@total_ordering class ConanVersion(Version): @classmethod def build_value(cls, string): return conan_version(string) - # def __eq__(self, other): - # if not isinstance(other, self.__class__): - # return NotImplemented - # return conan_version.vercmp(self.value, other.value) == 0 - - def __eq__(self, other): - if other is None: - return False - if not isinstance(other, conan_version): - other = conan_version(other) - @classmethod def is_valid(cls, string): try: @@ -697,6 +688,46 @@ def prerelease(self): def build(self): return self.value and self.value.build + @property + def micro(self): + return self.value and self.value.micro + + @property + def pre(self): + return self.value and self.value._pre + + @property + def nonzero_items(self): + return self.value and self.value._nonzero_items + + @property + def main(self): + return self.value._items + + @property + def major(self): + try: + return self.value.main[0] + except IndexError: + return None + + @property + def minor(self): + try: + return self.value.main[1] + except IndexError: + return None + + @property + def patch(self): + try: + return self.value.main[2] + except IndexError: + return None + + def upper_bound(self, index): + return self.value and self.value.upper_bound(index) + def next_major(self): return self.value and self.value.next_major() @@ -706,42 +737,41 @@ def next_minor(self): def next_patch(self): return self.value and self.value.next_patch() - @property - def micro(self): - # self.value() - return self.value and self.value.micro + def bump(self, index): + return self.value and self.value.bump(index) - @property - def pre(self): - return self.value and self.value._pre + def __eq__(self, other): + if other is None: + return False + if not isinstance(other, ConanVersion): + other = ConanVersion.build_value(other) + return self.value == other + return self.value == other.value def __lt__(self, other): if other is None: return False - if not isinstance(other, conan_version): - other = conan_version(other) - - if self.value._pre: - if other._pre: # both are pre-releases - return (self.value._nonzero_items, self.value._pre, self.value._build) < ( - other._nonzero_items, - other._pre, - other._build, - ) - else: # Left hand is pre-release, right side is regular - if ( - self.value._nonzero_items == other._nonzero_items - ): # Problem only happens if both equal - return True - else: - return self.value._nonzero_items < other._nonzero_items - else: - if other._pre: # Left hand is regular, right side is pre-release - if ( - self.value._nonzero_items == other._nonzero_items - ): # Problem only happens if both equal - return False - else: - return self.value._nonzero_items < other._nonzero_items - else: # None of them is pre-release - return (self.value._nonzero_items, self.value._build) < (other._nonzero_items, other._build) + if not isinstance(other, ConanVersion): + other = ConanVersion(str(other)) + return self.value < other.value + + def __le__(self, other): + if other is None: + return False + if not isinstance(other, ConanVersion): + other = ConanVersion(str(other)) + return self.value <= other.value + + def __gt__(self, other): + if other is None: + return False + if not isinstance(other, ConanVersion): + other = ConanVersion(str(other)) + return self.value > other.value + + def __ge__(self, other): + if other is None: + return False + if not isinstance(other, ConanVersion): + other = ConanVersion(str(other)) + return self.value >= other.value diff --git a/tests/data/conan_advisory.json b/tests/data/conan_advisory.json index 4a7c42d8..007954d7 100644 --- a/tests/data/conan_advisory.json +++ b/tests/data/conan_advisory.json @@ -24,14 +24,14 @@ "test_index": 4, "scheme": "conan", "native": "=3.7", - "expected_vers": "vers:conan/3.7.0", + "expected_vers": "vers:conan/3.7", "gitlab_scheme": "conan" }, { "test_index": 5, "scheme": "conan", "native": "<0", - "expected_vers": "vers:conan/<0.0.0", + "expected_vers": "vers:conan/<0", "gitlab_scheme": "conan" }, { @@ -220,7 +220,7 @@ "test_index": 32, "scheme": "conan", "native": "<2021.07.22.00", - "expected_vers": "vers:conan/<2021.7.22+00", + "expected_vers": "vers:conan/<2021.07.22.00", "gitlab_scheme": "conan" }, { @@ -325,14 +325,14 @@ "test_index": 47, "scheme": "conan", "native": "<=3.2", - "expected_vers": "vers:conan/<=3.2.0", + "expected_vers": "vers:conan/<=3.2", "gitlab_scheme": "conan" }, { "test_index": 48, "scheme": "conan", "native": "<=3.2", - "expected_vers": "vers:conan/<=3.2.0", + "expected_vers": "vers:conan/<=3.2", "gitlab_scheme": "conan" }, { @@ -801,7 +801,7 @@ "test_index": 115, "scheme": "conan", "native": "<2021-10-15", - "expected_vers": "vers:conan/<2021.0.0-10-15", + "expected_vers": "vers:conan/<2021-10-15", "gitlab_scheme": "conan" }, { @@ -1018,7 +1018,7 @@ "test_index": 146, "scheme": "conan", "native": "<=0.14", - "expected_vers": "vers:conan/<=0.14.0", + "expected_vers": "vers:conan/<=0.14", "gitlab_scheme": "conan" }, { @@ -1137,7 +1137,7 @@ "test_index": 163, "scheme": "conan", "native": "=3.3", - "expected_vers": "vers:conan/3.3.0", + "expected_vers": "vers:conan/3.3", "gitlab_scheme": "conan" }, { @@ -1417,21 +1417,21 @@ "test_index": 203, "scheme": "conan", "native": "<9d", - "expected_vers": "vers:conan/<9.0.0-d", + "expected_vers": "vers:conan/<9d", "gitlab_scheme": "conan" }, { "test_index": 204, "scheme": "conan", "native": "<9d", - "expected_vers": "vers:conan/<9.0.0-d", + "expected_vers": "vers:conan/<9d", "gitlab_scheme": "conan" }, { "test_index": 205, "scheme": "conan", "native": "<1.64", - "expected_vers": "vers:conan/<1.64.0", + "expected_vers": "vers:conan/<1.64", "gitlab_scheme": "conan" }, { @@ -1452,14 +1452,14 @@ "test_index": 208, "scheme": "conan", "native": "<0.20", - "expected_vers": "vers:conan/<0.20.0", + "expected_vers": "vers:conan/<0.20", "gitlab_scheme": "conan" }, { "test_index": 209, "scheme": "conan", "native": "<=0.20", - "expected_vers": "vers:conan/<=0.20.0", + "expected_vers": "vers:conan/<=0.20", "gitlab_scheme": "conan" }, { @@ -2068,7 +2068,7 @@ "test_index": 296, "scheme": "conan", "native": "<6.3", - "expected_vers": "vers:conan/<6.3.0", + "expected_vers": "vers:conan/<6.3", "gitlab_scheme": "conan" }, { @@ -2439,77 +2439,77 @@ "test_index": 349, "scheme": "conan", "native": ">=1.1.1d <=1.1.1f", - "expected_vers": "vers:conan/>=1.1.1-d|<=1.1.1-f", + "expected_vers": "vers:conan/>=1.1.1d|<=1.1.1f", "gitlab_scheme": "conan" }, { "test_index": 350, "scheme": "conan", "native": ">=1.0.2 <=1.0.2v", - "expected_vers": "vers:conan/>=1.0.2|<=1.0.2", + "expected_vers": "vers:conan/<=1.0.2|>=1.0.2", "gitlab_scheme": "conan" }, { "test_index": 351, "scheme": "conan", "native": ">=1.0.2 <=1.0.2w||>=1.1.1 <=1.1.1h", - "expected_vers": "vers:conan/<=1.0.2-w|>=1.0.2|<=1.1.1-h|>=1.1.1", + "expected_vers": "vers:conan/>=1.0.2|<=1.0.2w|>=1.1.1|<=1.1.1h", "gitlab_scheme": "conan" }, { "test_index": 352, "scheme": "conan", "native": "=1.0.2s", - "expected_vers": "vers:conan/1.0.2-s", + "expected_vers": "vers:conan/1.0.2s", "gitlab_scheme": "conan" }, { "test_index": 353, "scheme": "conan", "native": ">=1.0.2 <1.0.2y||>=1.1.1 <1.1.1j", - "expected_vers": "vers:conan/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1", + "expected_vers": "vers:conan/>=1.0.2|<1.0.2y|>=1.1.1|<1.1.1j", "gitlab_scheme": "conan" }, { "test_index": 354, "scheme": "conan", "native": ">=1.0.2 <1.0.2y||>=1.1.1 <1.1.1j", - "expected_vers": "vers:conan/<1.0.2-y|>=1.0.2|<1.1.1-j|>=1.1.1", + "expected_vers": "vers:conan/>=1.0.2|<1.0.2y|>=1.1.1|<1.1.1j", "gitlab_scheme": "conan" }, { "test_index": 355, "scheme": "conan", "native": "<0", - "expected_vers": "vers:conan/<0.0.0", + "expected_vers": "vers:conan/<0", "gitlab_scheme": "conan" }, { "test_index": 356, "scheme": "conan", "native": ">=1.1.1 <1.1.1k", - "expected_vers": "vers:conan/<1.1.1-k|>=1.1.1", + "expected_vers": "vers:conan/>=1.1.1|<1.1.1k", "gitlab_scheme": "conan" }, { "test_index": 357, "scheme": "conan", "native": ">=1.1.1h <1.1.1k", - "expected_vers": "vers:conan/>=1.1.1-h|<1.1.1-k", + "expected_vers": "vers:conan/>=1.1.1h|<1.1.1k", "gitlab_scheme": "conan" }, { "test_index": 358, "scheme": "conan", "native": ">=1.1.1 <1.1.1l", - "expected_vers": "vers:conan/<1.1.1-l|>=1.1.1", + "expected_vers": "vers:conan/>=1.1.1|<1.1.1l", "gitlab_scheme": "conan" }, { "test_index": 359, "scheme": "conan", "native": ">=1.0.2 <1.0.2za||>=1.1.1 <1.1.1l", - "expected_vers": "vers:conan/<1.0.2-za|>=1.0.2|<1.1.1-l|>=1.1.1", + "expected_vers": "vers:conan/>=1.0.2|<1.0.2za|>=1.1.1|<1.1.1l", "gitlab_scheme": "conan" }, { @@ -2523,21 +2523,21 @@ "test_index": 361, "scheme": "conan", "native": ">=1.0.2 <1.1.1m||=3.0.0", - "expected_vers": "vers:conan/>=1.0.2|<1.1.1-m|3.0.0", + "expected_vers": "vers:conan/>=1.0.2|<1.1.1m|3.0.0", "gitlab_scheme": "conan" }, { "test_index": 362, "scheme": "conan", "native": ">=1.0.2 <1.0.2zd||>=1.1.0 <1.1.1n||>=3.0.0 <3.0.2", - "expected_vers": "vers:conan/<1.0.2-zd|>=1.0.2|>=1.1.0|<1.1.1-n|>=3.0.0|<3.0.2", + "expected_vers": "vers:conan/>=1.0.2|<1.0.2zd|>=1.1.0|<1.1.1n|>=3.0.0|<3.0.2", "gitlab_scheme": "conan" }, { "test_index": 363, "scheme": "conan", "native": ">=1.0.2 <1.0.2ze||>=1.1.1 <1.1.1o||>=3.0.0 <3.0.3", - "expected_vers": "vers:conan/<1.0.2-ze|>=1.0.2|<1.1.1-o|>=1.1.1|>=3.0.0|<3.0.3", + "expected_vers": "vers:conan/>=1.0.2|<1.0.2ze|>=1.1.1|<1.1.1o|>=3.0.0|<3.0.3", "gitlab_scheme": "conan" }, { @@ -2565,14 +2565,14 @@ "test_index": 367, "scheme": "conan", "native": ">=1.0.2 <1.0.2zf||>=1.1.1 <1.1.1p||>=3.0.0 <3.0.4", - "expected_vers": "vers:conan/<1.0.2-zf|>=1.0.2|<1.1.1-p|>=1.1.1|>=3.0.0|<3.0.4", + "expected_vers": "vers:conan/>=1.0.2|<1.0.2zf|>=1.1.1|<1.1.1p|>=3.0.0|<3.0.4", "gitlab_scheme": "conan" }, { "test_index": 368, "scheme": "conan", "native": ">=1.1.1 <1.1.1q||>=3.0.0 <3.0.5", - "expected_vers": "vers:conan/<1.1.1-q|>=1.1.1|>=3.0.0|<3.0.5", + "expected_vers": "vers:conan/>=1.1.1|<1.1.1q|>=3.0.0|<3.0.5", "gitlab_scheme": "conan" }, { @@ -2614,21 +2614,21 @@ "test_index": 374, "scheme": "conan", "native": "<8.44", - "expected_vers": "vers:conan/<8.44.0", + "expected_vers": "vers:conan/<8.44", "gitlab_scheme": "conan" }, { "test_index": 375, "scheme": "conan", "native": "<10.40", - "expected_vers": "vers:conan/<10.40.0", + "expected_vers": "vers:conan/<10.40", "gitlab_scheme": "conan" }, { "test_index": 376, "scheme": "conan", "native": "<10.40", - "expected_vers": "vers:conan/<10.40.0", + "expected_vers": "vers:conan/<10.40", "gitlab_scheme": "conan" }, { @@ -2649,14 +2649,14 @@ "test_index": 379, "scheme": "conan", "native": "=1.3", - "expected_vers": "vers:conan/1.3.0", + "expected_vers": "vers:conan/1.3", "gitlab_scheme": "conan" }, { "test_index": 380, "scheme": "conan", "native": "=2.2", - "expected_vers": "vers:conan/2.2.0", + "expected_vers": "vers:conan/2.2", "gitlab_scheme": "conan" }, { @@ -2670,14 +2670,14 @@ "test_index": 382, "scheme": "conan", "native": ">=4.0 <4.4.1", - "expected_vers": "vers:conan/>=4.0.0|<4.4.1", + "expected_vers": "vers:conan/>=4.0|<4.4.1", "gitlab_scheme": "conan" }, { "test_index": 383, "scheme": "conan", "native": ">=4.0 <4.4.3", - "expected_vers": "vers:conan/>=4.0.0|<4.4.3", + "expected_vers": "vers:conan/>=4.0|<4.4.3", "gitlab_scheme": "conan" }, { @@ -2691,21 +2691,21 @@ "test_index": 385, "scheme": "conan", "native": "=cci.20200203", - "expected_vers": null, + "expected_vers": "vers:conan/cci.20200203", "gitlab_scheme": "conan" }, { "test_index": 386, "scheme": "conan", "native": "=2.27", - "expected_vers": "vers:conan/2.27.0", + "expected_vers": "vers:conan/2.27", "gitlab_scheme": "conan" }, { "test_index": 387, "scheme": "conan", "native": "=2.27", - "expected_vers": "vers:conan/2.27.0", + "expected_vers": "vers:conan/2.27", "gitlab_scheme": "conan" }, { @@ -2733,14 +2733,14 @@ "test_index": 391, "scheme": "conan", "native": "<2021.02.22.00", - "expected_vers": "vers:conan/<2021.2.22+00", + "expected_vers": "vers:conan/<2021.02.22.00", "gitlab_scheme": "conan" }, { "test_index": 392, "scheme": "conan", "native": "<1.05.01", - "expected_vers": "vers:conan/<1.5.1", + "expected_vers": "vers:conan/<1.05.01", "gitlab_scheme": "conan" }, { @@ -2995,4 +2995,4 @@ "expected_vers": "vers:conan/<4.3.3", "gitlab_scheme": "conan" } -] +] \ No newline at end of file diff --git a/tests/test_conan_version_bump.py b/tests/test_conan_version_bump.py index 1b5511b7..f0647858 100644 --- a/tests/test_conan_version_bump.py +++ b/tests/test_conan_version_bump.py @@ -1,6 +1,6 @@ import pytest -from univers.conan.version import ConanVersion +from univers.versions import ConanVersion values = [ ["1.0.0", 0, "2.0.0"], diff --git a/tests/test_conan_version_range.py b/tests/test_conan_version_range.py index de39cf88..112d6e3e 100644 --- a/tests/test_conan_version_range.py +++ b/tests/test_conan_version_range.py @@ -1,8 +1,8 @@ import pytest from univers.conan.errors import ConanException -from univers.conan.version import ConanVersion from univers.conan.version_range import VersionRange +from univers.versions import ConanVersion values = [ [">1.0.0", [[[">", "1.0.0"]]], ["1.0.1"], ["0.1"]], From 1e56074798ca34f41d5d3442452c0b5029b4cd26 Mon Sep 17 00:00:00 2001 From: "John M. Horan" Date: Tue, 7 Mar 2023 18:12:15 -0800 Subject: [PATCH 77/78] Add .ABOUT, .NOTICE files #101 Reference: https://github.com/nexB/univers/issues/101 Signed-off-by: John M. Horan --- src/univers/conan/__init__.py | 0 src/univers/conan/errors.py | 6 ++++++ src/univers/conan/errors.py.ABOUT | 8 ++++++++ src/univers/conan/errors.py.NOTICE | 21 +++++++++++++++++++++ src/univers/conan/version.py | 6 ++++++ src/univers/conan/version.py.ABOUT | 8 ++++++++ src/univers/conan/version.py.NOTICE | 21 +++++++++++++++++++++ src/univers/conan/version_range.py | 6 ++++++ src/univers/conan/version_range.py.ABOUT | 8 ++++++++ src/univers/conan/version_range.py.NOTICE | 21 +++++++++++++++++++++ 10 files changed, 105 insertions(+) create mode 100644 src/univers/conan/__init__.py create mode 100644 src/univers/conan/errors.py.ABOUT create mode 100644 src/univers/conan/errors.py.NOTICE create mode 100644 src/univers/conan/version.py.ABOUT create mode 100644 src/univers/conan/version.py.NOTICE create mode 100644 src/univers/conan/version_range.py.ABOUT create mode 100644 src/univers/conan/version_range.py.NOTICE diff --git a/src/univers/conan/__init__.py b/src/univers/conan/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/univers/conan/errors.py b/src/univers/conan/errors.py index dd445ceb..bd965c13 100644 --- a/src/univers/conan/errors.py +++ b/src/univers/conan/errors.py @@ -1,3 +1,9 @@ +# +# Copyright (c) 2019 JFrog LTD +# SPDX-License-Identifier: MIT +# +# Visit https://aboutcode.org and https://github.com/nexB/univers for support and download. + """ Exceptions raised and handled in Conan These exceptions are mapped between server (as an HTTP response) and client diff --git a/src/univers/conan/errors.py.ABOUT b/src/univers/conan/errors.py.ABOUT new file mode 100644 index 00000000..2be4aeea --- /dev/null +++ b/src/univers/conan/errors.py.ABOUT @@ -0,0 +1,8 @@ +about_resource: errors.py +package_url: pkg:pypi/conan@2.0.0 +copyright: | + Copyright (c) 2019 JFrog LTD +download_url: https://github.com/conan-io/conan/blob/release/2.0/conans/errors.py +license_expression: MIT +homepage_url: https://github.com/conan-io/conan +notice_file: errors.py.NOTICE diff --git a/src/univers/conan/errors.py.NOTICE b/src/univers/conan/errors.py.NOTICE new file mode 100644 index 00000000..bc1fdcc8 --- /dev/null +++ b/src/univers/conan/errors.py.NOTICE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2019 JFrog LTD + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/src/univers/conan/version.py b/src/univers/conan/version.py index 0ac68a6e..9bd853b9 100644 --- a/src/univers/conan/version.py +++ b/src/univers/conan/version.py @@ -1,3 +1,9 @@ +# +# Copyright (c) 2019 JFrog LTD +# SPDX-License-Identifier: MIT +# +# Visit https://aboutcode.org and https://github.com/nexB/univers for support and download. + from functools import total_ordering from univers.conan.errors import ConanException diff --git a/src/univers/conan/version.py.ABOUT b/src/univers/conan/version.py.ABOUT new file mode 100644 index 00000000..140eeef2 --- /dev/null +++ b/src/univers/conan/version.py.ABOUT @@ -0,0 +1,8 @@ +about_resource: version.py +package_url: pkg:pypi/conan@2.0.0 +copyright: | + Copyright (c) 2019 JFrog LTD +download_url: https://github.com/conan-io/conan/blob/release/2.0/conans/model/version.py +license_expression: MIT +homepage_url: https://github.com/conan-io/conan +notice_file: version.py.NOTICE diff --git a/src/univers/conan/version.py.NOTICE b/src/univers/conan/version.py.NOTICE new file mode 100644 index 00000000..bc1fdcc8 --- /dev/null +++ b/src/univers/conan/version.py.NOTICE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2019 JFrog LTD + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/src/univers/conan/version_range.py b/src/univers/conan/version_range.py index 747a36fd..7add0a8c 100644 --- a/src/univers/conan/version_range.py +++ b/src/univers/conan/version_range.py @@ -1,3 +1,9 @@ +# +# Copyright (c) 2019 JFrog LTD +# SPDX-License-Identifier: MIT +# +# Visit https://aboutcode.org and https://github.com/nexB/univers for support and download. + from collections import namedtuple from univers.conan.errors import ConanException diff --git a/src/univers/conan/version_range.py.ABOUT b/src/univers/conan/version_range.py.ABOUT new file mode 100644 index 00000000..db151f67 --- /dev/null +++ b/src/univers/conan/version_range.py.ABOUT @@ -0,0 +1,8 @@ +about_resource: version_range.py +package_url: pkg:pypi/conan@2.0.0 +copyright: | + Copyright (c) 2019 JFrog LTD +download_url: https://github.com/conan-io/conan/blob/release/2.0/conans/model/version_range.py +license_expression: MIT +homepage_url: https://github.com/conan-io/conan +notice_file: version_range.py.NOTICE diff --git a/src/univers/conan/version_range.py.NOTICE b/src/univers/conan/version_range.py.NOTICE new file mode 100644 index 00000000..bc1fdcc8 --- /dev/null +++ b/src/univers/conan/version_range.py.NOTICE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2019 JFrog LTD + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. From 01ff53e3b86e3675e2164fb22eb3b57df60ad9f9 Mon Sep 17 00:00:00 2001 From: "John M. Horan" Date: Wed, 8 Mar 2023 09:36:17 -0800 Subject: [PATCH 78/78] Add .ABOUT, .NOTICE files for Conan test files #101 Reference: https://github.com/nexB/univers/issues/101 Signed-off-by: John M. Horan --- tests/test_conan_version_bump.py | 6 ++++++ tests/test_conan_version_bump.py.ABOUT | 8 +++++++ tests/test_conan_version_bump.py.NOTICE | 21 +++++++++++++++++++ tests/test_conan_version_comparison.py | 6 ++++++ tests/test_conan_version_comparison.py.ABOUT | 8 +++++++ tests/test_conan_version_comparison.py.NOTICE | 21 +++++++++++++++++++ tests/test_conan_version_range.py | 6 ++++++ tests/test_conan_version_range.py.ABOUT | 8 +++++++ tests/test_conan_version_range.py.NOTICE | 21 +++++++++++++++++++ 9 files changed, 105 insertions(+) create mode 100644 tests/test_conan_version_bump.py.ABOUT create mode 100644 tests/test_conan_version_bump.py.NOTICE create mode 100644 tests/test_conan_version_comparison.py.ABOUT create mode 100644 tests/test_conan_version_comparison.py.NOTICE create mode 100644 tests/test_conan_version_range.py.ABOUT create mode 100644 tests/test_conan_version_range.py.NOTICE diff --git a/tests/test_conan_version_bump.py b/tests/test_conan_version_bump.py index f0647858..892cb1f5 100644 --- a/tests/test_conan_version_bump.py +++ b/tests/test_conan_version_bump.py @@ -1,3 +1,9 @@ +# +# Copyright (c) 2019 JFrog LTD +# SPDX-License-Identifier: MIT +# +# Visit https://aboutcode.org and https://github.com/nexB/univers for support and download. + import pytest from univers.versions import ConanVersion diff --git a/tests/test_conan_version_bump.py.ABOUT b/tests/test_conan_version_bump.py.ABOUT new file mode 100644 index 00000000..183ffc57 --- /dev/null +++ b/tests/test_conan_version_bump.py.ABOUT @@ -0,0 +1,8 @@ +about_resource: test_conan_version_bump.py +package_url: pkg:pypi/conan@2.0.0 +copyright: | + Copyright (c) 2019 JFrog LTD +download_url: https://github.com/conan-io/conan/tree/release/2.0/conans/test/unittests/model/version/test_conan_version_bump.py +license_expression: MIT +homepage_url: https://github.com/conan-io/conan +notice_file: test_conan_version_bump.py.NOTICE diff --git a/tests/test_conan_version_bump.py.NOTICE b/tests/test_conan_version_bump.py.NOTICE new file mode 100644 index 00000000..bc1fdcc8 --- /dev/null +++ b/tests/test_conan_version_bump.py.NOTICE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2019 JFrog LTD + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/tests/test_conan_version_comparison.py b/tests/test_conan_version_comparison.py index be5dcc19..ccbe1eab 100644 --- a/tests/test_conan_version_comparison.py +++ b/tests/test_conan_version_comparison.py @@ -1,3 +1,9 @@ +# +# Copyright (c) 2019 JFrog LTD +# SPDX-License-Identifier: MIT +# +# Visit https://aboutcode.org and https://github.com/nexB/univers for support and download. + import pytest from univers.versions import ConanVersion diff --git a/tests/test_conan_version_comparison.py.ABOUT b/tests/test_conan_version_comparison.py.ABOUT new file mode 100644 index 00000000..637da684 --- /dev/null +++ b/tests/test_conan_version_comparison.py.ABOUT @@ -0,0 +1,8 @@ +about_resource: test_conan_version_comparison.py +package_url: pkg:pypi/conan@2.0.0 +copyright: | + Copyright (c) 2019 JFrog LTD +download_url: https://github.com/conan-io/conan/tree/release/2.0/conans/test/unittests/model/version/test_conan_version_comparison.py +license_expression: MIT +homepage_url: https://github.com/conan-io/conan +notice_file: test_conan_version_comparison.py.NOTICE diff --git a/tests/test_conan_version_comparison.py.NOTICE b/tests/test_conan_version_comparison.py.NOTICE new file mode 100644 index 00000000..bc1fdcc8 --- /dev/null +++ b/tests/test_conan_version_comparison.py.NOTICE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2019 JFrog LTD + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/tests/test_conan_version_range.py b/tests/test_conan_version_range.py index 112d6e3e..5c559228 100644 --- a/tests/test_conan_version_range.py +++ b/tests/test_conan_version_range.py @@ -1,3 +1,9 @@ +# +# Copyright (c) 2019 JFrog LTD +# SPDX-License-Identifier: MIT +# +# Visit https://aboutcode.org and https://github.com/nexB/univers for support and download. + import pytest from univers.conan.errors import ConanException diff --git a/tests/test_conan_version_range.py.ABOUT b/tests/test_conan_version_range.py.ABOUT new file mode 100644 index 00000000..a6c406b4 --- /dev/null +++ b/tests/test_conan_version_range.py.ABOUT @@ -0,0 +1,8 @@ +about_resource: test_conan_version_range.py +package_url: pkg:pypi/conan@2.0.0 +copyright: | + Copyright (c) 2019 JFrog LTD +download_url: https://github.com/conan-io/conan/tree/release/2.0/conans/test/unittests/model/version/test_conan_version_range.py +license_expression: MIT +homepage_url: https://github.com/conan-io/conan +notice_file: test_conan_version_range.py.NOTICE diff --git a/tests/test_conan_version_range.py.NOTICE b/tests/test_conan_version_range.py.NOTICE new file mode 100644 index 00000000..bc1fdcc8 --- /dev/null +++ b/tests/test_conan_version_range.py.NOTICE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2019 JFrog LTD + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE.