diff options
| author | asatarin <asatarin@yandex-team.ru> | 2022-02-10 16:47:30 +0300 |
|---|---|---|
| committer | Daniil Cherednik <dcherednik@yandex-team.ru> | 2022-02-10 16:47:30 +0300 |
| commit | ca04a556317a80ac802f38457a2292185282878b (patch) | |
| tree | c0748b5dcbade83af788c0abfa89c0383d6b779c /contrib/python/PyHamcrest/src/hamcrest/library | |
| parent | 4ca29390ac54b7877174de542de47532c67453b5 (diff) | |
| download | ydb-ca04a556317a80ac802f38457a2292185282878b.tar.gz | |
Restoring authorship annotation for <asatarin@yandex-team.ru>. Commit 2 of 2.
Diffstat (limited to 'contrib/python/PyHamcrest/src/hamcrest/library')
30 files changed, 1525 insertions, 1525 deletions
diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/__init__.py b/contrib/python/PyHamcrest/src/hamcrest/library/__init__.py index 15c46401fc..a5a7963521 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/__init__.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/__init__.py @@ -1,44 +1,44 @@ -from __future__ import absolute_import -"""Library of Matcher implementations.""" - -from hamcrest.core import * -from hamcrest.library.collection import * -from hamcrest.library.integration import * -from hamcrest.library.number import * -from hamcrest.library.object import * -from hamcrest.library.text import * - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - -__all__ = [ - 'has_entry', - 'has_entries', - 'has_key', - 'has_value', - 'is_in', - 'empty', - 'has_item', - 'has_items', - 'contains_inanyorder', - 'contains', - 'only_contains', - 'match_equality', - 'matches_regexp', - 'close_to', - 'greater_than', - 'greater_than_or_equal_to', - 'less_than', - 'less_than_or_equal_to', - 'has_length', - 'has_property', - 'has_properties', - 'has_string', - 'equal_to_ignoring_case', - 'equal_to_ignoring_whitespace', - 'contains_string', - 'ends_with', - 'starts_with', - 'string_contains_in_order', -] +from __future__ import absolute_import +"""Library of Matcher implementations.""" + +from hamcrest.core import * +from hamcrest.library.collection import * +from hamcrest.library.integration import * +from hamcrest.library.number import * +from hamcrest.library.object import * +from hamcrest.library.text import * + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + +__all__ = [ + 'has_entry', + 'has_entries', + 'has_key', + 'has_value', + 'is_in', + 'empty', + 'has_item', + 'has_items', + 'contains_inanyorder', + 'contains', + 'only_contains', + 'match_equality', + 'matches_regexp', + 'close_to', + 'greater_than', + 'greater_than_or_equal_to', + 'less_than', + 'less_than_or_equal_to', + 'has_length', + 'has_property', + 'has_properties', + 'has_string', + 'equal_to_ignoring_case', + 'equal_to_ignoring_whitespace', + 'contains_string', + 'ends_with', + 'starts_with', + 'string_contains_in_order', +] diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/collection/__init__.py b/contrib/python/PyHamcrest/src/hamcrest/library/collection/__init__.py index ac72268ef4..2f89987788 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/collection/__init__.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/collection/__init__.py @@ -1,16 +1,16 @@ -"""Matchers of collections.""" -from __future__ import absolute_import -from .isdict_containing import has_entry -from .isdict_containingentries import has_entries -from .isdict_containingkey import has_key -from .isdict_containingvalue import has_value -from .isin import is_in -from .issequence_containing import has_item, has_items -from .issequence_containinginanyorder import contains_inanyorder -from .issequence_containinginorder import contains -from .issequence_onlycontaining import only_contains -from .is_empty import empty - -__author__ = "Chris Rose" -__copyright__ = "Copyright 2013 hamcrest.org" -__license__ = "BSD, see License.txt" +"""Matchers of collections.""" +from __future__ import absolute_import +from .isdict_containing import has_entry +from .isdict_containingentries import has_entries +from .isdict_containingkey import has_key +from .isdict_containingvalue import has_value +from .isin import is_in +from .issequence_containing import has_item, has_items +from .issequence_containinginanyorder import contains_inanyorder +from .issequence_containinginorder import contains +from .issequence_onlycontaining import only_contains +from .is_empty import empty + +__author__ = "Chris Rose" +__copyright__ = "Copyright 2013 hamcrest.org" +__license__ = "BSD, see License.txt" diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/collection/is_empty.py b/contrib/python/PyHamcrest/src/hamcrest/library/collection/is_empty.py index 45ac32cec1..bc99b63373 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/collection/is_empty.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/collection/is_empty.py @@ -1,35 +1,35 @@ -from hamcrest.core.base_matcher import BaseMatcher - -__author__ = "Chris Rose" -__copyright__ = "Copyright 2012 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class IsEmpty(BaseMatcher): - - def matches(self, item, mismatch_description=None): - try: - if len(item) == 0: - return True - - if mismatch_description: - mismatch_description \ - .append_text('has %d item(s)' % len(item)) - - except TypeError: - if mismatch_description: - mismatch_description \ - .append_text('does not support length') - - return False - - def describe_to(self, description): - description.append_text('an empty collection') - - -def empty(): - """ - This matcher matches any collection-like object that responds to the - __len__ method, and has a length of 0. - """ - return IsEmpty() +from hamcrest.core.base_matcher import BaseMatcher + +__author__ = "Chris Rose" +__copyright__ = "Copyright 2012 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class IsEmpty(BaseMatcher): + + def matches(self, item, mismatch_description=None): + try: + if len(item) == 0: + return True + + if mismatch_description: + mismatch_description \ + .append_text('has %d item(s)' % len(item)) + + except TypeError: + if mismatch_description: + mismatch_description \ + .append_text('does not support length') + + return False + + def describe_to(self, description): + description.append_text('an empty collection') + + +def empty(): + """ + This matcher matches any collection-like object that responds to the + __len__ method, and has a length of 0. + """ + return IsEmpty() diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containing.py b/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containing.py index f24a119cd5..95281973fb 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containing.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containing.py @@ -1,54 +1,54 @@ -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core.helpers.hasmethod import hasmethod -from hamcrest.core.helpers.wrap_matcher import wrap_matcher - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class IsDictContaining(BaseMatcher): - - def __init__(self, key_matcher, value_matcher): - self.key_matcher = key_matcher - self.value_matcher = value_matcher - - def _matches(self, dictionary): - if hasmethod(dictionary, 'items'): - for key, value in dictionary.items(): - if self.key_matcher.matches(key) and self.value_matcher.matches(value): - return True - return False - - def describe_to(self, description): - description.append_text('a dictionary containing [') \ - .append_description_of(self.key_matcher) \ - .append_text(': ') \ - .append_description_of(self.value_matcher) \ - .append_text(']') - - -def has_entry(key_match, value_match): - """Matches if dictionary contains key-value entry satisfying a given pair - of matchers. - - :param key_match: The matcher to satisfy for the key, or an expected value - for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - :param value_match: The matcher to satisfy for the value, or an expected - value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - - This matcher iterates the evaluated dictionary, searching for any key-value - entry that satisfies ``key_match`` and ``value_match``. If a matching entry - is found, ``has_entry`` is satisfied. - - Any argument that is not a matcher is implicitly wrapped in an - :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for - equality. - - Examples:: - - has_entry(equal_to('foo'), equal_to(1)) - has_entry('foo', 1) - - """ - return IsDictContaining(wrap_matcher(key_match), wrap_matcher(value_match)) +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core.helpers.hasmethod import hasmethod +from hamcrest.core.helpers.wrap_matcher import wrap_matcher + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class IsDictContaining(BaseMatcher): + + def __init__(self, key_matcher, value_matcher): + self.key_matcher = key_matcher + self.value_matcher = value_matcher + + def _matches(self, dictionary): + if hasmethod(dictionary, 'items'): + for key, value in dictionary.items(): + if self.key_matcher.matches(key) and self.value_matcher.matches(value): + return True + return False + + def describe_to(self, description): + description.append_text('a dictionary containing [') \ + .append_description_of(self.key_matcher) \ + .append_text(': ') \ + .append_description_of(self.value_matcher) \ + .append_text(']') + + +def has_entry(key_match, value_match): + """Matches if dictionary contains key-value entry satisfying a given pair + of matchers. + + :param key_match: The matcher to satisfy for the key, or an expected value + for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + :param value_match: The matcher to satisfy for the value, or an expected + value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + + This matcher iterates the evaluated dictionary, searching for any key-value + entry that satisfies ``key_match`` and ``value_match``. If a matching entry + is found, ``has_entry`` is satisfied. + + Any argument that is not a matcher is implicitly wrapped in an + :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for + equality. + + Examples:: + + has_entry(equal_to('foo'), equal_to(1)) + has_entry('foo', 1) + + """ + return IsDictContaining(wrap_matcher(key_match), wrap_matcher(value_match)) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containingentries.py b/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containingentries.py index 5e6ec9b905..eb83ade52d 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containingentries.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containingentries.py @@ -1,133 +1,133 @@ -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core.helpers.hasmethod import hasmethod -from hamcrest.core.helpers.wrap_matcher import wrap_matcher - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class IsDictContainingEntries(BaseMatcher): - - def __init__(self, value_matchers): - self.value_matchers = sorted(value_matchers.items()) - - def _not_a_dictionary(self, dictionary, mismatch_description): - if mismatch_description: - mismatch_description.append_description_of(dictionary) \ - .append_text(' is not a mapping object') - return False - - def matches(self, dictionary, mismatch_description=None): - for key, value_matcher in self.value_matchers: - - try: - if not key in dictionary: - if mismatch_description: - mismatch_description.append_text('no ') \ - .append_description_of(key) \ - .append_text(' key in ') \ - .append_description_of(dictionary) - return False - except TypeError: - return self._not_a_dictionary(dictionary, mismatch_description) - - try: - actual_value = dictionary[key] - except TypeError: - return self._not_a_dictionary(dictionary, mismatch_description) - - if not value_matcher.matches(actual_value): - if mismatch_description: - mismatch_description.append_text('value for ') \ - .append_description_of(key) \ - .append_text(' ') - value_matcher.describe_mismatch(actual_value, mismatch_description) - return False - - return True - - def describe_mismatch(self, item, mismatch_description): - self.matches(item, mismatch_description) - - def describe_keyvalue(self, index, value, description): - """Describes key-value pair at given index.""" - description.append_description_of(index) \ - .append_text(': ') \ - .append_description_of(value) - - def describe_to(self, description): - description.append_text('a dictionary containing {') - first = True - for key, value in self.value_matchers: - if not first: - description.append_text(', ') - self.describe_keyvalue(key, value, description) - first = False - description.append_text('}') - - -def has_entries(*keys_valuematchers, **kv_args): - """Matches if dictionary contains entries satisfying a dictionary of keys - and corresponding value matchers. - - :param matcher_dict: A dictionary mapping keys to associated value matchers, - or to expected values for - :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - - Note that the keys must be actual keys, not matchers. Any value argument - that is not a matcher is implicitly wrapped in an - :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for - equality. - - Examples:: - - has_entries({'foo':equal_to(1), 'bar':equal_to(2)}) - has_entries({'foo':1, 'bar':2}) - - ``has_entries`` also accepts a list of keyword arguments: - - .. function:: has_entries(keyword1=value_matcher1[, keyword2=value_matcher2[, ...]]) - - :param keyword1: A keyword to look up. - :param valueMatcher1: The matcher to satisfy for the value, or an expected - value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - - Examples:: - - has_entries(foo=equal_to(1), bar=equal_to(2)) - has_entries(foo=1, bar=2) - - Finally, ``has_entries`` also accepts a list of alternating keys and their - value matchers: - - .. function:: has_entries(key1, value_matcher1[, ...]) - - :param key1: A key (not a matcher) to look up. - :param valueMatcher1: The matcher to satisfy for the value, or an expected - value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - - Examples:: - - has_entries('foo', equal_to(1), 'bar', equal_to(2)) - has_entries('foo', 1, 'bar', 2) - - """ - if len(keys_valuematchers) == 1: - try: - base_dict = keys_valuematchers[0].copy() - for key in base_dict: - base_dict[key] = wrap_matcher(base_dict[key]) - except AttributeError: - raise ValueError('single-argument calls to has_entries must pass a dict as the argument') - else: - if len(keys_valuematchers) % 2: - raise ValueError('has_entries requires key-value pairs') - base_dict = {} - for index in range(int(len(keys_valuematchers) / 2)): - base_dict[keys_valuematchers[2 * index]] = wrap_matcher(keys_valuematchers[2 * index + 1]) - - for key, value in kv_args.items(): - base_dict[key] = wrap_matcher(value) - - return IsDictContainingEntries(base_dict) +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core.helpers.hasmethod import hasmethod +from hamcrest.core.helpers.wrap_matcher import wrap_matcher + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class IsDictContainingEntries(BaseMatcher): + + def __init__(self, value_matchers): + self.value_matchers = sorted(value_matchers.items()) + + def _not_a_dictionary(self, dictionary, mismatch_description): + if mismatch_description: + mismatch_description.append_description_of(dictionary) \ + .append_text(' is not a mapping object') + return False + + def matches(self, dictionary, mismatch_description=None): + for key, value_matcher in self.value_matchers: + + try: + if not key in dictionary: + if mismatch_description: + mismatch_description.append_text('no ') \ + .append_description_of(key) \ + .append_text(' key in ') \ + .append_description_of(dictionary) + return False + except TypeError: + return self._not_a_dictionary(dictionary, mismatch_description) + + try: + actual_value = dictionary[key] + except TypeError: + return self._not_a_dictionary(dictionary, mismatch_description) + + if not value_matcher.matches(actual_value): + if mismatch_description: + mismatch_description.append_text('value for ') \ + .append_description_of(key) \ + .append_text(' ') + value_matcher.describe_mismatch(actual_value, mismatch_description) + return False + + return True + + def describe_mismatch(self, item, mismatch_description): + self.matches(item, mismatch_description) + + def describe_keyvalue(self, index, value, description): + """Describes key-value pair at given index.""" + description.append_description_of(index) \ + .append_text(': ') \ + .append_description_of(value) + + def describe_to(self, description): + description.append_text('a dictionary containing {') + first = True + for key, value in self.value_matchers: + if not first: + description.append_text(', ') + self.describe_keyvalue(key, value, description) + first = False + description.append_text('}') + + +def has_entries(*keys_valuematchers, **kv_args): + """Matches if dictionary contains entries satisfying a dictionary of keys + and corresponding value matchers. + + :param matcher_dict: A dictionary mapping keys to associated value matchers, + or to expected values for + :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + + Note that the keys must be actual keys, not matchers. Any value argument + that is not a matcher is implicitly wrapped in an + :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for + equality. + + Examples:: + + has_entries({'foo':equal_to(1), 'bar':equal_to(2)}) + has_entries({'foo':1, 'bar':2}) + + ``has_entries`` also accepts a list of keyword arguments: + + .. function:: has_entries(keyword1=value_matcher1[, keyword2=value_matcher2[, ...]]) + + :param keyword1: A keyword to look up. + :param valueMatcher1: The matcher to satisfy for the value, or an expected + value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + + Examples:: + + has_entries(foo=equal_to(1), bar=equal_to(2)) + has_entries(foo=1, bar=2) + + Finally, ``has_entries`` also accepts a list of alternating keys and their + value matchers: + + .. function:: has_entries(key1, value_matcher1[, ...]) + + :param key1: A key (not a matcher) to look up. + :param valueMatcher1: The matcher to satisfy for the value, or an expected + value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + + Examples:: + + has_entries('foo', equal_to(1), 'bar', equal_to(2)) + has_entries('foo', 1, 'bar', 2) + + """ + if len(keys_valuematchers) == 1: + try: + base_dict = keys_valuematchers[0].copy() + for key in base_dict: + base_dict[key] = wrap_matcher(base_dict[key]) + except AttributeError: + raise ValueError('single-argument calls to has_entries must pass a dict as the argument') + else: + if len(keys_valuematchers) % 2: + raise ValueError('has_entries requires key-value pairs') + base_dict = {} + for index in range(int(len(keys_valuematchers) / 2)): + base_dict[keys_valuematchers[2 * index]] = wrap_matcher(keys_valuematchers[2 * index + 1]) + + for key, value in kv_args.items(): + base_dict[key] = wrap_matcher(value) + + return IsDictContainingEntries(base_dict) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containingkey.py b/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containingkey.py index 6d5cca4389..ccb51e6396 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containingkey.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containingkey.py @@ -1,48 +1,48 @@ -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core.helpers.hasmethod import hasmethod -from hamcrest.core.helpers.wrap_matcher import wrap_matcher - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class IsDictContainingKey(BaseMatcher): - - def __init__(self, key_matcher): - self.key_matcher = key_matcher - - def _matches(self, dictionary): - if hasmethod(dictionary, 'keys'): - for key in dictionary.keys(): - if self.key_matcher.matches(key): - return True - return False - - def describe_to(self, description): - description.append_text('a dictionary containing key ') \ - .append_description_of(self.key_matcher) - - -def has_key(key_match): - """Matches if dictionary contains an entry whose key satisfies a given - matcher. - - :param key_match: The matcher to satisfy for the key, or an expected value - for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - - This matcher iterates the evaluated dictionary, searching for any key-value - entry whose key satisfies the given matcher. If a matching entry is found, - ``has_key`` is satisfied. - - Any argument that is not a matcher is implicitly wrapped in an - :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for - equality. - - Examples:: - - has_key(equal_to('foo')) - has_key('foo') - - """ - return IsDictContainingKey(wrap_matcher(key_match)) +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core.helpers.hasmethod import hasmethod +from hamcrest.core.helpers.wrap_matcher import wrap_matcher + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class IsDictContainingKey(BaseMatcher): + + def __init__(self, key_matcher): + self.key_matcher = key_matcher + + def _matches(self, dictionary): + if hasmethod(dictionary, 'keys'): + for key in dictionary.keys(): + if self.key_matcher.matches(key): + return True + return False + + def describe_to(self, description): + description.append_text('a dictionary containing key ') \ + .append_description_of(self.key_matcher) + + +def has_key(key_match): + """Matches if dictionary contains an entry whose key satisfies a given + matcher. + + :param key_match: The matcher to satisfy for the key, or an expected value + for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + + This matcher iterates the evaluated dictionary, searching for any key-value + entry whose key satisfies the given matcher. If a matching entry is found, + ``has_key`` is satisfied. + + Any argument that is not a matcher is implicitly wrapped in an + :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for + equality. + + Examples:: + + has_key(equal_to('foo')) + has_key('foo') + + """ + return IsDictContainingKey(wrap_matcher(key_match)) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containingvalue.py b/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containingvalue.py index cd0441d2eb..e5288841b2 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containingvalue.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/collection/isdict_containingvalue.py @@ -1,48 +1,48 @@ -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core.helpers.hasmethod import hasmethod -from hamcrest.core.helpers.wrap_matcher import wrap_matcher - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class IsDictContainingValue(BaseMatcher): - - def __init__(self, value_matcher): - self.value_matcher = value_matcher - - def _matches(self, dictionary): - if hasmethod(dictionary, 'values'): - for value in dictionary.values(): - if self.value_matcher.matches(value): - return True - return False - - def describe_to(self, description): - description.append_text('a dictionary containing value ') \ - .append_description_of(self.value_matcher) - - -def has_value(value): - """Matches if dictionary contains an entry whose value satisfies a given - matcher. - - :param value_match: The matcher to satisfy for the value, or an expected - value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - - This matcher iterates the evaluated dictionary, searching for any key-value - entry whose value satisfies the given matcher. If a matching entry is - found, ``has_value`` is satisfied. - - Any argument that is not a matcher is implicitly wrapped in an - :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for - equality. - - Examples:: - - has_value(equal_to('bar')) - has_value('bar') - - """ - return IsDictContainingValue(wrap_matcher(value)) +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core.helpers.hasmethod import hasmethod +from hamcrest.core.helpers.wrap_matcher import wrap_matcher + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class IsDictContainingValue(BaseMatcher): + + def __init__(self, value_matcher): + self.value_matcher = value_matcher + + def _matches(self, dictionary): + if hasmethod(dictionary, 'values'): + for value in dictionary.values(): + if self.value_matcher.matches(value): + return True + return False + + def describe_to(self, description): + description.append_text('a dictionary containing value ') \ + .append_description_of(self.value_matcher) + + +def has_value(value): + """Matches if dictionary contains an entry whose value satisfies a given + matcher. + + :param value_match: The matcher to satisfy for the value, or an expected + value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + + This matcher iterates the evaluated dictionary, searching for any key-value + entry whose value satisfies the given matcher. If a matching entry is + found, ``has_value`` is satisfied. + + Any argument that is not a matcher is implicitly wrapped in an + :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for + equality. + + Examples:: + + has_value(equal_to('bar')) + has_value('bar') + + """ + return IsDictContainingValue(wrap_matcher(value)) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/collection/isin.py b/contrib/python/PyHamcrest/src/hamcrest/library/collection/isin.py index 438ac9b144..87962a2474 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/collection/isin.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/collection/isin.py @@ -1,30 +1,30 @@ -from hamcrest.core.base_matcher import BaseMatcher - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class IsIn(BaseMatcher): - - def __init__(self, sequence): - self.sequence = sequence - - def _matches(self, item): - return item in self.sequence - - def describe_to(self, description): - description.append_text('one of ') \ - .append_list('(', ', ', ')', self.sequence) - - -def is_in(sequence): - """Matches if evaluated object is present in a given sequence. - - :param sequence: The sequence to search. - - This matcher invokes the ``in`` membership operator to determine if the - evaluated object is a member of the sequence. - - """ - return IsIn(sequence) +from hamcrest.core.base_matcher import BaseMatcher + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class IsIn(BaseMatcher): + + def __init__(self, sequence): + self.sequence = sequence + + def _matches(self, item): + return item in self.sequence + + def describe_to(self, description): + description.append_text('one of ') \ + .append_list('(', ', ', ')', self.sequence) + + +def is_in(sequence): + """Matches if evaluated object is present in a given sequence. + + :param sequence: The sequence to search. + + This matcher invokes the ``in`` membership operator to determine if the + evaluated object is a member of the sequence. + + """ + return IsIn(sequence) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_containing.py b/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_containing.py index dfd6d6b173..21939b3f3f 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_containing.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_containing.py @@ -1,89 +1,89 @@ -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core.core.allof import all_of -from hamcrest.core.helpers.hasmethod import hasmethod -from hamcrest.core.helpers.wrap_matcher import wrap_matcher - - -class IsSequenceContaining(BaseMatcher): - - def __init__(self, element_matcher): - self.element_matcher = element_matcher - - def _matches(self, sequence): - try: - for item in sequence: - if self.element_matcher.matches(item): - return True - except TypeError: # not a sequence - return False - - def describe_to(self, description): - description.append_text('a sequence containing ') \ - .append_description_of(self.element_matcher) - - -# It'd be great to make use of all_of, but we can't be sure we won't -# be seeing a one-time sequence here (like a generator); see issue #20 -# Instead, we wrap it inside a class that will convert the sequence into -# a concrete list and then hand it off to the all_of matcher. -class IsSequenceContainingEvery(BaseMatcher): - - def __init__(self, *element_matchers): - delegates = [has_item(e) for e in element_matchers] - self.matcher = all_of(*delegates) - - def _matches(self, sequence): - try: - return self.matcher.matches(list(sequence)) - except TypeError: - return False - - def describe_mismatch(self, item, mismatch_description): - self.matcher.describe_mismatch(item, mismatch_description) - - def describe_to(self, description): - self.matcher.describe_to(description) - - - -def has_item(match): - """Matches if any element of sequence satisfies a given matcher. - - :param match: The matcher to satisfy, or an expected value for - :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - - This matcher iterates the evaluated sequence, searching for any element - that satisfies a given matcher. If a matching element is found, - ``has_item`` is satisfied. - - If the ``match`` argument is not a matcher, it is implicitly wrapped in an - :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for - equality. - - """ - return IsSequenceContaining(wrap_matcher(match)) - - -def has_items(*items): - """Matches if all of the given matchers are satisfied by any elements of - the sequence. - - :param match1,...: A comma-separated list of matchers. - - This matcher iterates the given matchers, searching for any elements in the - evaluated sequence that satisfy them. If each matcher is satisfied, then - ``has_items`` is satisfied. - - Any argument that is not a matcher is implicitly wrapped in an - :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for - equality. - - """ - matchers = [] - for item in items: - matchers.append(wrap_matcher(item)) - return IsSequenceContainingEvery(*matchers) +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core.core.allof import all_of +from hamcrest.core.helpers.hasmethod import hasmethod +from hamcrest.core.helpers.wrap_matcher import wrap_matcher + + +class IsSequenceContaining(BaseMatcher): + + def __init__(self, element_matcher): + self.element_matcher = element_matcher + + def _matches(self, sequence): + try: + for item in sequence: + if self.element_matcher.matches(item): + return True + except TypeError: # not a sequence + return False + + def describe_to(self, description): + description.append_text('a sequence containing ') \ + .append_description_of(self.element_matcher) + + +# It'd be great to make use of all_of, but we can't be sure we won't +# be seeing a one-time sequence here (like a generator); see issue #20 +# Instead, we wrap it inside a class that will convert the sequence into +# a concrete list and then hand it off to the all_of matcher. +class IsSequenceContainingEvery(BaseMatcher): + + def __init__(self, *element_matchers): + delegates = [has_item(e) for e in element_matchers] + self.matcher = all_of(*delegates) + + def _matches(self, sequence): + try: + return self.matcher.matches(list(sequence)) + except TypeError: + return False + + def describe_mismatch(self, item, mismatch_description): + self.matcher.describe_mismatch(item, mismatch_description) + + def describe_to(self, description): + self.matcher.describe_to(description) + + + +def has_item(match): + """Matches if any element of sequence satisfies a given matcher. + + :param match: The matcher to satisfy, or an expected value for + :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + + This matcher iterates the evaluated sequence, searching for any element + that satisfies a given matcher. If a matching element is found, + ``has_item`` is satisfied. + + If the ``match`` argument is not a matcher, it is implicitly wrapped in an + :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for + equality. + + """ + return IsSequenceContaining(wrap_matcher(match)) + + +def has_items(*items): + """Matches if all of the given matchers are satisfied by any elements of + the sequence. + + :param match1,...: A comma-separated list of matchers. + + This matcher iterates the given matchers, searching for any elements in the + evaluated sequence that satisfy them. If each matcher is satisfied, then + ``has_items`` is satisfied. + + Any argument that is not a matcher is implicitly wrapped in an + :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for + equality. + + """ + matchers = [] + for item in items: + matchers.append(wrap_matcher(item)) + return IsSequenceContainingEvery(*matchers) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_containinginanyorder.py b/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_containinginanyorder.py index 48a0fcc607..78e2b006fc 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_containinginanyorder.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_containinginanyorder.py @@ -1,97 +1,97 @@ -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core.helpers.hasmethod import hasmethod -from hamcrest.core.helpers.wrap_matcher import wrap_matcher - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class MatchInAnyOrder(object): - def __init__(self, matchers, mismatch_description): - self.matchers = matchers[:] - self.mismatch_description = mismatch_description - - def matches(self, item): - return self.isnotsurplus(item) and self.ismatched(item) - - def isfinished(self, sequence): - if not self.matchers: - return True - if self.mismatch_description: - self.mismatch_description.append_text('no item matches: ') \ - .append_list('', ', ', '', self.matchers) \ - .append_text(' in ') \ - .append_list('[', ', ', ']', sequence) - return False - - def isnotsurplus(self, item): - if not self.matchers: - if self.mismatch_description: - self.mismatch_description.append_text('not matched: ') \ - .append_description_of(item) - return False - return True - - def ismatched(self, item): - for index, matcher in enumerate(self.matchers): - if matcher.matches(item): - del self.matchers[index] - return True - - if self.mismatch_description: - self.mismatch_description.append_text('not matched: ') \ - .append_description_of(item) - return False - - -class IsSequenceContainingInAnyOrder(BaseMatcher): - - def __init__(self, matchers): - self.matchers = matchers - - def matches(self, sequence, mismatch_description=None): - try: - sequence = list(sequence) - matchsequence = MatchInAnyOrder(self.matchers, mismatch_description) - for item in sequence: - if not matchsequence.matches(item): - return False - return matchsequence.isfinished(sequence) - except TypeError: - if mismatch_description: - super(IsSequenceContainingInAnyOrder, self) \ - .describe_mismatch(sequence, mismatch_description) - return False - - def describe_mismatch(self, item, mismatch_description): - self.matches(item, mismatch_description) - - def describe_to(self, description): - description.append_text('a sequence over ') \ - .append_list('[', ', ', ']', self.matchers) \ - .append_text(' in any order') - - -def contains_inanyorder(*items): - """Matches if sequences's elements, in any order, satisfy a given list of - matchers. - - :param match1,...: A comma-separated list of matchers. - - This matcher iterates the evaluated sequence, seeing if each element - satisfies any of the given matchers. The matchers are tried from left to - right, and when a satisfied matcher is found, it is no longer a candidate - for the remaining elements. If a one-to-one correspondence is established - between elements and matchers, ``contains_inanyorder`` is satisfied. - - Any argument that is not a matcher is implicitly wrapped in an - :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for - equality. - - """ - - matchers = [] - for item in items: - matchers.append(wrap_matcher(item)) - return IsSequenceContainingInAnyOrder(matchers) +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core.helpers.hasmethod import hasmethod +from hamcrest.core.helpers.wrap_matcher import wrap_matcher + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class MatchInAnyOrder(object): + def __init__(self, matchers, mismatch_description): + self.matchers = matchers[:] + self.mismatch_description = mismatch_description + + def matches(self, item): + return self.isnotsurplus(item) and self.ismatched(item) + + def isfinished(self, sequence): + if not self.matchers: + return True + if self.mismatch_description: + self.mismatch_description.append_text('no item matches: ') \ + .append_list('', ', ', '', self.matchers) \ + .append_text(' in ') \ + .append_list('[', ', ', ']', sequence) + return False + + def isnotsurplus(self, item): + if not self.matchers: + if self.mismatch_description: + self.mismatch_description.append_text('not matched: ') \ + .append_description_of(item) + return False + return True + + def ismatched(self, item): + for index, matcher in enumerate(self.matchers): + if matcher.matches(item): + del self.matchers[index] + return True + + if self.mismatch_description: + self.mismatch_description.append_text('not matched: ') \ + .append_description_of(item) + return False + + +class IsSequenceContainingInAnyOrder(BaseMatcher): + + def __init__(self, matchers): + self.matchers = matchers + + def matches(self, sequence, mismatch_description=None): + try: + sequence = list(sequence) + matchsequence = MatchInAnyOrder(self.matchers, mismatch_description) + for item in sequence: + if not matchsequence.matches(item): + return False + return matchsequence.isfinished(sequence) + except TypeError: + if mismatch_description: + super(IsSequenceContainingInAnyOrder, self) \ + .describe_mismatch(sequence, mismatch_description) + return False + + def describe_mismatch(self, item, mismatch_description): + self.matches(item, mismatch_description) + + def describe_to(self, description): + description.append_text('a sequence over ') \ + .append_list('[', ', ', ']', self.matchers) \ + .append_text(' in any order') + + +def contains_inanyorder(*items): + """Matches if sequences's elements, in any order, satisfy a given list of + matchers. + + :param match1,...: A comma-separated list of matchers. + + This matcher iterates the evaluated sequence, seeing if each element + satisfies any of the given matchers. The matchers are tried from left to + right, and when a satisfied matcher is found, it is no longer a candidate + for the remaining elements. If a one-to-one correspondence is established + between elements and matchers, ``contains_inanyorder`` is satisfied. + + Any argument that is not a matcher is implicitly wrapped in an + :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for + equality. + + """ + + matchers = [] + for item in items: + matchers.append(wrap_matcher(item)) + return IsSequenceContainingInAnyOrder(matchers) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_containinginorder.py b/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_containinginorder.py index 5c860eeb73..3fd91a6c92 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_containinginorder.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_containinginorder.py @@ -1,88 +1,88 @@ -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core.helpers.hasmethod import hasmethod -from hamcrest.core.helpers.wrap_matcher import wrap_matcher - - -class MatchingInOrder(object): - def __init__(self, matchers, mismatch_description): - self.matchers = matchers - self.mismatch_description = mismatch_description - self.next_match_index = 0 - - def matches(self, item): - return self.isnotsurplus(item) and self.ismatched(item) - - def isfinished(self): - if self.next_match_index < len(self.matchers): - if self.mismatch_description: - self.mismatch_description.append_text('No item matched: ') \ - .append_description_of(self.matchers[self.next_match_index]) - return False - return True - - def ismatched(self, item): - matcher = self.matchers[self.next_match_index] - if not matcher.matches(item): - if self.mismatch_description: - self.mismatch_description.append_text('item ' + str(self.next_match_index) + ': ') - matcher.describe_mismatch(item, self.mismatch_description) - return False - self.next_match_index += 1 - return True - - def isnotsurplus(self, item): - if len(self.matchers) <= self.next_match_index: - if self.mismatch_description: - self.mismatch_description.append_text('Not matched: ') \ - .append_description_of(item) - return False - return True - - -class IsSequenceContainingInOrder(BaseMatcher): - - def __init__(self, matchers): - self.matchers = matchers - - def matches(self, sequence, mismatch_description=None): - try: - matchsequence = MatchingInOrder(self.matchers, mismatch_description) - for item in sequence: - if not matchsequence.matches(item): - return False - return matchsequence.isfinished() - except TypeError: - if mismatch_description: - super(IsSequenceContainingInOrder, self) \ - .describe_mismatch(sequence, mismatch_description) - return False - - def describe_mismatch(self, item, mismatch_description): - self.matches(item, mismatch_description) - - def describe_to(self, description): - description.append_text('a sequence containing ') \ - .append_list('[', ', ', ']', self.matchers) - - -def contains(*items): - """Matches if sequence's elements satisfy a given list of matchers, in order. - - :param match1,...: A comma-separated list of matchers. - - This matcher iterates the evaluated sequence and a given list of matchers, - seeing if each element satisfies its corresponding matcher. - - Any argument that is not a matcher is implicitly wrapped in an - :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for - equality. - - """ - matchers = [] - for item in items: - matchers.append(wrap_matcher(item)) - return IsSequenceContainingInOrder(matchers) +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core.helpers.hasmethod import hasmethod +from hamcrest.core.helpers.wrap_matcher import wrap_matcher + + +class MatchingInOrder(object): + def __init__(self, matchers, mismatch_description): + self.matchers = matchers + self.mismatch_description = mismatch_description + self.next_match_index = 0 + + def matches(self, item): + return self.isnotsurplus(item) and self.ismatched(item) + + def isfinished(self): + if self.next_match_index < len(self.matchers): + if self.mismatch_description: + self.mismatch_description.append_text('No item matched: ') \ + .append_description_of(self.matchers[self.next_match_index]) + return False + return True + + def ismatched(self, item): + matcher = self.matchers[self.next_match_index] + if not matcher.matches(item): + if self.mismatch_description: + self.mismatch_description.append_text('item ' + str(self.next_match_index) + ': ') + matcher.describe_mismatch(item, self.mismatch_description) + return False + self.next_match_index += 1 + return True + + def isnotsurplus(self, item): + if len(self.matchers) <= self.next_match_index: + if self.mismatch_description: + self.mismatch_description.append_text('Not matched: ') \ + .append_description_of(item) + return False + return True + + +class IsSequenceContainingInOrder(BaseMatcher): + + def __init__(self, matchers): + self.matchers = matchers + + def matches(self, sequence, mismatch_description=None): + try: + matchsequence = MatchingInOrder(self.matchers, mismatch_description) + for item in sequence: + if not matchsequence.matches(item): + return False + return matchsequence.isfinished() + except TypeError: + if mismatch_description: + super(IsSequenceContainingInOrder, self) \ + .describe_mismatch(sequence, mismatch_description) + return False + + def describe_mismatch(self, item, mismatch_description): + self.matches(item, mismatch_description) + + def describe_to(self, description): + description.append_text('a sequence containing ') \ + .append_list('[', ', ', ']', self.matchers) + + +def contains(*items): + """Matches if sequence's elements satisfy a given list of matchers, in order. + + :param match1,...: A comma-separated list of matchers. + + This matcher iterates the evaluated sequence and a given list of matchers, + seeing if each element satisfies its corresponding matcher. + + Any argument that is not a matcher is implicitly wrapped in an + :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for + equality. + + """ + matchers = [] + for item in items: + matchers.append(wrap_matcher(item)) + return IsSequenceContainingInOrder(matchers) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_onlycontaining.py b/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_onlycontaining.py index f1e40fa8c5..bd52c10419 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_onlycontaining.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/collection/issequence_onlycontaining.py @@ -1,55 +1,55 @@ -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core.core.anyof import any_of -from hamcrest.core.helpers.hasmethod import hasmethod -from hamcrest.core.helpers.wrap_matcher import wrap_matcher - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class IsSequenceOnlyContaining(BaseMatcher): - - def __init__(self, matcher): - self.matcher = matcher - - def _matches(self, sequence): - try: - sequence = list(sequence) - if len(sequence) == 0: - return False - for item in sequence: - if not self.matcher.matches(item): - return False - return True - except TypeError: - return False - - def describe_to(self, description): - description.append_text('a sequence containing items matching ') \ - .append_description_of(self.matcher) - - -def only_contains(*items): - """Matches if each element of sequence satisfies any of the given matchers. - - :param match1,...: A comma-separated list of matchers. - - This matcher iterates the evaluated sequence, confirming whether each - element satisfies any of the given matchers. - - Example:: - - only_contains(less_than(4)) - - will match ``[3,1,2]``. - - Any argument that is not a matcher is implicitly wrapped in an - :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for - equality. - - """ - matchers = [] - for item in items: - matchers.append(wrap_matcher(item)) - return IsSequenceOnlyContaining(any_of(*matchers)) +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core.core.anyof import any_of +from hamcrest.core.helpers.hasmethod import hasmethod +from hamcrest.core.helpers.wrap_matcher import wrap_matcher + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class IsSequenceOnlyContaining(BaseMatcher): + + def __init__(self, matcher): + self.matcher = matcher + + def _matches(self, sequence): + try: + sequence = list(sequence) + if len(sequence) == 0: + return False + for item in sequence: + if not self.matcher.matches(item): + return False + return True + except TypeError: + return False + + def describe_to(self, description): + description.append_text('a sequence containing items matching ') \ + .append_description_of(self.matcher) + + +def only_contains(*items): + """Matches if each element of sequence satisfies any of the given matchers. + + :param match1,...: A comma-separated list of matchers. + + This matcher iterates the evaluated sequence, confirming whether each + element satisfies any of the given matchers. + + Example:: + + only_contains(less_than(4)) + + will match ``[3,1,2]``. + + Any argument that is not a matcher is implicitly wrapped in an + :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for + equality. + + """ + matchers = [] + for item in items: + matchers.append(wrap_matcher(item)) + return IsSequenceOnlyContaining(any_of(*matchers)) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/integration/__init__.py b/contrib/python/PyHamcrest/src/hamcrest/library/integration/__init__.py index ce39993e01..cc1e132163 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/integration/__init__.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/integration/__init__.py @@ -1,8 +1,8 @@ -from __future__ import absolute_import -"""Utilities for integrating Hamcrest with other libraries.""" - -from .match_equality import match_equality - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" +from __future__ import absolute_import +"""Utilities for integrating Hamcrest with other libraries.""" + +from .match_equality import match_equality + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/integration/match_equality.py b/contrib/python/PyHamcrest/src/hamcrest/library/integration/match_equality.py index e000dee2e2..52da054760 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/integration/match_equality.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/integration/match_equality.py @@ -1,42 +1,42 @@ -from hamcrest.core.string_description import tostring -from hamcrest.core.helpers.wrap_matcher import wrap_matcher - -__author__ = "Chris Rose" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" -__unittest = True - - -class EqualityWrapper(object): - - def __init__(self, matcher): - self.matcher = matcher - - def __eq__(self, object): - return self.matcher.matches(object) - - def __str__(self): - return repr(self) - - def __repr__(self): - return tostring(self.matcher) - - -def match_equality(matcher): - """Wraps a matcher to define equality in terms of satisfying the matcher. - - ``match_equality`` allows Hamcrest matchers to be used in libraries that - are not Hamcrest-aware. They might use the equality operator:: - - assert match_equality(matcher) == object - - Or they might provide a method that uses equality for its test:: - - library.method_that_tests_eq(match_equality(matcher)) - - One concrete example is integrating with the ``assert_called_with`` methods - in Michael Foord's `mock <http://www.voidspace.org.uk/python/mock/>`_ - library. - - """ - return EqualityWrapper(wrap_matcher(matcher)) +from hamcrest.core.string_description import tostring +from hamcrest.core.helpers.wrap_matcher import wrap_matcher + +__author__ = "Chris Rose" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" +__unittest = True + + +class EqualityWrapper(object): + + def __init__(self, matcher): + self.matcher = matcher + + def __eq__(self, object): + return self.matcher.matches(object) + + def __str__(self): + return repr(self) + + def __repr__(self): + return tostring(self.matcher) + + +def match_equality(matcher): + """Wraps a matcher to define equality in terms of satisfying the matcher. + + ``match_equality`` allows Hamcrest matchers to be used in libraries that + are not Hamcrest-aware. They might use the equality operator:: + + assert match_equality(matcher) == object + + Or they might provide a method that uses equality for its test:: + + library.method_that_tests_eq(match_equality(matcher)) + + One concrete example is integrating with the ``assert_called_with`` methods + in Michael Foord's `mock <http://www.voidspace.org.uk/python/mock/>`_ + library. + + """ + return EqualityWrapper(wrap_matcher(matcher)) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/number/__init__.py b/contrib/python/PyHamcrest/src/hamcrest/library/number/__init__.py index 9dcac13993..5087faf846 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/number/__init__.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/number/__init__.py @@ -1,9 +1,9 @@ -from __future__ import absolute_import -"""Matchers that perform numeric comparisons.""" - -from .iscloseto import close_to -from .ordering_comparison import greater_than, greater_than_or_equal_to, less_than, less_than_or_equal_to - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" +from __future__ import absolute_import +"""Matchers that perform numeric comparisons.""" + +from .iscloseto import close_to +from .ordering_comparison import greater_than, greater_than_or_equal_to, less_than, less_than_or_equal_to + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/number/iscloseto.py b/contrib/python/PyHamcrest/src/hamcrest/library/number/iscloseto.py index d1ebbf0420..e401615e35 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/number/iscloseto.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/number/iscloseto.py @@ -1,74 +1,74 @@ -import six -from hamcrest.core.base_matcher import BaseMatcher -from math import fabs - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -def isnumeric(value): - """Confirm that 'value' can be treated numerically; duck-test accordingly - """ - if isinstance(value, (float, complex) + six.integer_types): - return True - - try: - _ = (fabs(value) + 0 - 0) * 1 - return True - except ArithmeticError: - return True - except: - return False - return False - - -class IsCloseTo(BaseMatcher): - - def __init__(self, value, delta): - if not isnumeric(value): - raise TypeError('IsCloseTo value must be numeric') - if not isnumeric(delta): - raise TypeError('IsCloseTo delta must be numeric') - - self.value = value - self.delta = delta - - def _matches(self, item): - if not isnumeric(item): - return False - return fabs(item - self.value) <= self.delta - - def describe_mismatch(self, item, mismatch_description): - if not isnumeric(item): - super(IsCloseTo, self).describe_mismatch(item, mismatch_description) - else: - actual_delta = fabs(item - self.value) - mismatch_description.append_description_of(item) \ - .append_text(' differed by ') \ - .append_description_of(actual_delta) - - def describe_to(self, description): - description.append_text('a numeric value within ') \ - .append_description_of(self.delta) \ - .append_text(' of ') \ - .append_description_of(self.value) - - -def close_to(value, delta): - """Matches if object is a number close to a given value, within a given - delta. - - :param value: The value to compare against as the expected value. - :param delta: The maximum delta between the values for which the numbers - are considered close. - - This matcher compares the evaluated object against ``value`` to see if the - difference is within a positive ``delta``. - - Example:: - - close_to(3.0, 0.25) - - """ - return IsCloseTo(value, delta) +import six +from hamcrest.core.base_matcher import BaseMatcher +from math import fabs + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +def isnumeric(value): + """Confirm that 'value' can be treated numerically; duck-test accordingly + """ + if isinstance(value, (float, complex) + six.integer_types): + return True + + try: + _ = (fabs(value) + 0 - 0) * 1 + return True + except ArithmeticError: + return True + except: + return False + return False + + +class IsCloseTo(BaseMatcher): + + def __init__(self, value, delta): + if not isnumeric(value): + raise TypeError('IsCloseTo value must be numeric') + if not isnumeric(delta): + raise TypeError('IsCloseTo delta must be numeric') + + self.value = value + self.delta = delta + + def _matches(self, item): + if not isnumeric(item): + return False + return fabs(item - self.value) <= self.delta + + def describe_mismatch(self, item, mismatch_description): + if not isnumeric(item): + super(IsCloseTo, self).describe_mismatch(item, mismatch_description) + else: + actual_delta = fabs(item - self.value) + mismatch_description.append_description_of(item) \ + .append_text(' differed by ') \ + .append_description_of(actual_delta) + + def describe_to(self, description): + description.append_text('a numeric value within ') \ + .append_description_of(self.delta) \ + .append_text(' of ') \ + .append_description_of(self.value) + + +def close_to(value, delta): + """Matches if object is a number close to a given value, within a given + delta. + + :param value: The value to compare against as the expected value. + :param delta: The maximum delta between the values for which the numbers + are considered close. + + This matcher compares the evaluated object against ``value`` to see if the + difference is within a positive ``delta``. + + Example:: + + close_to(3.0, 0.25) + + """ + return IsCloseTo(value, delta) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/number/ordering_comparison.py b/contrib/python/PyHamcrest/src/hamcrest/library/number/ordering_comparison.py index 76a2eaaef7..c3c75f425d 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/number/ordering_comparison.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/number/ordering_comparison.py @@ -1,59 +1,59 @@ -from hamcrest.core.base_matcher import BaseMatcher -import operator - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class OrderingComparison(BaseMatcher): - - def __init__(self, value, comparison_function, comparison_description): - self.value = value - self.comparison_function = comparison_function - self.comparison_description = comparison_description - - def _matches(self, item): - return self.comparison_function(item, self.value) - - def describe_to(self, description): - description.append_text('a value ') \ - .append_text(self.comparison_description) \ - .append_text(' ') \ - .append_description_of(self.value) - - -def greater_than(value): - """Matches if object is greater than a given value. - - :param value: The value to compare against. - - """ - return OrderingComparison(value, operator.gt, 'greater than') - - -def greater_than_or_equal_to(value): - """Matches if object is greater than or equal to a given value. - - :param value: The value to compare against. - - """ - return OrderingComparison(value, operator.ge, 'greater than or equal to') - - -def less_than(value): - """Matches if object is less than a given value. - - :param value: The value to compare against. - - """ - return OrderingComparison(value, operator.lt, 'less than') - - -def less_than_or_equal_to(value): - """Matches if object is less than or equal to a given value. - - :param value: The value to compare against. - - """ - return OrderingComparison(value, operator.le, 'less than or equal to') +from hamcrest.core.base_matcher import BaseMatcher +import operator + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class OrderingComparison(BaseMatcher): + + def __init__(self, value, comparison_function, comparison_description): + self.value = value + self.comparison_function = comparison_function + self.comparison_description = comparison_description + + def _matches(self, item): + return self.comparison_function(item, self.value) + + def describe_to(self, description): + description.append_text('a value ') \ + .append_text(self.comparison_description) \ + .append_text(' ') \ + .append_description_of(self.value) + + +def greater_than(value): + """Matches if object is greater than a given value. + + :param value: The value to compare against. + + """ + return OrderingComparison(value, operator.gt, 'greater than') + + +def greater_than_or_equal_to(value): + """Matches if object is greater than or equal to a given value. + + :param value: The value to compare against. + + """ + return OrderingComparison(value, operator.ge, 'greater than or equal to') + + +def less_than(value): + """Matches if object is less than a given value. + + :param value: The value to compare against. + + """ + return OrderingComparison(value, operator.lt, 'less than') + + +def less_than_or_equal_to(value): + """Matches if object is less than or equal to a given value. + + :param value: The value to compare against. + + """ + return OrderingComparison(value, operator.le, 'less than or equal to') diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/object/__init__.py b/contrib/python/PyHamcrest/src/hamcrest/library/object/__init__.py index 0e58a162be..5ca4556661 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/object/__init__.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/object/__init__.py @@ -1,10 +1,10 @@ -from __future__ import absolute_import -"""Matchers that inspect objects and classes.""" - -from .haslength import has_length -from .hasproperty import has_property, has_properties -from .hasstring import has_string - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" +from __future__ import absolute_import +"""Matchers that inspect objects and classes.""" + +from .haslength import has_length +from .hasproperty import has_property, has_properties +from .hasstring import has_string + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/object/haslength.py b/contrib/python/PyHamcrest/src/hamcrest/library/object/haslength.py index 59f1481631..3ef0ab5b81 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/object/haslength.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/object/haslength.py @@ -1,50 +1,50 @@ -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core.helpers.hasmethod import hasmethod -from hamcrest.core.helpers.wrap_matcher import wrap_matcher - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class HasLength(BaseMatcher): - - def __init__(self, len_matcher): - self.len_matcher = len_matcher - - def _matches(self, item): - if not hasmethod(item, '__len__'): - return False - return self.len_matcher.matches(len(item)) - - def describe_mismatch(self, item, mismatch_description): - super(HasLength, self).describe_mismatch(item, mismatch_description) - if hasmethod(item, '__len__'): - mismatch_description.append_text(' with length of ') \ - .append_description_of(len(item)) - - def describe_to(self, description): - description.append_text('an object with length of ') \ - .append_description_of(self.len_matcher) - - -def has_length(match): - """Matches if ``len(item)`` satisfies a given matcher. - - :param match: The matcher to satisfy, or an expected value for - :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - - This matcher invokes the :py:func:`len` function on the evaluated object to - get its length, passing the result to a given matcher for evaluation. - - If the ``match`` argument is not a matcher, it is implicitly wrapped in an - :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for - :equality. - - Examples:: - - has_length(greater_than(6)) - has_length(5) - - """ - return HasLength(wrap_matcher(match)) +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core.helpers.hasmethod import hasmethod +from hamcrest.core.helpers.wrap_matcher import wrap_matcher + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class HasLength(BaseMatcher): + + def __init__(self, len_matcher): + self.len_matcher = len_matcher + + def _matches(self, item): + if not hasmethod(item, '__len__'): + return False + return self.len_matcher.matches(len(item)) + + def describe_mismatch(self, item, mismatch_description): + super(HasLength, self).describe_mismatch(item, mismatch_description) + if hasmethod(item, '__len__'): + mismatch_description.append_text(' with length of ') \ + .append_description_of(len(item)) + + def describe_to(self, description): + description.append_text('an object with length of ') \ + .append_description_of(self.len_matcher) + + +def has_length(match): + """Matches if ``len(item)`` satisfies a given matcher. + + :param match: The matcher to satisfy, or an expected value for + :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + + This matcher invokes the :py:func:`len` function on the evaluated object to + get its length, passing the result to a given matcher for evaluation. + + If the ``match`` argument is not a matcher, it is implicitly wrapped in an + :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for + :equality. + + Examples:: + + has_length(greater_than(6)) + has_length(5) + + """ + return HasLength(wrap_matcher(match)) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/object/hasproperty.py b/contrib/python/PyHamcrest/src/hamcrest/library/object/hasproperty.py index d1cf5c6492..d2536d69f4 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/object/hasproperty.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/object/hasproperty.py @@ -1,154 +1,154 @@ -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core import anything -from hamcrest.core.core.allof import all_of -from hamcrest.core.string_description import StringDescription -from hamcrest.core.helpers.hasmethod import hasmethod -from hamcrest.core.helpers.wrap_matcher import wrap_matcher as wrap_shortcut - -__author__ = "Chris Rose" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class IsObjectWithProperty(BaseMatcher): - - def __init__(self, property_name, value_matcher): - self.property_name = property_name - self.value_matcher = value_matcher - - def _matches(self, o): - if o is None: - return False - - if not hasattr(o, self.property_name): - return False - - value = getattr(o, self.property_name) - return self.value_matcher.matches(value) - - def describe_to(self, description): - description.append_text("an object with a property '") \ - .append_text(self.property_name) \ - .append_text("' matching ") \ - .append_description_of(self.value_matcher) - - def describe_mismatch(self, item, mismatch_description): - if item is None: - mismatch_description.append_text('was None') - return - - if not hasattr(item, self.property_name): - mismatch_description.append_value(item) \ - .append_text(' did not have the ') \ - .append_value(self.property_name) \ - .append_text(' property') - return - - mismatch_description.append_text('property ').append_value(self.property_name).append_text(' ') - value = getattr(item, self.property_name) - self.value_matcher.describe_mismatch(value, mismatch_description) - - def __str__(self): - d = StringDescription() - self.describe_to(d) - return str(d) - - -def has_property(name, match=None): - """Matches if object has a property with a given name whose value satisfies - a given matcher. - - :param name: The name of the property. - :param match: Optional matcher to satisfy. - - This matcher determines if the evaluated object has a property with a given - name. If no such property is found, ``has_property`` is not satisfied. - - If the property is found, its value is passed to a given matcher for - evaluation. If the ``match`` argument is not a matcher, it is implicitly - wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to - check for equality. - - If the ``match`` argument is not provided, the - :py:func:`~hamcrest.core.core.isanything.anything` matcher is used so that - ``has_property`` is satisfied if a matching property is found. - - Examples:: - - has_property('name', starts_with('J')) - has_property('name', 'Jon') - has_property('name') - - """ - - if match is None: - match = anything() - - return IsObjectWithProperty(name, wrap_shortcut(match)) - - -def has_properties(*keys_valuematchers, **kv_args): - """Matches if an object has properties satisfying all of a dictionary - of string property names and corresponding value matchers. - - :param matcher_dict: A dictionary mapping keys to associated value matchers, - or to expected values for - :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - - Note that the keys must be actual keys, not matchers. Any value argument - that is not a matcher is implicitly wrapped in an - :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for - equality. - - Examples:: - - has_properties({'foo':equal_to(1), 'bar':equal_to(2)}) - has_properties({'foo':1, 'bar':2}) - - ``has_properties`` also accepts a list of keyword arguments: - - .. function:: has_properties(keyword1=value_matcher1[, keyword2=value_matcher2[, ...]]) - - :param keyword1: A keyword to look up. - :param valueMatcher1: The matcher to satisfy for the value, or an expected - value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - - Examples:: - - has_properties(foo=equal_to(1), bar=equal_to(2)) - has_properties(foo=1, bar=2) - - Finally, ``has_properties`` also accepts a list of alternating keys and their - value matchers: - - .. function:: has_properties(key1, value_matcher1[, ...]) - - :param key1: A key (not a matcher) to look up. - :param valueMatcher1: The matcher to satisfy for the value, or an expected - value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - - Examples:: - - has_properties('foo', equal_to(1), 'bar', equal_to(2)) - has_properties('foo', 1, 'bar', 2) - - """ - if len(keys_valuematchers) == 1: - try: - base_dict = keys_valuematchers[0].copy() - for key in base_dict: - base_dict[key] = wrap_shortcut(base_dict[key]) - except AttributeError: - raise ValueError('single-argument calls to has_properties must pass a dict as the argument') - else: - if len(keys_valuematchers) % 2: - raise ValueError('has_properties requires key-value pairs') - base_dict = {} - for index in range(int(len(keys_valuematchers) / 2)): - base_dict[keys_valuematchers[2 * index]] = wrap_shortcut(keys_valuematchers[2 * index + 1]) - - for key, value in kv_args.items(): - base_dict[key] = wrap_shortcut(value) - - return all_of(*[has_property(property_name, property_value_matcher) for \ - property_name, property_value_matcher in base_dict.items()]) +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core import anything +from hamcrest.core.core.allof import all_of +from hamcrest.core.string_description import StringDescription +from hamcrest.core.helpers.hasmethod import hasmethod +from hamcrest.core.helpers.wrap_matcher import wrap_matcher as wrap_shortcut + +__author__ = "Chris Rose" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class IsObjectWithProperty(BaseMatcher): + + def __init__(self, property_name, value_matcher): + self.property_name = property_name + self.value_matcher = value_matcher + + def _matches(self, o): + if o is None: + return False + + if not hasattr(o, self.property_name): + return False + + value = getattr(o, self.property_name) + return self.value_matcher.matches(value) + + def describe_to(self, description): + description.append_text("an object with a property '") \ + .append_text(self.property_name) \ + .append_text("' matching ") \ + .append_description_of(self.value_matcher) + + def describe_mismatch(self, item, mismatch_description): + if item is None: + mismatch_description.append_text('was None') + return + + if not hasattr(item, self.property_name): + mismatch_description.append_value(item) \ + .append_text(' did not have the ') \ + .append_value(self.property_name) \ + .append_text(' property') + return + + mismatch_description.append_text('property ').append_value(self.property_name).append_text(' ') + value = getattr(item, self.property_name) + self.value_matcher.describe_mismatch(value, mismatch_description) + + def __str__(self): + d = StringDescription() + self.describe_to(d) + return str(d) + + +def has_property(name, match=None): + """Matches if object has a property with a given name whose value satisfies + a given matcher. + + :param name: The name of the property. + :param match: Optional matcher to satisfy. + + This matcher determines if the evaluated object has a property with a given + name. If no such property is found, ``has_property`` is not satisfied. + + If the property is found, its value is passed to a given matcher for + evaluation. If the ``match`` argument is not a matcher, it is implicitly + wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to + check for equality. + + If the ``match`` argument is not provided, the + :py:func:`~hamcrest.core.core.isanything.anything` matcher is used so that + ``has_property`` is satisfied if a matching property is found. + + Examples:: + + has_property('name', starts_with('J')) + has_property('name', 'Jon') + has_property('name') + + """ + + if match is None: + match = anything() + + return IsObjectWithProperty(name, wrap_shortcut(match)) + + +def has_properties(*keys_valuematchers, **kv_args): + """Matches if an object has properties satisfying all of a dictionary + of string property names and corresponding value matchers. + + :param matcher_dict: A dictionary mapping keys to associated value matchers, + or to expected values for + :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + + Note that the keys must be actual keys, not matchers. Any value argument + that is not a matcher is implicitly wrapped in an + :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for + equality. + + Examples:: + + has_properties({'foo':equal_to(1), 'bar':equal_to(2)}) + has_properties({'foo':1, 'bar':2}) + + ``has_properties`` also accepts a list of keyword arguments: + + .. function:: has_properties(keyword1=value_matcher1[, keyword2=value_matcher2[, ...]]) + + :param keyword1: A keyword to look up. + :param valueMatcher1: The matcher to satisfy for the value, or an expected + value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + + Examples:: + + has_properties(foo=equal_to(1), bar=equal_to(2)) + has_properties(foo=1, bar=2) + + Finally, ``has_properties`` also accepts a list of alternating keys and their + value matchers: + + .. function:: has_properties(key1, value_matcher1[, ...]) + + :param key1: A key (not a matcher) to look up. + :param valueMatcher1: The matcher to satisfy for the value, or an expected + value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + + Examples:: + + has_properties('foo', equal_to(1), 'bar', equal_to(2)) + has_properties('foo', 1, 'bar', 2) + + """ + if len(keys_valuematchers) == 1: + try: + base_dict = keys_valuematchers[0].copy() + for key in base_dict: + base_dict[key] = wrap_shortcut(base_dict[key]) + except AttributeError: + raise ValueError('single-argument calls to has_properties must pass a dict as the argument') + else: + if len(keys_valuematchers) % 2: + raise ValueError('has_properties requires key-value pairs') + base_dict = {} + for index in range(int(len(keys_valuematchers) / 2)): + base_dict[keys_valuematchers[2 * index]] = wrap_shortcut(keys_valuematchers[2 * index + 1]) + + for key, value in kv_args.items(): + base_dict[key] = wrap_shortcut(value) + + return all_of(*[has_property(property_name, property_value_matcher) for \ + property_name, property_value_matcher in base_dict.items()]) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/object/hasstring.py b/contrib/python/PyHamcrest/src/hamcrest/library/object/hasstring.py index e48b31f180..8b50547e21 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/object/hasstring.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/object/hasstring.py @@ -1,40 +1,40 @@ -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core.helpers.wrap_matcher import wrap_matcher - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class HasString(BaseMatcher): - - def __init__(self, str_matcher): - self.str_matcher = str_matcher - - def _matches(self, item): - return self.str_matcher.matches(str(item)) - - def describe_to(self, description): - description.append_text('an object with str ') \ - .append_description_of(self.str_matcher) - - -def has_string(match): - """Matches if ``str(item)`` satisfies a given matcher. - - :param match: The matcher to satisfy, or an expected value for - :py:func:`~hamcrest.core.core.isequal.equal_to` matching. - - This matcher invokes the :py:func:`str` function on the evaluated object to - get its length, passing the result to a given matcher for evaluation. If - the ``match`` argument is not a matcher, it is implicitly wrapped in an - :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for - equality. - - Examples:: - - has_string(starts_with('foo')) - has_string('bar') - - """ - return HasString(wrap_matcher(match)) +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core.helpers.wrap_matcher import wrap_matcher + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class HasString(BaseMatcher): + + def __init__(self, str_matcher): + self.str_matcher = str_matcher + + def _matches(self, item): + return self.str_matcher.matches(str(item)) + + def describe_to(self, description): + description.append_text('an object with str ') \ + .append_description_of(self.str_matcher) + + +def has_string(match): + """Matches if ``str(item)`` satisfies a given matcher. + + :param match: The matcher to satisfy, or an expected value for + :py:func:`~hamcrest.core.core.isequal.equal_to` matching. + + This matcher invokes the :py:func:`str` function on the evaluated object to + get its length, passing the result to a given matcher for evaluation. If + the ``match`` argument is not a matcher, it is implicitly wrapped in an + :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for + equality. + + Examples:: + + has_string(starts_with('foo')) + has_string('bar') + + """ + return HasString(wrap_matcher(match)) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/text/__init__.py b/contrib/python/PyHamcrest/src/hamcrest/library/text/__init__.py index dbdd04f24f..39d0e8b382 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/text/__init__.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/text/__init__.py @@ -1,14 +1,14 @@ -from __future__ import absolute_import -"""Matchers that perform text comparisons.""" - -from .isequal_ignoring_case import equal_to_ignoring_case -from .isequal_ignoring_whitespace import equal_to_ignoring_whitespace -from .stringcontains import contains_string -from .stringendswith import ends_with -from .stringstartswith import starts_with -from .stringmatches import matches_regexp -from .stringcontainsinorder import string_contains_in_order - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" +from __future__ import absolute_import +"""Matchers that perform text comparisons.""" + +from .isequal_ignoring_case import equal_to_ignoring_case +from .isequal_ignoring_whitespace import equal_to_ignoring_whitespace +from .stringcontains import contains_string +from .stringendswith import ends_with +from .stringstartswith import starts_with +from .stringmatches import matches_regexp +from .stringcontainsinorder import string_contains_in_order + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/text/isequal_ignoring_case.py b/contrib/python/PyHamcrest/src/hamcrest/library/text/isequal_ignoring_case.py index 114996092b..d1ee2d17fc 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/text/isequal_ignoring_case.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/text/isequal_ignoring_case.py @@ -1,43 +1,43 @@ -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - -from hamcrest.core.base_matcher import BaseMatcher - -import six - -class IsEqualIgnoringCase(BaseMatcher): - - def __init__(self, string): - if not isinstance(string, six.string_types): - raise TypeError('IsEqualIgnoringCase requires string') - self.original_string = string - self.lowered_string = string.lower() - - def _matches(self, item): - if not isinstance(item, six.string_types): - return False - return self.lowered_string == item.lower() - - def describe_to(self, description): - description.append_description_of(self.original_string) \ - .append_text(' ignoring case') - - -def equal_to_ignoring_case(string): - """Matches if object is a string equal to a given string, ignoring case - differences. - - :param string: The string to compare against as the expected value. - - This matcher first checks whether the evaluated object is a string. If so, - it compares it with ``string``, ignoring differences of case. - - Example:: - - equal_to_ignoring_case("hello world") - - will match "heLLo WorlD". - - """ - return IsEqualIgnoringCase(string) +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + +from hamcrest.core.base_matcher import BaseMatcher + +import six + +class IsEqualIgnoringCase(BaseMatcher): + + def __init__(self, string): + if not isinstance(string, six.string_types): + raise TypeError('IsEqualIgnoringCase requires string') + self.original_string = string + self.lowered_string = string.lower() + + def _matches(self, item): + if not isinstance(item, six.string_types): + return False + return self.lowered_string == item.lower() + + def describe_to(self, description): + description.append_description_of(self.original_string) \ + .append_text(' ignoring case') + + +def equal_to_ignoring_case(string): + """Matches if object is a string equal to a given string, ignoring case + differences. + + :param string: The string to compare against as the expected value. + + This matcher first checks whether the evaluated object is a string. If so, + it compares it with ``string``, ignoring differences of case. + + Example:: + + equal_to_ignoring_case("hello world") + + will match "heLLo WorlD". + + """ + return IsEqualIgnoringCase(string) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/text/isequal_ignoring_whitespace.py b/contrib/python/PyHamcrest/src/hamcrest/library/text/isequal_ignoring_whitespace.py index 3350803621..86fa997601 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/text/isequal_ignoring_whitespace.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/text/isequal_ignoring_whitespace.py @@ -1,57 +1,57 @@ -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - -from hamcrest.core.base_matcher import BaseMatcher - -import six - -def stripspace(string): - result = '' - last_was_space = True - for character in string: - if character.isspace(): - if not last_was_space: - result += ' ' - last_was_space = True - else: - result += character - last_was_space = False - return result.strip() - - -class IsEqualIgnoringWhiteSpace(BaseMatcher): - - def __init__(self, string): - if not isinstance(string, six.string_types): - raise TypeError('IsEqualIgnoringWhiteSpace requires string') - self.original_string = string - self.stripped_string = stripspace(string) - - def _matches(self, item): - if not isinstance(item, six.string_types): - return False - return self.stripped_string == stripspace(item) - - def describe_to(self, description): - description.append_description_of(self.original_string) \ - .append_text(' ignoring whitespace') - - -def equal_to_ignoring_whitespace(string): - """Matches if object is a string equal to a given string, ignoring - differences in whitespace. - - :param string: The string to compare against as the expected value. - - This matcher first checks whether the evaluated object is a string. If so, - it compares it with ``string``, ignoring differences in runs of whitespace. - - Example:: - - equal_to_ignoring_whitespace("hello world") - - will match ``"hello world"``. - - """ - return IsEqualIgnoringWhiteSpace(string) +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + +from hamcrest.core.base_matcher import BaseMatcher + +import six + +def stripspace(string): + result = '' + last_was_space = True + for character in string: + if character.isspace(): + if not last_was_space: + result += ' ' + last_was_space = True + else: + result += character + last_was_space = False + return result.strip() + + +class IsEqualIgnoringWhiteSpace(BaseMatcher): + + def __init__(self, string): + if not isinstance(string, six.string_types): + raise TypeError('IsEqualIgnoringWhiteSpace requires string') + self.original_string = string + self.stripped_string = stripspace(string) + + def _matches(self, item): + if not isinstance(item, six.string_types): + return False + return self.stripped_string == stripspace(item) + + def describe_to(self, description): + description.append_description_of(self.original_string) \ + .append_text(' ignoring whitespace') + + +def equal_to_ignoring_whitespace(string): + """Matches if object is a string equal to a given string, ignoring + differences in whitespace. + + :param string: The string to compare against as the expected value. + + This matcher first checks whether the evaluated object is a string. If so, + it compares it with ``string``, ignoring differences in runs of whitespace. + + Example:: + + equal_to_ignoring_whitespace("hello world") + + will match ``"hello world"``. + + """ + return IsEqualIgnoringWhiteSpace(string) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/text/stringcontains.py b/contrib/python/PyHamcrest/src/hamcrest/library/text/stringcontains.py index e309b5a116..58ffd283c6 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/text/stringcontains.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/text/stringcontains.py @@ -1,38 +1,38 @@ -from hamcrest.library.text.substringmatcher import SubstringMatcher -from hamcrest.core.helpers.hasmethod import hasmethod - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class StringContains(SubstringMatcher): - - def __init__(self, substring): - super(StringContains, self).__init__(substring) - - def _matches(self, item): - if not hasmethod(item, 'find'): - return False - return item.find(self.substring) >= 0 - - def relationship(self): - return 'containing' - - -def contains_string(substring): - """Matches if object is a string containing a given string. - - :param string: The string to search for. - - This matcher first checks whether the evaluated object is a string. If so, - it checks whether it contains ``string``. - - Example:: - - contains_string("def") - - will match "abcdefg". - - """ - return StringContains(substring) +from hamcrest.library.text.substringmatcher import SubstringMatcher +from hamcrest.core.helpers.hasmethod import hasmethod + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class StringContains(SubstringMatcher): + + def __init__(self, substring): + super(StringContains, self).__init__(substring) + + def _matches(self, item): + if not hasmethod(item, 'find'): + return False + return item.find(self.substring) >= 0 + + def relationship(self): + return 'containing' + + +def contains_string(substring): + """Matches if object is a string containing a given string. + + :param string: The string to search for. + + This matcher first checks whether the evaluated object is a string. If so, + it checks whether it contains ``string``. + + Example:: + + contains_string("def") + + will match "abcdefg". + + """ + return StringContains(substring) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/text/stringcontainsinorder.py b/contrib/python/PyHamcrest/src/hamcrest/library/text/stringcontainsinorder.py index 9d23193882..d5b24ffa40 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/text/stringcontainsinorder.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/text/stringcontainsinorder.py @@ -1,52 +1,52 @@ -__author__ = "Romilly Cocking" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core.helpers.hasmethod import hasmethod - -import six - -class StringContainsInOrder(BaseMatcher): - - def __init__(self, *substrings): - for substring in substrings: - if not isinstance(substring, six.string_types): - raise TypeError(self.__class__.__name__ - + ' requires string arguments') - self.substrings = substrings - - def _matches(self, item): - if not hasmethod(item, 'find'): - return False - from_index = 0 - for substring in self.substrings: - from_index = item.find(substring, from_index) - if from_index == -1: - return False - return True - - def describe_to(self, description): - description.append_list('a string containing ', ', ', ' in order', - self.substrings) - - -def string_contains_in_order(*substrings): - """Matches if object is a string containing a given list of substrings in - relative order. - - :param string1,...: A comma-separated list of strings. - - This matcher first checks whether the evaluated object is a string. If so, - it checks whether it contains a given list of strings, in relative order to - each other. The searches are performed starting from the beginning of the - evaluated string. - - Example:: - - string_contains_in_order("bc", "fg", "jkl") - - will match "abcdefghijklm". - - """ - return StringContainsInOrder(*substrings) +__author__ = "Romilly Cocking" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core.helpers.hasmethod import hasmethod + +import six + +class StringContainsInOrder(BaseMatcher): + + def __init__(self, *substrings): + for substring in substrings: + if not isinstance(substring, six.string_types): + raise TypeError(self.__class__.__name__ + + ' requires string arguments') + self.substrings = substrings + + def _matches(self, item): + if not hasmethod(item, 'find'): + return False + from_index = 0 + for substring in self.substrings: + from_index = item.find(substring, from_index) + if from_index == -1: + return False + return True + + def describe_to(self, description): + description.append_list('a string containing ', ', ', ' in order', + self.substrings) + + +def string_contains_in_order(*substrings): + """Matches if object is a string containing a given list of substrings in + relative order. + + :param string1,...: A comma-separated list of strings. + + This matcher first checks whether the evaluated object is a string. If so, + it checks whether it contains a given list of strings, in relative order to + each other. The searches are performed starting from the beginning of the + evaluated string. + + Example:: + + string_contains_in_order("bc", "fg", "jkl") + + will match "abcdefghijklm". + + """ + return StringContainsInOrder(*substrings) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/text/stringendswith.py b/contrib/python/PyHamcrest/src/hamcrest/library/text/stringendswith.py index 6ccfbb2de0..43f9c3d302 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/text/stringendswith.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/text/stringendswith.py @@ -1,39 +1,39 @@ -from hamcrest.library.text.substringmatcher import SubstringMatcher -from hamcrest.core.helpers.hasmethod import hasmethod - -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - - -class StringEndsWith(SubstringMatcher): - - def __init__(self, substring): - super(StringEndsWith, self).__init__(substring) - - def _matches(self, item): - if not hasmethod(item, 'endswith'): - return False - return item.endswith(self.substring) - - def relationship(self): - return 'ending with' - - -def ends_with(string): - """Matches if object is a string ending with a given string. - - :param string: The string to search for. - - This matcher first checks whether the evaluated object is a string. If so, - it checks if ``string`` matches the ending characters of the evaluated - object. - - Example:: - - ends_with("bar") - - will match "foobar". - - """ - return StringEndsWith(string) +from hamcrest.library.text.substringmatcher import SubstringMatcher +from hamcrest.core.helpers.hasmethod import hasmethod + +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + + +class StringEndsWith(SubstringMatcher): + + def __init__(self, substring): + super(StringEndsWith, self).__init__(substring) + + def _matches(self, item): + if not hasmethod(item, 'endswith'): + return False + return item.endswith(self.substring) + + def relationship(self): + return 'ending with' + + +def ends_with(string): + """Matches if object is a string ending with a given string. + + :param string: The string to search for. + + This matcher first checks whether the evaluated object is a string. If so, + it checks if ``string`` matches the ending characters of the evaluated + object. + + Example:: + + ends_with("bar") + + will match "foobar". + + """ + return StringEndsWith(string) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/text/stringmatches.py b/contrib/python/PyHamcrest/src/hamcrest/library/text/stringmatches.py index 0f66b9dce5..2a16e29729 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/text/stringmatches.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/text/stringmatches.py @@ -1,40 +1,40 @@ -__author__ = "Chris Rose" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - -import re - -import six - -from hamcrest.core.base_matcher import BaseMatcher -from hamcrest.core.helpers.hasmethod import hasmethod - -class StringMatchesPattern(BaseMatcher): - - def __init__(self, pattern): - self.pattern = pattern - - def describe_to(self, description): - description.append_text("a string matching '") \ - .append_text(self.pattern.pattern) \ - .append_text("'") - - def _matches(self, item): - return self.pattern.search(item) is not None - - -def matches_regexp(pattern): - """Matches if object is a string containing a match for a given regular - expression. - - :param pattern: The regular expression to search for. - - This matcher first checks whether the evaluated object is a string. If so, - it checks if the regular expression ``pattern`` matches anywhere within the - evaluated object. - - """ - if isinstance(pattern, six.string_types): - pattern = re.compile(pattern) - - return StringMatchesPattern(pattern) +__author__ = "Chris Rose" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + +import re + +import six + +from hamcrest.core.base_matcher import BaseMatcher +from hamcrest.core.helpers.hasmethod import hasmethod + +class StringMatchesPattern(BaseMatcher): + + def __init__(self, pattern): + self.pattern = pattern + + def describe_to(self, description): + description.append_text("a string matching '") \ + .append_text(self.pattern.pattern) \ + .append_text("'") + + def _matches(self, item): + return self.pattern.search(item) is not None + + +def matches_regexp(pattern): + """Matches if object is a string containing a match for a given regular + expression. + + :param pattern: The regular expression to search for. + + This matcher first checks whether the evaluated object is a string. If so, + it checks if the regular expression ``pattern`` matches anywhere within the + evaluated object. + + """ + if isinstance(pattern, six.string_types): + pattern = re.compile(pattern) + + return StringMatchesPattern(pattern) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/text/stringstartswith.py b/contrib/python/PyHamcrest/src/hamcrest/library/text/stringstartswith.py index 19a1ec4f06..a0af49c9c2 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/text/stringstartswith.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/text/stringstartswith.py @@ -1,39 +1,39 @@ -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - -from hamcrest.library.text.substringmatcher import SubstringMatcher -from hamcrest.core.helpers.hasmethod import hasmethod - - -class StringStartsWith(SubstringMatcher): - - def __init__(self, substring): - super(StringStartsWith, self).__init__(substring) - - def _matches(self, item): - if not hasmethod(item, 'startswith'): - return False - return item.startswith(self.substring) - - def relationship(self): - return 'starting with' - - -def starts_with(substring): - """Matches if object is a string starting with a given string. - - :param string: The string to search for. - - This matcher first checks whether the evaluated object is a string. If so, - it checks if ``string`` matches the beginning characters of the evaluated - object. - - Example:: - - starts_with("foo") - - will match "foobar". - - """ - return StringStartsWith(substring) +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + +from hamcrest.library.text.substringmatcher import SubstringMatcher +from hamcrest.core.helpers.hasmethod import hasmethod + + +class StringStartsWith(SubstringMatcher): + + def __init__(self, substring): + super(StringStartsWith, self).__init__(substring) + + def _matches(self, item): + if not hasmethod(item, 'startswith'): + return False + return item.startswith(self.substring) + + def relationship(self): + return 'starting with' + + +def starts_with(substring): + """Matches if object is a string starting with a given string. + + :param string: The string to search for. + + This matcher first checks whether the evaluated object is a string. If so, + it checks if ``string`` matches the beginning characters of the evaluated + object. + + Example:: + + starts_with("foo") + + will match "foobar". + + """ + return StringStartsWith(substring) diff --git a/contrib/python/PyHamcrest/src/hamcrest/library/text/substringmatcher.py b/contrib/python/PyHamcrest/src/hamcrest/library/text/substringmatcher.py index 968919aa93..63ea359a51 100644 --- a/contrib/python/PyHamcrest/src/hamcrest/library/text/substringmatcher.py +++ b/contrib/python/PyHamcrest/src/hamcrest/library/text/substringmatcher.py @@ -1,20 +1,20 @@ -__author__ = "Jon Reid" -__copyright__ = "Copyright 2011 hamcrest.org" -__license__ = "BSD, see License.txt" - -from hamcrest.core.base_matcher import BaseMatcher - -import six - -class SubstringMatcher(BaseMatcher): - - def __init__(self, substring): - if not isinstance(substring, six.string_types): - raise TypeError(self.__class__.__name__ + ' requires string') - self.substring = substring - - def describe_to(self, description): - description.append_text('a string ') \ - .append_text(self.relationship()) \ - .append_text(' ') \ - .append_description_of(self.substring) +__author__ = "Jon Reid" +__copyright__ = "Copyright 2011 hamcrest.org" +__license__ = "BSD, see License.txt" + +from hamcrest.core.base_matcher import BaseMatcher + +import six + +class SubstringMatcher(BaseMatcher): + + def __init__(self, substring): + if not isinstance(substring, six.string_types): + raise TypeError(self.__class__.__name__ + ' requires string') + self.substring = substring + + def describe_to(self, description): + description.append_text('a string ') \ + .append_text(self.relationship()) \ + .append_text(' ') \ + .append_description_of(self.substring) |