check/gst/gstiterator.c

   1 /* GStreamer
   2  * Copyright (C) 2005 Andy Wingo <wingo@pobox.com>
   3  *
   4  * gstiterator.c: Unit test for iterators
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22
  23 #include "../gstcheck.h"
  24
  25
  26 static GList *
  27 make_list_of_ints (gint n)
  28 {
  29   GList *ret = NULL;
  30   gint i;
  31
  32   for (i = 0; i < n; i++)
  33     ret = g_list_prepend (ret, GINT_TO_POINTER (i));
  34
  35   return g_list_reverse (ret);
  36 }
  37
  38 #define NUM_ELEMENTS 10
  39
  40 GST_START_TEST (test_manual_iteration)
  41 {
  42   GList *l;
  43   guint32 cookie = 0;
  44   GMutex *m;
  45   GstIterator *iter;
  46   GstIteratorResult res;
  47   gpointer item;
  48   gint i = 0;
  49
  50   l = make_list_of_ints (NUM_ELEMENTS);
  51   m = g_mutex_new ();
  52
  53   iter = gst_iterator_new_list (m, &cookie, &l, NULL, NULL, NULL);
  54
  55   g_return_if_fail (iter != NULL);
  56
  57   while (1) {
  58     res = gst_iterator_next (iter, &item);
  59     if (i < NUM_ELEMENTS) {
  60       g_return_if_fail (res == GST_ITERATOR_OK);
  61       g_return_if_fail (GPOINTER_TO_INT (item) == i);
  62       i++;
  63       continue;
  64     } else {
  65       g_return_if_fail (res == GST_ITERATOR_DONE);
  66       break;
  67     }
  68   }
  69
  70   gst_iterator_free (iter);
  71 }
  72
  73 GST_END_TEST
  74 GST_START_TEST (test_resync)
  75 {
  76   GList *l;
  77   guint32 cookie = 0;
  78   GMutex *m;
  79   GstIterator *iter;
  80   GstIteratorResult res;
  81   gpointer item;
  82   gint i = 0;
  83   gboolean hacked_list = FALSE;
  84
  85   l = make_list_of_ints (NUM_ELEMENTS);
  86   m = g_mutex_new ();
  87
  88   iter = gst_iterator_new_list (m, &cookie, &l, NULL, NULL, NULL);
  89
  90   g_return_if_fail (iter != NULL);
  91
  92   while (1) {
  93     res = gst_iterator_next (iter, &item);
  94     if (i < NUM_ELEMENTS / 2) {
  95       g_return_if_fail (res == GST_ITERATOR_OK);
  96       g_return_if_fail (GPOINTER_TO_INT (item) == i);
  97       i++;
  98       continue;
  99     } else if (!hacked_list) {
 100       /* here's where we test resync */
 101       g_return_if_fail (res == GST_ITERATOR_OK);
 102       l = g_list_prepend (l, GINT_TO_POINTER (-1));
 103       cookie++;
 104       hacked_list = TRUE;
 105       continue;
 106     } else {
 107       g_return_if_fail (res == GST_ITERATOR_RESYNC);
 108       gst_iterator_resync (iter);
 109       res = gst_iterator_next (iter, &item);
 110       g_return_if_fail (res == GST_ITERATOR_OK);
 111       g_return_if_fail (GPOINTER_TO_INT (item) == -1);
 112       break;
 113     }
 114   }
 115
 116   gst_iterator_free (iter);
 117 }
 118 GST_END_TEST static gboolean
 119 add_fold_func (gpointer item, GValue * ret, gpointer user_data)
 120 {
 121   g_value_set_int (ret, g_value_get_int (ret) + GPOINTER_TO_INT (item));
 122   return TRUE;
 123 }
 124
 125 GST_START_TEST (test_fold)
 126 {
 127   GList *l;
 128   guint32 cookie = 0;
 129   GMutex *m;
 130   GstIterator *iter;
 131   GstIteratorResult res;
 132   gint i, expected;
 133   GValue ret = { 0, };
 134
 135   l = make_list_of_ints (NUM_ELEMENTS);
 136   m = g_mutex_new ();
 137   iter = gst_iterator_new_list (m, &cookie, &l, NULL, NULL, NULL);
 138   g_return_if_fail (iter != NULL);
 139
 140   expected = 0;
 141   for (i = 0; i < NUM_ELEMENTS; i++)
 142     expected += i;
 143
 144   g_value_init (&ret, G_TYPE_INT);
 145   g_value_set_int (&ret, 0);
 146
 147   res = gst_iterator_fold (iter, add_fold_func, &ret, NULL);
 148
 149   g_return_if_fail (res == GST_ITERATOR_DONE);
 150   g_return_if_fail (g_value_get_int (&ret) == expected);
 151 }
 152 GST_END_TEST Suite *
 153 gstiterator_suite (void)
 154 {
 155   Suite *s = suite_create ("GstIterator");
 156   TCase *tc_chain = tcase_create ("correctness");
 157
 158   tcase_set_timeout (tc_chain, 0);
 159
 160   suite_add_tcase (s, tc_chain);
 161   tcase_add_test (tc_chain, test_manual_iteration);
 162   tcase_add_test (tc_chain, test_resync);
 163   tcase_add_test (tc_chain, test_fold);
 164   return s;
 165 }
 166
 167 int
 168 main (int argc, char **argv)
 169 {
 170   int nf;
 171
 172   Suite *s = gstiterator_suite ();
 173   SRunner *sr = srunner_create (s);
 174
 175   gst_check_init (&argc, &argv);
 176
 177   srunner_run_all (sr, CK_NORMAL);
 178   nf = srunner_ntests_failed (sr);
 179   srunner_free (sr);
 180
 181   return nf;
 182 }