← Back to branch summary

~guijemont/paf/api-fixing

« back to all changes in this revision

Viewing changes to tests/unit/pafclock.c

  • Committer: Guillaume Emont
  • Date: 2008-05-14 14:40:43 UTC
  • mfrom: (57.2.12 clock)
  • Revision ID: guillaume@fluendo.com-20080514144043-bxyapa8hgp3w8j42
Merge with the clock branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit/pafclock.c
23
23
 */
24
24
#include "paftest.h"
25
25
 
26
 
static void
27
 
construct_destruct (void)
28
 
{
29
 
    CU_ASSERT (TRUE);
 
26
/* FIXME: add more stuff with transformations when transformation
 
27
 * implementations actually exist */
 
28
 
 
29
/* init / cleanup stuff, not used for construction tests */
 
30
 
 
31
static PafClock *gClock = NULL;
 
32
 
 
33
static int
 
34
suite_init (void)
 
35
{
 
36
    gClock = paf_clock_new (1000);
 
37
 
 
38
    if (NULL == gClock)
 
39
        return 1;
 
40
 
 
41
    return 0;
 
42
}
 
43
 
 
44
static int
 
45
suite_cleanup (void)
 
46
{
 
47
    g_object_unref (gClock);
 
48
 
 
49
    return 0;
 
50
}
 
51
 
 
52
/* construction tests */
 
53
 
 
54
PAF_TEST_CONSTRUCT_DESTRUCT (PafClock, CLOCK, paf_clock_new (1000))
 
55
 
 
56
static void
 
57
test_new (void)
 
58
{
 
59
    PafClock *clock = NULL;
 
60
 
 
61
    CU_ASSERT_PTR_NOT_NULL_FATAL (clock = paf_clock_new (1000));
 
62
 
 
63
    g_object_unref (clock);
 
64
    clock = NULL;
 
65
 
 
66
    CU_ASSERT_PTR_NOT_NULL_FATAL (clock = paf_clock_new (0));
 
67
    g_object_unref (clock);
 
68
    clock = NULL;
 
69
 
 
70
    CU_ASSERT_PTR_NOT_NULL_FATAL (clock = paf_clock_new (G_MAXUINT));
 
71
    g_object_unref (clock);
 
72
}
 
73
 
 
74
static void
 
75
test_new_full_fail (void)
 
76
{
 
77
    PafClock *clock = NULL, *clock0 = NULL;
 
78
 
 
79
    CU_ASSERT_PTR_NOT_NULL_FATAL (clock0 = paf_clock_new (1000));
 
80
 
 
81
    CU_ASSERT_PTR_NULL (clock = paf_clock_new_full (1000,
 
82
                                                    -1.0f, /* should fail */
 
83
                                                    TRUE,
 
84
                                                    G_TYPE_NONE,
 
85
                                                    NULL,
 
86
                                                    NULL));
 
87
 
 
88
    CU_ASSERT_PTR_NULL (clock =
 
89
                        paf_clock_new_full (1000,
 
90
                                            1.0f,
 
91
                                            TRUE,
 
92
                                            G_TYPE_NONE,
 
93
                                            (PafTransformation *) clock0,
 
94
                                            /* should fail */
 
95
                                            NULL));
 
96
 
 
97
    CU_ASSERT_PTR_NULL (clock =
 
98
                        paf_clock_new_full (1000,
 
99
                                            1.0f,
 
100
                                            TRUE,
 
101
                                            G_TYPE_NONE,
 
102
                                            NULL,
 
103
                                            (PafTicker *) clock0
 
104
                                            /* should fail */));
 
105
 
 
106
    g_object_unref (clock0);
 
107
}
 
108
 
 
109
static void
 
110
test_new_full (void)
 
111
{
 
112
    PafClock *clock = NULL;
 
113
 
 
114
    CU_ASSERT_PTR_NOT_NULL_FATAL (clock =
 
115
                                  paf_clock_new_full (1000,
 
116
                                                      1.0f,
 
117
                                                      TRUE,
 
118
                                                      G_TYPE_NONE,
 
119
                                                      NULL,
 
120
                                                      NULL));
 
121
    g_object_unref (clock);
 
122
 
 
123
    CU_ASSERT_PTR_NOT_NULL_FATAL (clock =
 
124
                                  paf_clock_new_full (0,
 
125
                                                      1.0f,
 
126
                                                      TRUE,
 
127
                                                      G_TYPE_NONE,
 
128
                                                      NULL,
 
129
                                                      NULL));
 
130
    g_object_unref (clock);
 
131
    CU_ASSERT_PTR_NOT_NULL_FATAL (clock =
 
132
                                  paf_clock_new_full (G_MAXUINT,
 
133
                                                      1.0f,
 
134
                                                      TRUE,
 
135
                                                      G_TYPE_NONE,
 
136
                                                      NULL,
 
137
                                                      NULL));
 
138
    g_object_unref (clock);
 
139
 
 
140
    CU_ASSERT_PTR_NOT_NULL_FATAL (clock =
 
141
                                  paf_clock_new_full (1000,
 
142
                                                      0.0f,
 
143
                                                      TRUE,
 
144
                                                      G_TYPE_NONE,
 
145
                                                      NULL,
 
146
                                                      NULL));
 
147
    g_object_unref (clock);
 
148
 
 
149
    CU_ASSERT_PTR_NOT_NULL_FATAL (clock =
 
150
                                  paf_clock_new_full (1000,
 
151
                                                      G_MINFLOAT,
 
152
                                                      TRUE,
 
153
                                                      G_TYPE_NONE,
 
154
                                                      NULL,
 
155
                                                      NULL));
 
156
    g_object_unref (clock);
 
157
 
 
158
    CU_ASSERT_PTR_NOT_NULL_FATAL (clock =
 
159
                                  paf_clock_new_full (1000,
 
160
                                                      G_MAXFLOAT,
 
161
                                                      TRUE,
 
162
                                                      G_TYPE_NONE,
 
163
                                                      NULL,
 
164
                                                      NULL));
 
165
    g_object_unref (clock);
 
166
 
 
167
    CU_ASSERT_PTR_NOT_NULL_FATAL (clock =
 
168
                                  paf_clock_new_full (1000,
 
169
                                                      PAF_INFINITY,
 
170
                                                      TRUE,
 
171
                                                      G_TYPE_NONE,
 
172
                                                      NULL,
 
173
                                                      NULL));
 
174
    g_object_unref (clock);
 
175
 
 
176
    CU_ASSERT_PTR_NOT_NULL_FATAL (clock =
 
177
                                  paf_clock_new_full (1000,
 
178
                                                      1.0f,
 
179
                                                      FALSE,
 
180
                                                      G_TYPE_NONE,
 
181
                                                      NULL,
 
182
                                                      NULL));
 
183
    g_object_unref (clock);
 
184
 
 
185
    {
 
186
        PafTicker *ticker = NULL;
 
187
        CU_ASSERT_PTR_NOT_NULL (ticker = paf_ticker_new ());
 
188
        CU_ASSERT_PTR_NOT_NULL_FATAL (clock =
 
189
                                      paf_clock_new_full (1000,
 
190
                                                          1.0f,
 
191
                                                          TRUE,
 
192
                                                          G_TYPE_NONE,
 
193
                                                          NULL,
 
194
                                                          ticker));
 
195
        g_object_unref (clock);
 
196
    }
 
197
}
 
198
 
 
199
/* general tests */
 
200
 
 
201
/* non behavioural tests of paf_clock_tick() */
 
202
static void
 
203
basic_tick_fail (void)
 
204
{
 
205
    PAF_TEST_ASSERT_WARNING (paf_clock_tick (NULL, 0.0f));
 
206
 
 
207
    PAF_TEST_ASSERT_WARNING (paf_clock_tick (gClock, -1.0f));
 
208
    PAF_TEST_CHECK_GETTER_FAIL (gClock, clock, progression, -1.0f);
 
209
 
 
210
    PAF_TEST_ASSERT_WARNING (paf_clock_tick (gClock, 1.0f + G_MINFLOAT));
 
211
    PAF_TEST_CHECK_GETTER_FAIL (gClock, clock, progression, 1.0f + G_MINFLOAT);
 
212
 
 
213
    PAF_TEST_ASSERT_WARNING (paf_clock_tick (gClock, -G_MAXFLOAT));
 
214
    PAF_TEST_CHECK_GETTER_FAIL (gClock, clock, progression, -G_MAXFLOAT);
 
215
 
 
216
    PAF_TEST_ASSERT_WARNING (paf_clock_tick (gClock, G_MAXFLOAT));
 
217
    PAF_TEST_CHECK_GETTER_FAIL (gClock, clock, progression, G_MAXFLOAT);
 
218
 
 
219
    PAF_TEST_ASSERT_WARNING (paf_clock_tick (gClock, 2.0f));
 
220
    PAF_TEST_CHECK_GETTER_FAIL (gClock, clock, progression, 2.0f);
 
221
}
 
222
 
 
223
static void
 
224
do_basic_tick (PafClock *clock)
 
225
{
 
226
    PAF_TEST_ASSERT_NO_WARNING (paf_clock_tick (clock, 0.0f));
 
227
    PAF_TEST_CHECK_GETTER (clock, clock, progression, 0.0f);
 
228
 
 
229
    PAF_TEST_ASSERT_NO_WARNING (paf_clock_tick (clock, G_MINFLOAT));
 
230
    PAF_TEST_CHECK_GETTER (clock, clock, progression, G_MINFLOAT);
 
231
 
 
232
    PAF_TEST_ASSERT_NO_WARNING (paf_clock_tick (clock, 0.5f));
 
233
    PAF_TEST_CHECK_GETTER (clock, clock, progression, 0.5f);
 
234
 
 
235
    PAF_TEST_ASSERT_NO_WARNING (paf_clock_tick (clock, 0.75f));
 
236
    PAF_TEST_CHECK_GETTER (clock, clock, progression, 0.75f);
 
237
 
 
238
    PAF_TEST_ASSERT_NO_WARNING (paf_clock_tick (clock, 1.0f-G_MINFLOAT));
 
239
    PAF_TEST_CHECK_GETTER (clock, clock, progression, 1.0f-G_MINFLOAT);
 
240
}
 
241
 
 
242
static void
 
243
basic_tick (void)
 
244
{
 
245
    do_basic_tick (gClock);
 
246
 
 
247
    PAF_TEST_ASSERT_NO_WARNING (paf_clock_set_state (gClock, PAF_RUNNING));
 
248
    do_basic_tick (gClock);
 
249
 
 
250
    PAF_TEST_ASSERT_NO_WARNING (paf_clock_set_state (gClock, PAF_PAUSED));
 
251
    do_basic_tick (gClock);
 
252
}
 
253
 
 
254
/* property tests */
 
255
 
 
256
static void
 
257
test_auto_reverse (PafClock *clock)
 
258
{
 
259
    PAF_TEST_CHECK_PROPERTY_FAIL (NULL, clock, auto_reverse, TRUE);
 
260
 
 
261
    PAF_TEST_CHECK_PROPERTY (clock, clock, auto_reverse, TRUE);
 
262
    PAF_TEST_CHECK_PROPERTY (clock, clock, auto_reverse, FALSE);
 
263
}
 
264
 
 
265
static void
 
266
test_duration (PafClock *clock)
 
267
{
 
268
    PAF_TEST_CHECK_PROPERTY_FAIL (NULL, clock, duration, 1234);
 
269
 
 
270
    PAF_TEST_CHECK_PROPERTY (clock, clock, duration, 1234);
 
271
    PAF_TEST_CHECK_PROPERTY (clock, clock, duration, 1000);
 
272
    PAF_TEST_CHECK_PROPERTY (clock, clock, duration, 0);
 
273
    PAF_TEST_CHECK_PROPERTY (clock, clock, duration, G_MAXUINT);
 
274
 
 
275
}
 
276
 
 
277
static void
 
278
test_repeat_count (PafClock *clock)
 
279
{
 
280
    PAF_TEST_CHECK_PROPERTY_FAIL (NULL, clock, repeat_count, 1.0f);
 
281
 
 
282
    PAF_TEST_CHECK_PROPERTY_FAIL (clock, clock, repeat_count, -1.0f);
 
283
    PAF_TEST_CHECK_PROPERTY_FAIL (clock, clock, repeat_count, -G_MAXFLOAT);
 
284
    PAF_TEST_CHECK_PROPERTY_FAIL (clock, clock, repeat_count, -G_MINFLOAT);
 
285
 
 
286
    PAF_TEST_CHECK_PROPERTY (clock, clock, repeat_count, 0.0f);
 
287
    PAF_TEST_CHECK_PROPERTY (clock, clock, repeat_count, G_MINFLOAT);
 
288
    PAF_TEST_CHECK_PROPERTY (clock, clock, repeat_count, 0.5f);
 
289
    PAF_TEST_CHECK_PROPERTY (clock, clock, repeat_count, 1.0f);
 
290
    PAF_TEST_CHECK_PROPERTY (clock, clock, repeat_count, 3.0f);
 
291
    PAF_TEST_CHECK_PROPERTY (clock, clock, repeat_count, 123.456f);
 
292
    PAF_TEST_CHECK_PROPERTY (clock, clock, repeat_count, G_MAXFLOAT);
 
293
}
 
294
 
 
295
static void
 
296
test_state (PafClock *clock)
 
297
{
 
298
    PAF_TEST_CHECK_PROPERTY_FAIL (NULL, clock, state, PAF_STOPPED);
 
299
 
 
300
    PAF_TEST_CHECK_PROPERTY_FAIL (clock, clock, state, PAF_LAST_STATE);
 
301
    PAF_TEST_CHECK_PROPERTY_FAIL (clock, clock, state, PAF_LAST_STATE +1);
 
302
    PAF_TEST_CHECK_PROPERTY_FAIL (clock, clock, state, G_MAXINT);
 
303
 
 
304
    PAF_TEST_CHECK_PROPERTY (clock, clock, state, PAF_RUNNING);
 
305
    PAF_TEST_CHECK_PROPERTY (clock, clock, state, PAF_PAUSED);
 
306
    PAF_TEST_CHECK_PROPERTY (clock, clock, state, PAF_STOPPED);
 
307
}
 
308
 
 
309
/* FIXME: check behaviour with implemented transformations */
 
310
static void
 
311
test_time_transformation (PafClock *clock)
 
312
{
 
313
    PAF_TEST_CHECK_PROPERTY_FAIL (NULL, clock, time_transformation,
 
314
                                  NULL);
 
315
 
 
316
    PAF_TEST_CHECK_PROPERTY (clock, clock, time_transformation, NULL);
 
317
}
 
318
 
 
319
static void
 
320
test_time_transformation_type (PafClock *clock)
 
321
{
 
322
    PAF_TEST_CHECK_PROPERTY_FAIL (NULL, clock, time_transformation_type,
 
323
                                  G_TYPE_NONE);
 
324
 
 
325
    PAF_TEST_CHECK_PROPERTY_FAIL (clock, clock, time_transformation_type,
 
326
                                  G_TYPE_NONE);
 
327
}
 
328
 
 
329
static void
 
330
test_properties (void)
 
331
{
 
332
    test_auto_reverse (gClock);
 
333
    test_duration (gClock);
 
334
    test_repeat_count (gClock);
 
335
    test_state (gClock);
 
336
    test_time_transformation (gClock);
 
337
    test_time_transformation_type (gClock);
 
338
}
 
339
 
 
340
/* signal tests */
 
341
 
 
342
static gboolean
 
343
state_changed_callback (PafClock *clock, guint state, gpointer user_data)
 
344
{
 
345
    PafState *ret_state = user_data;
 
346
 
 
347
    *ret_state = state;
 
348
 
 
349
    return TRUE;
 
350
}
 
351
 
 
352
static void
 
353
test_state_changed (PafClock *clock)
 
354
{
 
355
    PafState state = PAF_LAST_STATE;
 
356
    gulong id;
 
357
 
 
358
    PAF_TEST_CHECK_SETTER (clock, clock, state, PAF_STOPPED);
 
359
 
 
360
    id = g_signal_connect (clock, "state-changed",
 
361
                           G_CALLBACK (state_changed_callback), &state);
 
362
    CU_ASSERT_NOT_EQUAL (id, 0);
 
363
 
 
364
    PAF_TEST_CHECK_SETTER (clock, clock, state, PAF_RUNNING);
 
365
    CU_ASSERT_EQUAL (state, PAF_RUNNING);
 
366
 
 
367
    g_signal_handler_disconnect (clock, id);
 
368
 
 
369
    PAF_TEST_CHECK_SETTER (clock, clock, state, PAF_STOPPED);
 
370
}
 
371
 
 
372
static gboolean
 
373
ticked_callback (PafClock *clock, gfloat progression, gpointer user_data)
 
374
{
 
375
    gfloat *ret_progression = user_data;
 
376
 
 
377
    *ret_progression = progression;
 
378
 
 
379
    return TRUE;
 
380
}
 
381
 
 
382
static void
 
383
test_ticked (PafClock *clock)
 
384
{
 
385
    gfloat progression = -1.0f;
 
386
    gulong id;
 
387
 
 
388
    PAF_TEST_CHECK_SETTER (clock, clock, state, PAF_STOPPED);
 
389
 
 
390
    id = g_signal_connect (clock, "ticked",
 
391
                           G_CALLBACK (ticked_callback), &progression);
 
392
    CU_ASSERT_NOT_EQUAL (id, 0);
 
393
 
 
394
    PAF_TEST_ASSERT_NO_WARNING (paf_clock_tick (clock, 0.1234f));
 
395
    CU_ASSERT_EQUAL (progression, 0.1234f);
 
396
 
 
397
    PAF_TEST_ASSERT_NO_WARNING (paf_clock_tick (clock, 0.314159f));
 
398
    CU_ASSERT_EQUAL (progression, 3.14159f);
 
399
 
 
400
    g_signal_handler_disconnect (clock, id);
 
401
 
 
402
    PAF_TEST_ASSERT_NO_WARNING (paf_clock_tick (clock, 0.0f));
 
403
 
 
404
    PAF_TEST_CHECK_SETTER (clock, clock, state, PAF_STOPPED);
 
405
}
 
406
 
 
407
static void
 
408
test_signals (void)
 
409
{
 
410
    test_state_changed (gClock);
 
411
    test_ticked (gClock);
30
412
}
31
413
 
32
414
void
33
415
add_pafclock_suite (void)
34
416
{
35
 
    CU_pSuite suite = paf_test_add_suite ("PafClock", NULL, NULL);
 
417
    CU_pSuite suite = paf_test_add_suite ("PafClock-noinit", NULL, NULL);
36
418
    PAF_TEST_ADD_TEST (suite, construct_destruct);
 
419
    PAF_TEST_ADD_TEST (suite, test_new);
 
420
    PAF_TEST_ADD_TEST (suite, test_new_full_fail);
 
421
    PAF_TEST_ADD_TEST (suite, test_new_full);
 
422
 
 
423
    suite = paf_test_add_suite ("PafClock",
 
424
                                          suite_init, suite_cleanup);
 
425
    PAF_TEST_ADD_TEST (suite, basic_tick_fail);
 
426
    PAF_TEST_ADD_TEST (suite, basic_tick);
 
427
    PAF_TEST_ADD_TEST (suite, test_properties);
 
428
    PAF_TEST_ADD_TEST (suite, test_signals);
37
429
}
38
430