Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/harfbuzz/src/test-map.cc @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 /*
2 * Copyright © 2021 Behdad Esfahbod
3 *
4 * This is part of HarfBuzz, a text shaping library.
5 *
6 * Permission is hereby granted, without written agreement and without
7 * license or royalty fees, to use, copy, modify, and distribute this
8 * software and its documentation for any purpose, provided that the
9 * above copyright notice and the following two paragraphs appear in
10 * all copies of this software.
11 *
12 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
13 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
14 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
15 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
16 * DAMAGE.
17 *
18 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
19 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
20 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
21 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
22 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
23 */
24
25 #include "hb.hh"
26 #include "hb-map.hh"
27 #include "hb-set.hh"
28 #include <string>
29
30 int
31 main (int argc, char **argv)
32 {
33
34 /* Test copy constructor. */
35 {
36 hb_map_t v1;
37 v1.set (1, 2);
38 hb_map_t v2 {v1};
39 assert (v1.get_population () == 1);
40 assert (v2.get_population () == 1);
41 assert (v1[1] == 2);
42 assert (v2[1] == 2);
43 }
44
45 /* Test copy assignment. */
46 {
47 hb_map_t v1;
48 v1.set (1, 2);
49 hb_map_t v2 = v1;
50 assert (v1.get_population () == 1);
51 assert (v2.get_population () == 1);
52 assert (v1[1] == 2);
53 assert (v2[1] == 2);
54 }
55
56 /* Test move constructor. */
57 {
58 hb_map_t s {};
59 s.set (1, 2);
60 hb_map_t v (std::move (s));
61 assert (s.get_population () == 0);
62 assert (v.get_population () == 1);
63 }
64
65 /* Test move assignment. */
66 {
67 hb_map_t s {};
68 s.set (1, 2);
69 hb_map_t v;
70 v = std::move (s);
71 assert (s.get_population () == 0);
72 assert (v.get_population () == 1);
73 }
74
75 /* Test initializing from iterable. */
76 {
77 hb_map_t s;
78
79 s.set (1, 2);
80 s.set (3, 4);
81
82 hb_vector_t<hb_pair_t<hb_codepoint_t, hb_codepoint_t>> v (s);
83 hb_map_t v0 (v);
84 hb_map_t v1 (s);
85 hb_map_t v2 (std::move (s));
86
87 assert (s.get_population () == 0);
88 assert (v0.get_population () == 2);
89 assert (v1.get_population () == 2);
90 assert (v2.get_population () == 2);
91 }
92
93 /* Test call fini() twice. */
94 {
95 hb_map_t s;
96 for (int i = 0; i < 16; i++)
97 s.set(i, i+1);
98 s.fini();
99 }
100
101 /* Test initializing from iterator. */
102 {
103 hb_map_t s;
104
105 s.set (1, 2);
106 s.set (3, 4);
107
108 hb_map_t v (hb_iter (s));
109
110 assert (v.get_population () == 2);
111 }
112
113 /* Test initializing from initializer list and swapping. */
114 {
115 using pair_t = hb_pair_t<hb_codepoint_t, hb_codepoint_t>;
116 hb_map_t v1 {pair_t{1,2}, pair_t{4,5}};
117 hb_map_t v2 {pair_t{3,4}};
118 hb_swap (v1, v2);
119 assert (v1.get_population () == 1);
120 assert (v2.get_population () == 2);
121 }
122
123 /* Test class key / value types. */
124 {
125 hb_hashmap_t<hb_bytes_t, int> m1;
126 hb_hashmap_t<int, hb_bytes_t> m2;
127 hb_hashmap_t<hb_bytes_t, hb_bytes_t> m3;
128 assert (m1.get_population () == 0);
129 assert (m2.get_population () == 0);
130 assert (m3.get_population () == 0);
131 }
132
133 {
134 hb_hashmap_t<int, int> m0;
135 hb_hashmap_t<std::string, int> m1;
136 hb_hashmap_t<int, std::string> m2;
137 hb_hashmap_t<std::string, std::string> m3;
138
139 std::string s;
140 for (unsigned i = 1; i < 1000; i++)
141 {
142 s += "x";
143 m0.set (i, i);
144 m1.set (s, i);
145 m2.set (i, s);
146 m3.set (s, s);
147 }
148 }
149
150 /* Test hashing maps. */
151 {
152 using pair = hb_pair_t<hb_codepoint_t, hb_codepoint_t>;
153
154 hb_hashmap_t<hb_map_t, hb_map_t> m1;
155
156 m1.set (hb_map_t (), hb_map_t {});
157 m1.set (hb_map_t (), hb_map_t {pair (1u, 2u)});
158 m1.set (hb_map_t {pair (1u, 2u)}, hb_map_t {pair (2u, 3u)});
159
160 assert (m1.get (hb_map_t ()) == hb_map_t {pair (1u, 2u)});
161 assert (m1.get (hb_map_t {pair (1u, 2u)}) == hb_map_t {pair (2u, 3u)});
162 }
163
164 /* Test hashing sets. */
165 {
166 hb_hashmap_t<hb_set_t, hb_set_t> m1;
167
168 m1.set (hb_set_t (), hb_set_t ());
169 m1.set (hb_set_t (), hb_set_t {1});
170 m1.set (hb_set_t {1, 1000}, hb_set_t {2});
171
172 assert (m1.get (hb_set_t ()) == hb_set_t {1});
173 assert (m1.get (hb_set_t {1000, 1}) == hb_set_t {2});
174 }
175
176 /* Test hashing vectors. */
177 {
178 using vector_t = hb_vector_t<unsigned>;
179
180 hb_hashmap_t<vector_t, vector_t> m1;
181
182 m1.set (vector_t (), vector_t {1});
183 m1.set (vector_t {1}, vector_t {2});
184
185 m1 << hb_pair_t<vector_t, vector_t> {vector_t {2}, vector_t ()};
186
187 assert (m1.get (vector_t ()) == vector_t {1});
188 assert (m1.get (vector_t {1}) == vector_t {2});
189 }
190
191 /* Test moving values */
192 {
193 using vector_t = hb_vector_t<unsigned>;
194
195 hb_hashmap_t<vector_t, vector_t> m1;
196 vector_t v {3};
197 assert (v.length == 1);
198 m1 << hb_pair_t<vector_t, vector_t> {vector_t {3}, v};
199 assert (v.length == 1);
200 m1 << hb_pair_t<vector_t, vector_t&&> {vector_t {4}, std::move (v)};
201 assert (v.length == 0);
202 m1 << hb_pair_t<vector_t&&, vector_t> {vector_t {4}, vector_t {5}};
203 m1 << hb_pair_t<vector_t&&, vector_t&&> {vector_t {4}, vector_t {5}};
204
205 hb_hashmap_t<vector_t, vector_t> m2;
206 vector_t v2 {3};
207 m2.set (vector_t {4}, v2);
208 assert (v2.length == 1);
209 m2.set (vector_t {5}, std::move (v2));
210 assert (v2.length == 0);
211 }
212
213 /* Test hb::shared_ptr. */
214 {
215 hb_hashmap_t<hb::shared_ptr<hb_set_t>, hb::shared_ptr<hb_set_t>> m;
216
217 m.set (hb::shared_ptr<hb_set_t> (hb_set_get_empty ()),
218 hb::shared_ptr<hb_set_t> (hb_set_get_empty ()));
219 m.get (hb::shared_ptr<hb_set_t> (hb_set_get_empty ()));
220 m.iter ();
221 m.keys ();
222 m.values ();
223 m.iter_ref ();
224 m.keys_ref ();
225 m.values_ref ();
226 }
227 /* Test hb::unique_ptr. */
228 {
229 hb_hashmap_t<hb::unique_ptr<hb_set_t>, hb::unique_ptr<hb_set_t>> m;
230
231 m.set (hb::unique_ptr<hb_set_t> (hb_set_get_empty ()),
232 hb::unique_ptr<hb_set_t> (hb_set_get_empty ()));
233 m.get (hb::unique_ptr<hb_set_t> (hb_set_get_empty ()));
234 hb::unique_ptr<hb_set_t> *v;
235 m.has (hb::unique_ptr<hb_set_t> (hb_set_get_empty ()), &v);
236 m.iter_ref ();
237 m.keys_ref ();
238 m.values_ref ();
239 }
240 /* Test more complex unique_ptr's. */
241 {
242 hb_hashmap_t<int, hb::unique_ptr<hb_hashmap_t<int, int>>> m;
243
244 m.get (0);
245 const hb::unique_ptr<hb_hashmap_t<int, int>> *v1;
246 m.has (0, &v1);
247 hb::unique_ptr<hb_hashmap_t<int, int>> *v2;
248 m.has (0, &v2);
249 }
250 /* Test hashmap with complex shared_ptrs as keys. */
251 {
252 hb_hashmap_t<hb::shared_ptr<hb_map_t>, unsigned> m;
253
254 hb_map_t *m1 = hb_map_create ();
255 hb_map_t *m2 = hb_map_create ();
256 m1->set (1,3);
257 m2->set (1,3);
258
259 hb::shared_ptr<hb_map_t> p1 {m1};
260 hb::shared_ptr<hb_map_t> p2 {m2};
261 m.set (p1,1);
262
263 assert (m.has (p2));
264
265 m1->set (2,4);
266 assert (!m.has (p2));
267 }
268 /* Test value type with hb_bytes_t. */
269 {
270 hb_hashmap_t<int, hb_bytes_t> m;
271 char c_str[] = "Test";
272 hb_bytes_t bytes (c_str);
273
274 m.set (1, bytes);
275 assert (m.has (1));
276 }
277 /* Test operators. */
278 {
279 hb_map_t m1, m2, m3;
280 m1.set (1, 2);
281 m1.set (2, 4);
282 m2.set (1, 2);
283 m2.set (2, 4);
284 m3.set (1, 3);
285 m3.set (3, 5);
286
287 assert (m1 == m2);
288 assert (m1 != m3);
289 assert (!(m2 == m3));
290
291 m2 = m3;
292 assert (m2.has (1));
293 assert (!m2.has (2));
294 assert (m2.has (3));
295
296 assert (m3.has (3));
297 }
298 /* Test reset. */
299 {
300 hb_hashmap_t<int, hb_set_t> m;
301 m.set (1, hb_set_t {1, 2, 3});
302 m.reset ();
303 }
304
305 return 0;
306 }