Edit
kc3-lang/harfbuzz/src/test-iter.cc
Behdad Esfahbod
- src/test-iter.cc
-
/* * Copyright © 2018 Google, Inc. * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Google Author(s): Behdad Esfahbod */ #include "hb.hh" #include "hb-iter.hh" #include "hb-array.hh" #include "hb-set.hh" #include "hb-ot-layout-common.hh" template <typename T> struct array_iter_t : hb_iter_with_fallback_t<array_iter_t<T>, T&> { array_iter_t (hb_array_t<T> arr_) : arr (arr_) {} typedef T& __item_t__; static constexpr bool is_random_access_iterator = true; T& __item_at__ (unsigned i) const { return arr[i]; } void __forward__ (unsigned n) { arr += n; } void __rewind__ (unsigned n) { arr -= n; } unsigned __len__ () const { return arr.length; } bool operator != (const array_iter_t& o) { return arr != o.arr; } private: hb_array_t<T> arr; }; template <typename T> struct some_array_t { some_array_t (hb_array_t<T> arr_) : arr (arr_) {} typedef array_iter_t<T> iter_t; array_iter_t<T> iter () { return array_iter_t<T> (arr); } operator array_iter_t<T> () { return iter (); } operator hb_iter_t<array_iter_t<T>> () { return iter (); } private: hb_array_t<T> arr; }; template <typename Iter, hb_requires (hb_is_iterator (Iter))> static void test_iterator_non_default_constructable (Iter it) { /* Iterate over a copy of it. */ for (auto c = it.iter (); c; c++) *c; /* Same. */ for (auto c = +it; c; c++) *c; /* Range-based for over a copy. */ for (auto _ : +it) (void) _; it += it.len (); it = it + 10; it = 10 + it; assert (*it == it[0]); static_assert (true || it.is_random_access_iterator, ""); static_assert (true || it.is_sorted_iterator, ""); } template <typename Iter, hb_requires (hb_is_iterator (Iter))> static void test_iterator (Iter it) { Iter default_constructed; assert (!default_constructed); test_iterator_non_default_constructable (it); } template <typename Iterable, hb_requires (hb_is_iterable (Iterable))> static void test_iterable (const Iterable &lst = Null (Iterable)) { for (auto _ : lst) (void) _; // Test that can take iterator from. test_iterator (lst.iter ()); } template <typename It> static void check_sequential (It it) { int i = 1; for (int v : +it) { assert (v == i++); } } static void test_concat () { hb_vector_t<int> a = {1, 2, 3}; hb_vector_t<int> b = {4, 5}; hb_vector_t<int> c = {}; hb_vector_t<int> d = {1, 2, 3, 4, 5}; auto it1 = hb_concat (a, b); assert (it1.len () == 5); assert (it1.is_random_access_iterator); auto it2 = hb_concat (c, d); assert (it2.len () == 5); auto it3 = hb_concat (d, c); assert (it3.len () == 5); for (int i = 0; i < 5; i++) { assert(it1[i] == i + 1); assert(it2[i] == i + 1); assert(it3[i] == i + 1); } check_sequential (it1); check_sequential (it2); check_sequential (it3); auto it4 = +it1; it4 += 0; assert (*it4 == 1); it4 += 2; assert (*it4 == 3); assert (it4); assert (it4.len () == 3); it4 += 2; assert (*it4 == 5); assert (it4); assert (it4.len () == 1); it4++; assert (!it4); assert (it4.len () == 0); auto it5 = +it1; it5 += 3; assert (*it5 == 4); hb_set_t s_a = {1, 2, 3}; hb_set_t s_b = {4, 5}; auto it6 = hb_concat (s_a, s_b); assert (!it6.is_random_access_iterator); check_sequential (it6); assert (it6.len () == 5); it6 += 0; assert (*it6 == 1); it6 += 3; assert (*it6 == 4); assert (it6); assert (it6.len () == 2); } int main (int argc, char **argv) { const int src[10] = {}; int dst[20]; hb_vector_t<int> v; array_iter_t<const int> s (src); /* Implicit conversion from static array. */ array_iter_t<const int> s2 (v); /* Implicit conversion from vector. */ array_iter_t<int> t (dst); static_assert (array_iter_t<int>::is_random_access_iterator, ""); some_array_t<const int> a (src); s2 = s; hb_iter (src); hb_iter (src, 2); hb_fill (t, 42); hb_copy (s, t); hb_copy (a.iter (), t); test_iterable (v); hb_set_t st; st << 1 << 15 << 43; test_iterable (st); hb_sorted_array_t<int> sa; (void) static_cast<hb_iter_t<hb_sorted_array_t<int>, hb_sorted_array_t<int>::item_t>&> (sa); (void) static_cast<hb_iter_t<hb_sorted_array_t<int>, hb_sorted_array_t<int>::__item_t__>&> (sa); (void) static_cast<hb_iter_t<hb_sorted_array_t<int>, int&>&>(sa); (void) static_cast<hb_iter_t<hb_sorted_array_t<int>>&>(sa); (void) static_cast<hb_iter_t<hb_array_t<int>, int&>&> (sa); test_iterable (sa); test_iterable<hb_array_t<int>> (); test_iterable<hb_sorted_array_t<const int>> (); test_iterable<hb_vector_t<float>> (); test_iterable<hb_set_t> (); test_iterable<OT::Array16Of<OT::HBUINT16>> (); test_iterator (hb_zip (st, v)); test_iterator_non_default_constructable (hb_enumerate (st)); test_iterator_non_default_constructable (hb_enumerate (st, -5)); test_iterator_non_default_constructable (hb_enumerate (hb_iter (st))); test_iterator_non_default_constructable (hb_enumerate (hb_iter (st) + 1)); test_iterator_non_default_constructable (hb_iter (st) | hb_filter ()); test_iterator_non_default_constructable (hb_iter (st) | hb_map (hb_lidentity)); assert (true == hb_all (st)); assert (false == hb_all (st, 42u)); assert (true == hb_any (st)); assert (false == hb_any (st, 14u)); assert (true == hb_any (st, 14u, [] (unsigned _) { return _ - 1u; })); assert (true == hb_any (st, [] (unsigned _) { return _ == 15u; })); assert (true == hb_any (st, 15u)); assert (false == hb_none (st)); assert (false == hb_none (st, 15u)); assert (true == hb_none (st, 17u)); hb_array_t<hb_vector_t<int>> pa; pa->as_array (); hb_map_t m; hb_iter (st); hb_iter (&st); + hb_iter (src) | hb_map (m) | hb_map (&m) | hb_filter () | hb_filter (st) | hb_filter (&st) | hb_filter (hb_bool) | hb_filter (hb_bool, hb_identity) | hb_sink (st) ; + hb_iter (src) | hb_sink (hb_array (dst)) ; + hb_iter (src) | hb_apply (&st) ; + hb_iter (src) | hb_map ([] (int i) { return 1; }) | hb_reduce ([=] (int acc, int value) { return acc; }, 2) ; using map_pair_t = hb_item_type<hb_map_t>; + hb_iter (m) | hb_map ([] (map_pair_t p) { return p.first * p.second; }) ; m.keys (); using map_key_t = decltype (*m.keys()); + hb_iter (m.keys ()) | hb_filter ([] (map_key_t k) { return k < 42; }) | hb_drain ; m.values (); using map_value_t = decltype (*m.values()); + hb_iter (m.values ()) | hb_filter ([] (map_value_t k) { return k < 42; }) | hb_drain ; unsigned int temp1 = 10; unsigned int temp2 = 0; hb_map_t *result = + hb_iter (src) | hb_map ([&] (int i) -> hb_set_t * { hb_set_t *set = hb_set_create (); for (unsigned int i = 0; i < temp1; ++i) hb_set_add (set, i); temp1++; return set; }) | hb_reduce ([&] (hb_map_t *acc, hb_set_t *value) -> hb_map_t * { hb_map_set (acc, temp2++, hb_set_get_population (value)); /* This is not a memory managed language, take care! */ hb_set_destroy (value); return acc; }, hb_map_create ()) ; /* The result should be something like 0->10, 1->11, ..., 9->19 */ assert (hb_map_get (result, 9) == 19); hb_map_destroy (result); /* Like above, but passing hb_set_t instead of hb_set_t * */ temp1 = 10; temp2 = 0; result = + hb_iter (src) | hb_map ([&] (int i) -> hb_set_t { hb_set_t set; for (unsigned int i = 0; i < temp1; ++i) hb_set_add (&set, i); temp1++; return set; }) | hb_reduce ([&] (hb_map_t *acc, hb_set_t value) -> hb_map_t * { hb_map_set (acc, temp2++, hb_set_get_population (&value)); return acc; }, hb_map_create ()) ; /* The result should be something like 0->10, 1->11, ..., 9->19 */ assert (hb_map_get (result, 9) == 19); hb_map_destroy (result); unsigned int temp3 = 0; + hb_iter(src) | hb_map([&] (int i) { return ++temp3; }) | hb_reduce([&] (float acc, int value) { return acc + value; }, 0) ; + hb_iter (src) | hb_drain ; t << 1; long vl; s >> vl; hb_iota (); hb_iota (3); hb_iota (3, 2); assert ((&vl) + 1 == *++hb_iota (&vl, hb_inc)); hb_range (); hb_repeat (7u); hb_repeat (nullptr); hb_repeat (vl) | hb_chop (3); assert (hb_len (hb_range (10) | hb_take (3)) == 3); assert (hb_range (9).len () == 9); assert (hb_range (2, 9).len () == 7); assert (hb_range (2, 9, 3).len () == 3); assert (hb_range (2, 8, 3).len () == 2); assert (hb_range (2, 7, 3).len () == 2); assert (hb_range (-2, -9, -3).len () == 3); assert (hb_range (-2, -8, -3).len () == 2); assert (hb_range (-2, -7, -3).len () == 2); test_concat (); return 0; }