Debian Codegraph @

tests/conform/model.c

raw
1 #include <stdlib.h>
2 #include <string.h>
3 #define CLUTTER_DISABLE_DEPRECATION_WARNINGS
4 #include <clutter/clutter.h>
5
6 typedef struct _ModelData
7 {
8 ClutterModel *model;
9
10 guint n_row;
11 } ModelData;
12
13 typedef struct _ChangedData
14 {
15 ClutterModel *model;
16
17 ClutterModelIter *iter;
18
19 guint row;
20 guint n_emissions;
21
22 gint value_check;
23 } ChangedData;
24
25 enum
26 {
27 COLUMN_FOO, /* G_TYPE_STRING */
28 COLUMN_BAR, /* G_TYPE_INT */
29
30 N_COLUMNS
31 };
32
33 static const struct {
34 const gchar *expected_foo;
35 gint expected_bar;
36 } base_model[] = {
37 { "String 1", 1 },
38 { "String 2", 2 },
39 { "String 3", 3 },
40 { "String 4", 4 },
41 { "String 5", 5 },
42 { "String 6", 6 },
43 { "String 7", 7 },
44 { "String 8", 8 },
45 { "String 9", 9 },
46 };
47
48 static const struct {
49 const gchar *expected_foo;
50 gint expected_bar;
51 } forward_base[] = {
52 { "String 1", 1 },
53 { "String 2", 2 },
54 { "String 3", 3 },
55 { "String 4", 4 },
56 { "String 5", 5 },
57 { "String 6", 6 },
58 { "String 7", 7 },
59 { "String 8", 8 },
60 { "String 9", 9 },
61 };
62
63 static const struct {
64 const gchar *expected_foo;
65 gint expected_bar;
66 } backward_base[] = {
67 { "String 9", 9 },
68 { "String 8", 8 },
69 { "String 7", 7 },
70 { "String 6", 6 },
71 { "String 5", 5 },
72 { "String 4", 4 },
73 { "String 3", 3 },
74 { "String 2", 2 },
75 { "String 1", 1 },
76 };
77
78 static const struct {
79 const gchar *expected_foo;
80 gint expected_bar;
81 } filter_odd[] = {
82 { "String 1", 1 },
83 { "String 3", 3 },
84 { "String 5", 5 },
85 { "String 7", 7 },
86 { "String 9", 9 },
87 };
88
89 static const struct {
90 const gchar *expected_foo;
91 gint expected_bar;
92 } filter_even[] = {
93 { "String 8", 8 },
94 { "String 6", 6 },
95 { "String 4", 4 },
96 { "String 2", 2 },
97 };
98
99 static inline void
100 compare_iter (ClutterModelIter *iter,
101 const gint expected_row,
102 const gchar *expected_foo,
103 const gint expected_bar)
104 {
105 gchar *foo = NULL;
106 gint bar = 0;
107 gint row = 0;
108
109 row = clutter_model_iter_get_row (iter);
110 clutter_model_iter_get (iter,
111 COLUMN_FOO, &foo,
112 COLUMN_BAR, &bar,
113 -1);
114
115 if (g_test_verbose ())
116 g_print ("Row %d => %d: Got [ '%s', '%d' ], expected [ '%s', '%d' ]\n",
117 row, expected_row,
118 foo, bar,
119 expected_foo, expected_bar);
120
121 g_assert_cmpint (row, ==, expected_row);
122 g_assert_cmpstr (foo, ==, expected_foo);
123 g_assert_cmpint (bar, ==, expected_bar);
124
125 g_free (foo);
126 }
127
128 static void
129 on_row_added (ClutterModel *model,
130 ClutterModelIter *iter,
131 gpointer data)
132 {
133 ModelData *model_data = data;
134
135 compare_iter (iter,
136 model_data->n_row,
137 base_model[model_data->n_row].expected_foo,
138 base_model[model_data->n_row].expected_bar);
139
140 model_data->n_row += 1;
141 }
142
143 static gboolean
144 filter_even_rows (ClutterModel *model,
145 ClutterModelIter *iter,
146 gpointer dummy G_GNUC_UNUSED)
147 {
148 gint bar_value;
149
150 clutter_model_iter_get (iter, COLUMN_BAR, &bar_value, -1);
151
152 if (bar_value % 2 == 0)
153 return TRUE;
154
155 return FALSE;
156 }
157
158 static gboolean
159 filter_odd_rows (ClutterModel *model,
160 ClutterModelIter *iter,
161 gpointer dummy G_GNUC_UNUSED)
162 {
163 gint bar_value;
164
165 clutter_model_iter_get (iter, COLUMN_BAR, &bar_value, -1);
166
167 if (bar_value % 2 != 0)
168 return TRUE;
169
170 return FALSE;
171 }
172
173 static void
174 list_model_filter (void)
175 {
176 ModelData test_data = { NULL, 0 };
177 ClutterModelIter *iter;
178 gint i;
179
180 test_data.model = clutter_list_model_new (N_COLUMNS,
181 G_TYPE_STRING, "Foo",
182 G_TYPE_INT, "Bar");
183 test_data.n_row = 0;
184
185 for (i = 1; i < 10; i++)
186 {
187 gchar *foo = g_strdup_printf ("String %d", i);
188
189 clutter_model_append (test_data.model,
190 COLUMN_FOO, foo,
191 COLUMN_BAR, i,
192 -1);
193
194 g_free (foo);
195 }
196
197 if (g_test_verbose ())
198 g_print ("Forward iteration (filter odd)...\n");
199
200 clutter_model_set_filter (test_data.model, filter_odd_rows, NULL, NULL);
201
202 iter = clutter_model_get_first_iter (test_data.model);
203 g_assert (iter != NULL);
204
205 i = 0;
206 while (!clutter_model_iter_is_last (iter))
207 {
208 compare_iter (iter, i,
209 filter_odd[i].expected_foo,
210 filter_odd[i].expected_bar);
211
212 iter = clutter_model_iter_next (iter);
213 i += 1;
214 }
215
216 g_object_unref (iter);
217
218 if (g_test_verbose ())
219 g_print ("Backward iteration (filter even)...\n");
220
221 clutter_model_set_filter (test_data.model, filter_even_rows, NULL, NULL);
222
223 iter = clutter_model_get_last_iter (test_data.model);
224 g_assert (iter != NULL);
225
226 i = 0;
227 do
228 {
229 compare_iter (iter, G_N_ELEMENTS (filter_even) - i - 1,
230 filter_even[i].expected_foo,
231 filter_even[i].expected_bar);
232
233 iter = clutter_model_iter_prev (iter);
234 i += 1;
235 }
236 while (!clutter_model_iter_is_first (iter));
237
238 g_object_unref (iter);
239
240 if (g_test_verbose ())
241 g_print ("get_iter_at_row...\n");
242
243 clutter_model_set_filter (test_data.model, filter_odd_rows, NULL, NULL);
244
245 for (i = 0; i < 5; i++)
246 {
247 iter = clutter_model_get_iter_at_row (test_data.model, i);
248 compare_iter (iter, i ,
249 filter_odd[i].expected_foo,
250 filter_odd[i].expected_bar);
251 g_object_unref (iter);
252 }
253
254 iter = clutter_model_get_iter_at_row (test_data.model, 5);
255 g_assert (iter == NULL);
256
257 g_object_unref (test_data.model);
258 }
259
260 static void
261 list_model_iterate (void)
262 {
263 ModelData test_data = { NULL, 0 };
264 ClutterModelIter *iter;
265 gint i;
266
267 test_data.model = clutter_list_model_new (N_COLUMNS,
268 G_TYPE_STRING, "Foo",
269 G_TYPE_INT, "Bar");
270 test_data.n_row = 0;
271
272 g_signal_connect (test_data.model, "row-added",
273 G_CALLBACK (on_row_added),
274 &test_data);
275
276 for (i = 1; i < 10; i++)
277 {
278 gchar *foo = g_strdup_printf ("String %d", i);
279
280 clutter_model_append (test_data.model,
281 COLUMN_FOO, foo,
282 COLUMN_BAR, i,
283 -1);
284
285 g_free (foo);
286 }
287
288 if (g_test_verbose ())
289 g_print ("Forward iteration...\n");
290
291 iter = clutter_model_get_first_iter (test_data.model);
292 g_assert (iter != NULL);
293
294 i = 0;
295 while (!clutter_model_iter_is_last (iter))
296 {
297 compare_iter (iter, i,
298 forward_base[i].expected_foo,
299 forward_base[i].expected_bar);
300
301 iter = clutter_model_iter_next (iter);
302 i += 1;
303 }
304
305 g_object_unref (iter);
306
307 if (g_test_verbose ())
308 g_print ("Backward iteration...\n");
309
310 iter = clutter_model_get_last_iter (test_data.model);
311 g_assert (iter != NULL);
312
313 i = 0;
314 do
315 {
316 compare_iter (iter, G_N_ELEMENTS (backward_base) - i - 1,
317 backward_base[i].expected_foo,
318 backward_base[i].expected_bar);
319
320 iter = clutter_model_iter_prev (iter);
321 i += 1;
322 }
323 while (!clutter_model_iter_is_first (iter));
324
325 compare_iter (iter, G_N_ELEMENTS (backward_base) - i - 1,
326 backward_base[i].expected_foo,
327 backward_base[i].expected_bar);
328
329 g_object_unref (iter);
330
331 g_object_unref (test_data.model);
332 }
333
334 static void
335 list_model_populate (void)
336 {
337 ModelData test_data = { NULL, 0 };
338 gint i;
339
340 test_data.model = clutter_list_model_new (N_COLUMNS,
341 G_TYPE_STRING, "Foo",
342 G_TYPE_INT, "Bar");
343 test_data.n_row = 0;
344
345 g_signal_connect (test_data.model, "row-added",
346 G_CALLBACK (on_row_added),
347 &test_data);
348
349 for (i = 1; i < 10; i++)
350 {
351 gchar *foo = g_strdup_printf ("String %d", i);
352
353 clutter_model_append (test_data.model,
354 COLUMN_FOO, foo,
355 COLUMN_BAR, i,
356 -1);
357
358 g_free (foo);
359 }
360
361 g_object_unref (test_data.model);
362 }
363
364 static void
365 list_model_from_script (void)
366 {
367 ClutterScript *script = clutter_script_new ();
368 GObject *model;
369 GError *error = NULL;
370 gchar *test_file;
371 const gchar *name;
372 GType type;
373 ClutterModelIter *iter;
374 GValue value = { 0, };
375
376 test_file = g_test_build_filename (G_TEST_DIST, "scripts", "test-script-model.json", NULL);
377 clutter_script_load_from_file (script, test_file, &error);
378 if (g_test_verbose () && error)
379 g_print ("Error: %s", error->message);
380
381 g_assert_no_error (error);
382
383 model = clutter_script_get_object (script, "test-model");
384
385 g_assert (CLUTTER_IS_MODEL (model));
386 g_assert (clutter_model_get_n_columns (CLUTTER_MODEL (model)) == 3);
387
388 name = clutter_model_get_column_name (CLUTTER_MODEL (model), 0);
389 type = clutter_model_get_column_type (CLUTTER_MODEL (model), 0);
390
391 if (g_test_verbose ())
392 g_print ("column[0]: %s, type: %s\n", name, g_type_name (type));
393
394 g_assert (strcmp (name, "text-column") == 0);
395 g_assert (type == G_TYPE_STRING);
396
397 name = clutter_model_get_column_name (CLUTTER_MODEL (model), 2);
398 type = clutter_model_get_column_type (CLUTTER_MODEL (model), 2);
399
400 if (g_test_verbose ())
401 g_print ("column[2]: %s, type: %s\n", name, g_type_name (type));
402
403 g_assert (strcmp (name, "actor-column") == 0);
404 g_assert (g_type_is_a (type, CLUTTER_TYPE_ACTOR));
405
406 g_assert (clutter_model_get_n_rows (CLUTTER_MODEL (model)) == 3);
407
408 iter = clutter_model_get_iter_at_row (CLUTTER_MODEL (model), 0);
409 clutter_model_iter_get_value (iter, 0, &value);
410 g_assert (G_VALUE_HOLDS_STRING (&value));
411 g_assert (strcmp (g_value_get_string (&value), "text-row-1") == 0);
412 g_value_unset (&value);
413
414 clutter_model_iter_get_value (iter, 1, &value);
415 g_assert (G_VALUE_HOLDS_INT (&value));
416 g_assert (g_value_get_int (&value) == 1);
417 g_value_unset (&value);
418
419 clutter_model_iter_get_value (iter, 2, &value);
420 g_assert (G_VALUE_HOLDS_OBJECT (&value));
421 g_assert (g_value_get_object (&value) == NULL);
422 g_value_unset (&value);
423
424 iter = clutter_model_iter_next (iter);
425 clutter_model_iter_get_value (iter, 2, &value);
426 g_assert (G_VALUE_HOLDS_OBJECT (&value));
427 g_assert (CLUTTER_IS_ACTOR (g_value_get_object (&value)));
428 g_value_unset (&value);
429
430 iter = clutter_model_iter_next (iter);
431 clutter_model_iter_get_value (iter, 2, &value);
432 g_assert (G_VALUE_HOLDS_OBJECT (&value));
433 g_assert (CLUTTER_IS_ACTOR (g_value_get_object (&value)));
434 g_assert (strcmp (clutter_actor_get_name (g_value_get_object (&value)),
435 "actor-row-3") == 0);
436 g_value_unset (&value);
437 g_object_unref (iter);
438 }
439
440 static void
441 on_row_changed (ClutterModel *model,
442 ClutterModelIter *iter,
443 ChangedData *data)
444 {
445 gint value = -1;
446
447 clutter_model_iter_get (iter, COLUMN_BAR, &value, -1);
448
449 if (g_test_verbose ())
450 g_print ("row-changed value-check: %d, expected: %d\n",
451 value, data->value_check);
452
453 g_assert_cmpint (value, ==, data->value_check);
454
455 data->n_emissions += 1;
456 }
457
458 static void
459 list_model_row_changed (void)
460 {
461 ChangedData test_data = { NULL, NULL, 0, 0 };
462 GValue value = { 0, };
463 gint i;
464
465 test_data.model = clutter_list_model_new (N_COLUMNS,
466 G_TYPE_STRING, "Foo",
467 G_TYPE_INT, "Bar");
468 for (i = 1; i < 10; i++)
469 {
470 gchar *foo = g_strdup_printf ("String %d", i);
471
472 clutter_model_append (test_data.model,
473 COLUMN_FOO, foo,
474 COLUMN_BAR, i,
475 -1);
476
477 g_free (foo);
478 }
479
480 g_signal_connect (test_data.model, "row-changed",
481 G_CALLBACK (on_row_changed),
482 &test_data);
483
484 test_data.row = g_random_int_range (0, 9);
485 test_data.iter = clutter_model_get_iter_at_row (test_data.model,
486 test_data.row);
487 g_assert (CLUTTER_IS_MODEL_ITER (test_data.iter));
488
489 test_data.value_check = 47;
490
491 g_value_init (&value, G_TYPE_INT);
492 g_value_set_int (&value, test_data.value_check);
493
494 clutter_model_iter_set_value (test_data.iter, COLUMN_BAR, &value);
495
496 g_value_unset (&value);
497
498 if (g_test_verbose ())
499 g_print ("iter.set_value() emissions: %d, expected: 1\n",
500 test_data.n_emissions);
501
502 g_assert_cmpint (test_data.n_emissions, ==, 1);
503
504 test_data.n_emissions = 0;
505 test_data.value_check = 42;
506
507 clutter_model_iter_set (test_data.iter,
508 COLUMN_FOO, "changed",
509 COLUMN_BAR, test_data.value_check,
510 -1);
511
512 if (g_test_verbose ())
513 g_print ("iter.set() emissions: %d, expected: 1\n",
514 test_data.n_emissions);
515
516 g_assert_cmpint (test_data.n_emissions, ==, 1);
517
518 g_object_unref (test_data.iter);
519 g_object_unref (test_data.model);
520 }
521
522 CLUTTER_TEST_SUITE (
523 CLUTTER_TEST_UNIT ("/list-model/populate", list_model_populate)
524 CLUTTER_TEST_UNIT ("/list-model/iterate", list_model_iterate)
525 CLUTTER_TEST_UNIT ("/list-model/filter", list_model_filter)
526 CLUTTER_TEST_UNIT ("/list-model/row-changed", list_model_row_changed)
527 CLUTTER_TEST_UNIT ("/list-model/from-script", list_model_from_script)
528 )