diff options
Diffstat (limited to 'tests/run/cpp_stl_algo_nonmodifying_sequence_ops.pyx')
| -rw-r--r-- | tests/run/cpp_stl_algo_nonmodifying_sequence_ops.pyx | 307 |
1 files changed, 307 insertions, 0 deletions
diff --git a/tests/run/cpp_stl_algo_nonmodifying_sequence_ops.pyx b/tests/run/cpp_stl_algo_nonmodifying_sequence_ops.pyx new file mode 100644 index 000000000..2b001b5f2 --- /dev/null +++ b/tests/run/cpp_stl_algo_nonmodifying_sequence_ops.pyx @@ -0,0 +1,307 @@ +# mode: run +# tag: cpp, werror, cpp11 + +from cython.operator cimport dereference as deref + +from libcpp cimport bool +from libcpp.algorithm cimport all_of, any_of, none_of, for_each, count, count_if, mismatch, find, find_if, find_if_not +from libcpp.algorithm cimport find_end, find_first_of, adjacent_find, search, search_n +from libcpp.iterator cimport distance +from libcpp.string cimport string +from libcpp.vector cimport vector + + +cdef bool is_odd(int i): + return i % 2 + + +def all_odd(vector[int] values): + """ + Test all_of with is_odd predicate. + + >>> all_odd([3, 5, 7, 11, 13, 17, 19, 23]) + True + >>> all_odd([3, 4]) + False + """ + return all_of(values.begin(), values.end(), is_odd) + + +def any_odd(vector[int] values): + """ + Test any_of with is_odd predicate. + + >>> any_odd([1, 2, 3, 4]) + True + >>> any_odd([2, 4, 6, 8]) + False + """ + return any_of(values.begin(), values.end(), is_odd) + + +def none_odd(vector[int] values): + """ + Test none_of with is_odd predicate. + + >>> none_odd([2, 4, 6, 8]) + True + >>> none_odd([1, 2, 3, 4]) + False + """ + return none_of(values.begin(), values.end(), is_odd) + + +def count_ones(vector[int] values): + """ + Test count. + + >>> count_ones([1, 2, 1, 2]) + 2 + """ + return count(values.begin(), values.end(), 1) + + +cdef void add_one(int &i): + # https://github.com/cython/cython/issues/1863 + (&i)[0] += 1 + + +def increment_ints(vector[int] values): + """ + Test for_each. + + >>> increment_ints([3, 4, 2, 8, 15, 267]) + [4, 5, 3, 9, 16, 268] + """ + for_each(values.begin(), values.end(), &add_one) + return values + + +def count_odd(vector[int] values): + """ + Test count_if with is_odd predicate. + + >>> count_odd([1, 2, 3, 4]) + 2 + >>> count_odd([2, 4, 6, 8]) + 0 + """ + return count_if(values.begin(), values.end(), is_odd) + + +def mirror_ends(string data): + """ + Test mismatch using cppreference example. + + This program determines the longest substring that is simultaneously found at the very beginning of the given string + and at the very end of it, in reverse order (possibly overlapping). + + >>> print(mirror_ends(b'abXYZba').decode('ascii')) + ab + >>> print(mirror_ends(b'abca').decode('ascii')) + a + >>> print(mirror_ends(b'aba').decode('ascii')) + aba + """ + return string(data.begin(), mismatch(data.begin(), data.end(), data.rbegin()).first) + + +def mismatch_ints(vector[int] values1, vector[int] values2): + """ + Test mismatch(first1, last1, first2). + + >>> mismatch_ints([1, 2, 3], [1, 2, 3]) + >>> mismatch_ints([1, 2], [1, 2, 3]) + >>> mismatch_ints([1, 3], [1, 2, 3]) + (3, 2) + """ + result = mismatch(values1.begin(), values1.end(), values2.begin()) + if result.first == values1.end(): + return + return deref(result.first), deref(result.second) + + +def is_int_in(vector[int] values, int target): + """ + Test find. + + >>> is_int_in(range(5), 3) + True + >>> is_int_in(range(5), 10) + False + """ + return find(values.begin(), values.end(), target) != values.end() + + +def find_odd(vector[int] values): + """ + Test find_if using is_odd predicate. + + >>> find_odd([2, 3, 4]) + 3 + >>> find_odd([2, 4, 6]) + """ + result = find_if(values.begin(), values.end(), is_odd) + if result != values.end(): + return deref(result) + else: + return None + + +def find_even(vector[int] values): + """ + Test find_if_not using is_odd predicate. + + >>> find_even([3, 4, 5]) + 4 + >>> find_even([1, 3, 5]) + """ + result = find_if_not(values.begin(), values.end(), is_odd) + if result != values.end(): + return deref(result) + else: + return None + + +def find_last_int_sequence(vector[int] values, vector[int] target): + """ + Test find_end. + + >>> find_last_int_sequence([1, 2, 3, 1, 2, 3], [2, 3]) + 4 + >>> find_last_int_sequence([1, 2, 3], [4, 5]) + """ + result = find_end(values.begin(), values.end(), target.begin(), target.end()) + if result != values.end(): + return distance(values.begin(), result) + else: + return None + + +cdef bool is_equal(int lhs, int rhs): + return lhs == rhs + + +def find_last_int_sequence2(vector[int] values, vector[int] target): + """ + Test find_end (using is_equal predicate). + + >>> find_last_int_sequence2([1, 2, 3, 1, 2, 3], [2, 3]) + 4 + >>> find_last_int_sequence2([1, 2, 3], [4, 5]) + """ + result = find_end(values.begin(), values.end(), target.begin(), target.end(), &is_equal) + if result != values.end(): + return distance(values.begin(), result) + else: + return None + + +def find_first_int_in_set(values, target): + """ + Test find_first_of. + + >>> find_first_int_in_set([1, 2, 3, 4, 5], [3, 5]) + 2 + >>> find_first_int_in_set([1, 2, 3], [4, 5]) + """ + cdef vector[int] v = values + cdef vector[int] t = target + result = find_first_of(v.begin(), v.end(), t.begin(), t.end()) + if result != v.end(): + return distance(v.begin(), result) + else: + return None + + +def find_first_int_in_set2(vector[int] values, vector[int] target): + """ + Test find_first_of with is_equal predicate. + + >>> find_first_int_in_set2([1, 2, 3, 4, 5], [3, 5]) + 2 + >>> find_first_int_in_set2([1, 2, 3], [4, 5]) + """ + result = find_first_of(values.begin(), values.end(), target.begin(), target.end(), is_equal) + if result != values.end(): + return distance(values.begin(), result) + else: + return None + + +def find_adjacent_int(vector[int] values): + """ + Test adjacent_find. + + >>> find_adjacent_int([0, 1, 2, 3, 40, 40, 41, 41, 5]) + 4 + >>> find_adjacent_int(range(5)) + """ + result = adjacent_find(values.begin(), values.end()) + if result != values.end(): + return distance(values.begin(), result) + else: + return None + + +def find_adjacent_int2(vector[int] values): + """ + Test find_adjacent with is_equal predicate. + + >>> find_adjacent_int2([0, 1, 2, 3, 40, 40, 41, 41, 5]) + 4 + >>> find_adjacent_int2(range(5)) + """ + result = adjacent_find(values.begin(), values.end(), is_equal) + if result != values.end(): + return distance(values.begin(), result) + else: + return None + + +def in_quote(string quote, string word): + """ + Test search using cppreference example. + + >>> in_quote(b"why waste time learning, when ignorance is instantaneous?", b"learning") + True + >>> in_quote(b"why waste time learning, when ignorance is instantaneous?", b"lemming") + False + """ + return search(quote.begin(), quote.end(), word.begin(), word.end()) != quote.end() + + +def in_quote2(string quote, string word): + """ + Test search using cppreference example (with is_equal predicate). + + >>> in_quote2(b"why waste time learning, when ignorance is instantaneous?", b"learning") + True + >>> in_quote2(b"why waste time learning, when ignorance is instantaneous?", b"lemming") + False + """ + return search(quote.begin(), quote.end(), word.begin(), word.end(), &is_equal) != quote.end() + + +def consecutive_values(string c, int count, char v): + """ + Test search_n using cppreference example (without std::begin and std::end). + + >>> consecutive_values(b"1001010100010101001010101", 4, ord("0")) + False + >>> consecutive_values(b"1001010100010101001010101", 3, ord("0")) + True + """ + return search_n(c.begin(), c.end(), count, v) != c.end() + + +def consecutive_values2(string c, int count, char v): + """ + Test search_n using cppreference example (with is_equal predicate). + + >>> consecutive_values2(b"1001010100010101001010101", 4, ord("0")) + False + >>> consecutive_values2(b"1001010100010101001010101", 3, ord("0")) + True + """ + return search_n(c.begin(), c.end(), count, v, &is_equal) != c.end() |