def test__natsort_key_with_float_and_unsigned_splits_input_into_string_and_unsigned_float(x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) assert ns.U == ns.UNSIGNED assert _natsort_key(s, None, ns.F | ns.U) == tuple(_number_extracter(s, _float_nosign_exp_re, *float_nosafe_nolocale_nogroup)) # Default is unsigned search assert _natsort_key(s, None, ns.F) == tuple(_number_extracter(s, _float_nosign_exp_re, *float_nosafe_nolocale_nogroup))
def test__natsort_key_with_tuple_input_returns_nested_tuples(x): # Iterables are parsed recursively so you can sort lists of lists. assume(len(x) <= 10) assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) t = tuple(_number_extracter(s, _int_nosign_re, *int_nosafe_nolocale_nogroup)) assert _natsort_key((s, s), None, ns.I) == (t, t)
def test_parse_string_function_parses_float_with_sign_exp_float(x): assume(not any(type(y) == float and isnan(y) for y in x)) assume(all(whitespace_check(y) for y in x)) s = "".join(repr(y) if type(y) in (float, long, int) else y for y in x) assert _parse_string_function(0, "", _float_sign_exp_re.split, no_op, fast_float, tuple2)(s) == float_splitter( s, True, True, "" )
def test_locale_convert_transforms_float_string_to_float_with_de_locale(x): assume(not isnan(x)) load_locale('de_DE') assert locale_convert(repr(x), (fast_float, isfloat), False) == x assert locale_convert( repr(x).replace('.', ','), (fast_float, isfloat), False) == x locale.setlocale(locale.LC_NUMERIC, str(''))
def test_post_split_function_with_LOCALE_and_GROUPLETTERS_returns_fast_int_and_groupletters_and_locale_convert(x): assume(x) try: assert _post_split_function(ns.GROUPLETTERS | ns.LOCALE)(x) == fast_int(x, key=lambda x: get_strxfrm()(_groupletters(x))) except ValueError as e: # handle broken locale lib on BSD. if 'is not in range' not in str(e): raise
def test_keep_entry_range_returns_False_if_no_portion_of_input_is_between_the_range_bounds( x): s = ''.join(map(py23_str, x)) assume( all(not (1 <= int(i) <= 20) for i in re.findall(r'\d+', s) if re.match(r'\d+$', i))) assert not keep_entry_range(s, [1], [20], int, re.compile(r'\d+'))
def test_number_extracter_doubles_letters_with_lowercase_version_with_groupletters_for_float(x): assume(len(x) <= 10) assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) t = float_splitter(s, True, True, False, '') t = [''.join([low(z) + z for z in y]) if type(y) != float else y for y in t] assert _number_extracter(s, _float_sign_exp_re, *float_nosafe_nolocale_group) == t
def test_exclude_entry_returns_False_if_exlcude_parameters_are_in_input(x): s = ''.join(map(py23_str, x)) assume( any( int(i) in (23, 45, 87) for i in re.findall(r'\d+', s) if re.match(r'\d+$', i))) assert not exclude_entry(s, [23, 45, 87], int, re.compile(r'\d+'))
def test__natsort_key_with_version_or_digit_matches_usigned_int(x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) assert _natsort_key(s, None, ns.VERSION) == _natsort_key(s, None, ns.INT | ns.UNSIGNED) assert _natsort_key(s, None, ns.DIGIT) == _natsort_key(s, None, ns.VERSION)
def test__natsort_key_with_float_and_signed_splits_input_into_string_and_signed_float_with_exponent(x): assume(len(x) <= 10) assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) assert ns.F == ns.FLOAT assert ns.S == ns.SIGNED assert _natsort_key(s, None, ns.F | ns.S) == tuple(_number_extracter(s, _float_sign_exp_re, *float_nosafe_nolocale_nogroup))
def test__natsort_key_with_tuple_input_returns_nested_tuples(x): # Iterables are parsed recursively so you can sort lists of lists. assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) t = tuple( _number_extracter(s, _int_nosign_re, *int_nosafe_nolocale_nogroup)) assert _natsort_key((s, s), None, ns.I) == (t, t)
def test_keep_entry_range_returns_True_if_any_portion_of_input_is_between_any_range_bounds( x): s = ''.join(map(py23_str, x)) assume( any((1 < int(i) < 20) or (88 < int(i) < 90) for i in re.findall(r'\d+', s) if re.match(r'\d+$', i))) assert keep_entry_range(s, [1, 88], [20, 90], int, re.compile(r'\d+'))
def test_path_splitter_splits_path_string_by_separator_and_removes_extension( x): assume(all(x)) z = py23_str(pathlib.Path(*x[:-2])) + '.' + x[-1] y = list(pathlib.Path(z).parts) assert _path_splitter(z) == y[:-1] + [pathlib.Path(z).stem ] + [pathlib.Path(z).suffix]
def test__natsort_key_with_IGNORECASE_lowercases_text(x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) try: assert _natsort_key(s, None, ns.IGNORECASE) == tuple(_number_extracter(s.casefold(), _int_nosign_re, *int_nosafe_nolocale_nogroup)) except AttributeError: assert _natsort_key(s, None, ns.IGNORECASE) == tuple(_number_extracter(s.lower(), _int_nosign_re, *int_nosafe_nolocale_nogroup))
def test__natsort_key_with_float_and_noexp_splits_input_into_string_and_unsigned_float_without_exponent( x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) assert _natsort_key(s, None, ns.F | ns.N) == tuple( _number_extracter(s, _float_nosign_noexp_re, *float_nosafe_nolocale_nogroup))
def test__natsort_key_with_GROUPLETTERS_and_LOWERCASEFIRST_inverts_text_first_then_doubles_letters_with_lowercase_letter_first(x): assume(len(x) <= 10) assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(ichain([repr(y)] if type(y) in (float, long, int) else [low(y), y] for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) t = _number_extracter(s.swapcase(), _int_nosign_re, *int_nosafe_nolocale_nogroup) assert _natsort_key(s, None, ns.G | ns.LF) == tuple(''.join(low(z) + z for z in y) if type(y) not in (float, long, int) else y for y in t)
def test_number_extracter_inserts_empty_string_between_floats_for_py3safe_option( x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) assert _number_extracter(s, _float_sign_exp_re, *float_safe_nolocale_nogroup) == float_splitter( s, True, True, True, '')
def test_number_extracter_excludes_plus_sign_and_exponent_in_float_definition_for_unsigned_noexp_floats( x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) assert _number_extracter(s, _float_nosign_noexp_re, *float_nosafe_nolocale_nogroup) == float_splitter( s, False, False, False, '')
def test__natsort_key_with_LOCALE_and_UNGROUPLETTERS_places_space_before_string_with_capital_first_letter( x): # Locale aware sorting assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) load_locale('en_US') if dumb_sort(): t = tuple( _number_extracter(s.swapcase(), _float_nosign_exp_re, *float_nosafe_locale_group)) else: t = tuple( _number_extracter(s, _float_nosign_exp_re, *float_nosafe_locale_nogroup)) if not t: r = (t, t) elif t[0] in (null_string, get_strxfrm()(b'\x00') if sys.version[0] == '2' and not use_pyicu else null_string): r = ((b'' if use_pyicu else '', ), t) else: r = ((s[0], ), t) assert _natsort_key(s, None, ns.LOCALE | ns.UNGROUPLETTERS | ns.F) == r # The below are all aliases for UNGROUPLETTERS assert ns.UNGROUPLETTERS == ns.UG assert ns.UNGROUPLETTERS == ns.CAPITALFIRST assert ns.UNGROUPLETTERS == ns.C locale.setlocale(locale.LC_NUMERIC, str(''))
def test__natsort_key_with_tuple_input_but_itemgetter_key_returns_split_second_element(x): # A key is applied before recursion, but not in the recursive calls. assume(len(x) <= 10) assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) t = tuple(_number_extracter(s, _int_nosign_re, *int_nosafe_nolocale_nogroup)) assert _natsort_key((s, s), itemgetter(1), ns.I) == t
def test__natsort_key_with_tuple_input_but_itemgetter_key_returns_split_second_element( x): # A key is applied before recursion, but not in the recursive calls. assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) t = tuple( _number_extracter(s, _int_nosign_re, *int_nosafe_nolocale_nogroup)) assert _natsort_key((s, s), itemgetter(1), ns.I) == t
def test__natsort_key_with_int_splits_and_signed_input_into_string_and_signed_int( x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) assert _natsort_key(s, None, ns.INT | ns.SIGNED) == tuple( _number_extracter(s, _int_sign_re, *int_nosafe_nolocale_nogroup)) assert _natsort_key(s, None, ns.SIGNED) == tuple( _number_extracter(s, _int_sign_re, *int_nosafe_nolocale_nogroup))
def test_locale_convert_with_groupletters_transforms_nonfloat_string_to_strxfrm_string_with_grouped_letters( x): assume(type(fast_float(x)) is not float) load_locale('en_US') strxfrm = get_strxfrm() assert locale_convert(x, (fast_float, isfloat), True) == strxfrm(''.join( chain.from_iterable([low(y), y] for y in x))) locale.setlocale(locale.LC_NUMERIC, str(''))
def test__natsort_key_with_int_splits_input_into_string_and_unsigned_int(x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) assert ns.I == ns.INT assert _natsort_key(s, None, ns.INT) == tuple(_number_extracter(s, _int_nosign_re, *int_nosafe_nolocale_nogroup)) # Default is int search assert _natsort_key(s, None, ns.NOEXP) == tuple(_number_extracter(s, _int_nosign_re, *int_nosafe_nolocale_nogroup)) # NOEXP is ignored for integers assert _natsort_key(s, None, ns.I | ns.NOEXP) == tuple(_number_extracter(s, _int_nosign_re, *int_nosafe_nolocale_nogroup))
def test_number_extracter_doubles_letters_with_lowercase_version_with_groupletters_for_float( x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) t = float_splitter(s, True, True, False, '') t = [ ''.join([low(z) + z for z in y]) if type(y) != float else y for y in t ] assert _number_extracter(s, _float_sign_exp_re, *float_nosafe_nolocale_group) == t
def test__natsort_key_with_LOCALE_transforms_floats_according_to_the_current_locale_and_strxfrms_strings(x): # Locale aware sorting assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) load_locale('en_US') if dumb_sort(): assert _natsort_key(s, None, ns.LOCALE | ns.F) == tuple(_number_extracter(s.swapcase(), _float_nosign_exp_re, *float_nosafe_locale_group)) else: assert _natsort_key(s, None, ns.LOCALE | ns.F) == tuple(_number_extracter(s, _float_nosign_exp_re, *float_nosafe_locale_nogroup)) locale.setlocale(locale.LC_NUMERIC, str(''))
def test__natsort_key_with_IGNORECASE_lowercases_text(x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) try: assert _natsort_key(s, None, ns.IGNORECASE) == tuple( _number_extracter(s.casefold(), _int_nosign_re, *int_nosafe_nolocale_nogroup)) except AttributeError: assert _natsort_key(s, None, ns.IGNORECASE) == tuple( _number_extracter(s.lower(), _int_nosign_re, *int_nosafe_nolocale_nogroup))
def test_number_extracter_extracts_numbers_and_strxfrms_letter_doubled_strings_with_use_locale_and_groupletters(x): assume(len(x) <= 10) load_locale('en_US') s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) t = int_splitter(s, False, False, null_string) try: # Account for locale bug on Python 3.2 t = [y if i == 0 and y is null_string else locale_convert(y, (fast_int, isint), True) for i, y in enumerate(t)] assert _number_extracter(s, _int_nosign_re, *int_nosafe_locale_group) == t except OverflowError: pass locale.setlocale(locale.LC_NUMERIC, str(''))
def test__natsort_key_with_GROUPLETTERS_doubles_text_with_lowercase_letter_first( x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join( ichain([repr(y)] if type(y) in (float, long, int) else [low(y), y] for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) t = _number_extracter(s, _int_nosign_re, *int_nosafe_nolocale_nogroup) assert _natsort_key(s, None, ns.GROUPLETTERS) == tuple(''.join( low(z) + z for z in y) if type(y) not in (float, long, int) else y for y in t)
def test__natsort_key_with_float_and_unsigned_splits_input_into_string_and_unsigned_float( x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) assert ns.U == ns.UNSIGNED assert _natsort_key(s, None, ns.F | ns.U) == tuple( _number_extracter(s, _float_nosign_exp_re, *float_nosafe_nolocale_nogroup)) # Default is unsigned search assert _natsort_key(s, None, ns.F) == tuple( _number_extracter(s, _float_nosign_exp_re, *float_nosafe_nolocale_nogroup))
def test__natsort_key_with_int_splits_input_into_string_and_unsigned_int(x): assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) assert ns.I == ns.INT assert _natsort_key(s, None, ns.INT) == tuple( _number_extracter(s, _int_nosign_re, *int_nosafe_nolocale_nogroup)) # Default is int search assert _natsort_key(s, None, ns.NOEXP) == tuple( _number_extracter(s, _int_nosign_re, *int_nosafe_nolocale_nogroup)) # NOEXP is ignored for integers assert _natsort_key(s, None, ns.I | ns.NOEXP) == tuple( _number_extracter(s, _int_nosign_re, *int_nosafe_nolocale_nogroup))
def test__natsort_key_with_LOCALE_transforms_floats_according_to_the_current_locale_and_strxfrms_strings( x): # Locale aware sorting assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) load_locale('en_US') if dumb_sort(): assert _natsort_key(s, None, ns.LOCALE | ns.F) == tuple( _number_extracter(s.swapcase(), _float_nosign_exp_re, *float_nosafe_locale_group)) else: assert _natsort_key(s, None, ns.LOCALE | ns.F) == tuple( _number_extracter(s, _float_nosign_exp_re, *float_nosafe_locale_nogroup)) locale.setlocale(locale.LC_NUMERIC, str(''))
def test__natsort_key_with_LOCALE_and_UNGROUPLETTERS_places_space_before_string_with_capital_first_letter(x): # Locale aware sorting assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) load_locale('en_US') if dumb_sort(): t = tuple(_number_extracter(s.swapcase(), _float_nosign_exp_re, *float_nosafe_locale_group)) else: t = tuple(_number_extracter(s, _float_nosign_exp_re, *float_nosafe_locale_nogroup)) if not t: r = (t, t) elif t[0] in (null_string, get_strxfrm()(b'\x00') if sys.version[0] == '2' and not use_pyicu else null_string): r = ((b'' if use_pyicu else '',), t) else: r = ((s[0],), t) assert _natsort_key(s, None, ns.LOCALE | ns.UNGROUPLETTERS | ns.F) == r # The below are all aliases for UNGROUPLETTERS assert ns.UNGROUPLETTERS == ns.UG assert ns.UNGROUPLETTERS == ns.CAPITALFIRST assert ns.UNGROUPLETTERS == ns.C locale.setlocale(locale.LC_NUMERIC, str(''))
def test_fast_int_leaves_float_string_as_is(x): assume(not x.is_integer()) assert fast_int(repr(x)) == repr(x)
def test_fast_float_converts_float_string_to_float(x): assume(not isnan(x)) # But inf is included assert fast_float(repr(x)) == x
def test_check_filter_converts_filter_numbers_to_floats_if_filter_is_valid( x, y): assume(all(i < j for i, j in zip(x, y))) assert check_filter(list(zip(x, y))) == [(float(i), float(j)) for i, j in zip(x, y)]
def test_parse_number_function_with_PATH_UNGROUPLETTERS_LOCALE_makes_function_that_returns_nested_tuple(x): assume(not isnan(x)) assert _parse_number_function(ns.PATH | ns.UNGROUPLETTERS | ns.LOCALE, '')(x) == ((('',), ('', x)),)
def test_check_filter_raises_ValueError_if_filter_is_invalid(x, y): assume(any(float(i) >= float(j) for i, j in zip(x, y))) with raises(ValueError) as err: check_filter(list(zip(x, y))) assert str(err.value) == 'Error in --filter: low >= high'
def test_keep_entry_range_returns_False_if_no_portion_of_input_is_between_the_range_bounds(x): s = ''.join(map(py23_str, x)) assume(all(not (1 <= int(i) <= 20) for i in re.findall(r'\d+', s) if re.match(r'\d+$', i))) assert not keep_entry_range(s, [1], [20], int, re.compile(r'\d+'))
def test_range_check_returns_range_as_is_but_with_floats_if_first_is_less_than_second(x, y): assume(float(x) < float(y)) assert range_check(x, y) == (float(x), float(y))
def test_range_check_raises_ValueError_if_second_is_less_than_first(x, y): assume(x >= y) with raises(ValueError) as err: range_check(x, x) assert str(err.value) == 'low >= high'
def test_fast_float_leaves_string_as_is(x): assume(not is_float(x)) assume(bool(x)) assert fast_float(x) == x
def test__natsort_key_with_UNGROUPLETTERS_does_nothing_without_LOCALE(x): assume(len(x) <= 10) assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) assert _natsort_key(s, None, ns.UG | ns.I) == _natsort_key(s, None, ns.I)
def test__natsort_key_with_LOWERCASEFIRST_inverts_text_case(x): assume(len(x) <= 10) assume(not any(type(y) == float and isnan(y) for y in x)) s = ''.join(repr(y) if type(y) in (float, long, int) else y for y in x) assert _natsort_key(s, None, ns.LOWERCASEFIRST) == tuple(_number_extracter(s.swapcase(), _int_nosign_re, *int_nosafe_nolocale_nogroup))
def test_fast_float_with_key_applies_to_string(x): assume(not is_float(x)) assume(bool(x)) assert fast_float(x, key=len) == len(x)
def test_grouper_returns_letters_with_lowercase_transform_of_letter(x): assume(type(fast_float(x)) is not float) assert grouper(x, (fast_float, isfloat)) == ''.join( chain.from_iterable([low(y), y] for y in x))
def test_fast_float_leaves_float_asis(x): assume(not isnan(x)) # But inf is included assert fast_float(x) == x
def test_grouper_returns_float_string_as_float(x): assume(not isnan(x)) assert grouper(repr(x), (fast_float, isfloat)) == x
def test_fast_float_leaves_string_as_is(x): assume(not is_float(x)) assert fast_float(x) == x
def test_locale_convert_transforms_float_string_to_float(x): assume(not isnan(x)) load_locale('en_US') assert locale_convert(repr(x), (fast_float, isfloat), False) == x locale.setlocale(locale.LC_NUMERIC, str(''))
def test_range_check_returns_range_as_is_but_with_floats_if_first_is_less_than_second2(x, y): assume(x < y) assert range_check(x, y) == (x, y)
def test_locale_convert_transforms_nonfloat_string_to_strxfrm_string(x): assume(type(fast_float(x)) is not float) load_locale('en_US') strxfrm = get_strxfrm() assert locale_convert(x, (fast_float, isfloat), False) == strxfrm(x) locale.setlocale(locale.LC_NUMERIC, str(''))
def test_check_filter_converts_filter_numbers_to_floats_if_filter_is_valid(x, y): assume(all(float(i) < float(j) for i, j in zip(x, y))) assert check_filter(list(zip(x, y))) == [(float(i), float(j)) for i, j in zip(x, y)]
def test_parse_number_function_makes_function_that_returns_tuple(x): assume(not isnan(x)) assert _parse_number_function(0, '')(x) == ('', x)
def test_keep_entry_range_returns_True_if_any_portion_of_input_is_between_any_range_bounds(x): s = ''.join(map(py23_str, x)) assume(any((1 < int(i) < 20) or (88 < int(i) < 90) for i in re.findall(r'\d+', s) if re.match(r'\d+$', i))) assert keep_entry_range(s, [1, 88], [20, 90], int, re.compile(r'\d+'))
def test_parse_number_function_with_PATH_makes_function_that_returns_nested_tuple(x): assume(not isnan(x)) assert _parse_number_function(ns.PATH, '')(x) == (('', x), )
def test_exclude_entry_returns_False_if_exlcude_parameters_are_in_input(x): s = ''.join(map(py23_str, x)) assume(any(int(i) in (23, 45, 87) for i in re.findall(r'\d+', s) if re.match(r'\d+$', i))) assert not exclude_entry(s, [23, 45, 87], int, re.compile(r'\d+'))
def test_check_filter_raises_ValueError_if_filter_is_invalid(x, y): assume(any(i >= j for i, j in zip(x, y))) with raises(ValueError) as err: check_filter(list(zip(x, y))) assert str(err.value) == 'Error in --filter: low >= high'