mobile/tests/check/libs/bytewriter.c

   1 /* GStreamer
   2  *
   3  * unit test for GstByteWriter
   4  *
   5  * Copyright (C) <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <gst/gst.h>
  28 #include <gst/check/gstcheck.h>
  29 #include <gst/base/gstbytewriter.h>
  30
  31 GST_START_TEST (test_initialization)
  32 {
  33   GstByteWriter writer, *writer2;
  34   static guint8 sdata[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  35   guint8 *data, *tmp;
  36
  37   gst_byte_writer_init_with_size (&writer, 24, FALSE);
  38   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 0);
  39   fail_unless_equals_int (gst_byte_writer_get_size (&writer), 0);
  40   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), -1);
  41   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
  42           (&writer)), 0);
  43   gst_byte_writer_reset (&writer);
  44
  45   data = g_memdup (sdata, sizeof (sdata));
  46   gst_byte_writer_init_with_data (&writer, data, sizeof (sdata), FALSE);
  47   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 0);
  48   fail_unless_equals_int (gst_byte_writer_get_size (&writer), 0);
  49   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer),
  50       sizeof (sdata));
  51   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
  52           (&writer)), 0)
  53       tmp = gst_byte_writer_reset_and_get_data (&writer);
  54   fail_if (tmp == data);
  55   g_free (tmp);
  56   g_free (data);
  57   data = tmp = NULL;
  58
  59   data = g_memdup (sdata, sizeof (sdata));
  60   gst_byte_writer_init_with_data (&writer, data, sizeof (sdata), TRUE);
  61   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 0);
  62   fail_unless_equals_int (gst_byte_writer_get_size (&writer), sizeof (sdata));
  63   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer),
  64       sizeof (sdata));
  65   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
  66           (&writer)), sizeof (sdata));
  67   tmp = gst_byte_writer_reset_and_get_data (&writer);
  68   fail_unless (tmp != data);
  69   g_free (tmp);
  70   g_free (data);
  71   data = tmp = NULL;
  72
  73   writer2 = gst_byte_writer_new_with_size (24, FALSE);
  74   data = gst_byte_writer_free_and_get_data (writer2);
  75   fail_unless (data != NULL);
  76   g_free (data);
  77 }
  78
  79 GST_END_TEST;
  80
  81 GST_START_TEST (test_write_fixed)
  82 {
  83   GstByteWriter writer;
  84   guint64 end_data = G_GUINT64_CONSTANT (0xff34567890abcdef);
  85   guint8 *data;
  86   guint8 b = 0;
  87   guint64 l = 0;
  88
  89   end_data = GUINT64_TO_BE (end_data);
  90
  91   gst_byte_writer_init_with_size (&writer, 8, TRUE);
  92   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), 8);
  93
  94   fail_unless (gst_byte_writer_put_uint8 (&writer, 0x12));
  95   fail_unless (gst_byte_writer_put_uint16_be (&writer, 0x3456));
  96   fail_unless (gst_byte_writer_put_uint16_le (&writer, 0x9078));
  97   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 5);
  98   fail_unless_equals_int (gst_byte_writer_get_size (&writer), 5);
  99   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), 8 - 5);
 100   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
 101           (&writer)), 0);
 102   fail_if (gst_byte_reader_get_uint8 (GST_BYTE_READER (&writer), &b));
 103   fail_unless (gst_byte_writer_put_uint24_be (&writer, 0xabcdef));
 104   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 8);
 105   fail_unless_equals_int (gst_byte_writer_get_size (&writer), 8);
 106   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), 8 - 8);
 107   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
 108           (&writer)), 0);
 109   fail_if (gst_byte_writer_put_uint8 (&writer, 0x12));
 110   fail_unless (gst_byte_writer_set_pos (&writer, 0));
 111   fail_unless (gst_byte_reader_peek_uint64_be (GST_BYTE_READER (&writer), &l));
 112   fail_unless_equals_uint64 (l, G_GUINT64_CONSTANT (0x1234567890abcdef));
 113   fail_unless (gst_byte_writer_put_uint8 (&writer, 0xff));
 114   fail_unless (gst_byte_writer_set_pos (&writer, 0));
 115   fail_unless (gst_byte_reader_get_uint64_be (GST_BYTE_READER (&writer), &l));
 116   fail_unless_equals_uint64 (l, G_GUINT64_CONSTANT (0xff34567890abcdef));
 117   fail_if (gst_byte_writer_put_uint64_be (&writer,
 118           G_GUINT64_CONSTANT (0x1234567890abcdef)));
 119
 120   data = gst_byte_writer_reset_and_get_data (&writer);
 121   fail_unless (data != NULL);
 122   fail_unless (memcmp (&end_data, data, 8) == 0);
 123   g_free (data);
 124 }
 125
 126 GST_END_TEST;
 127
 128 GST_START_TEST (test_write_non_fixed)
 129 {
 130   GstByteWriter writer;
 131   guint64 end_data = G_GUINT64_CONSTANT (0xff34567890abcdef);
 132   guint8 *data;
 133   guint64 l = 0;
 134
 135   end_data = GUINT64_TO_BE (end_data);
 136
 137   gst_byte_writer_init_with_size (&writer, 6, FALSE);
 138   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), -1);
 139
 140   fail_unless (gst_byte_writer_put_uint8 (&writer, 0x12));
 141   fail_unless (gst_byte_writer_put_uint16_be (&writer, 0x3456));
 142   fail_unless (gst_byte_writer_put_uint16_le (&writer, 0x9078));
 143   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 5);
 144   fail_unless_equals_int (gst_byte_writer_get_size (&writer), 5);
 145   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), -1);
 146   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
 147           (&writer)), 0);
 148   fail_unless (gst_byte_writer_put_uint24_be (&writer, 0xabcdef));
 149   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 8);
 150   fail_unless_equals_int (gst_byte_writer_get_size (&writer), 8);
 151   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), -1);
 152   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
 153           (&writer)), 0);
 154   fail_unless (gst_byte_writer_set_pos (&writer, 0));
 155   fail_unless (gst_byte_reader_peek_uint64_be (GST_BYTE_READER (&writer), &l));
 156   fail_unless_equals_uint64 (l, G_GUINT64_CONSTANT (0x1234567890abcdef));
 157   fail_unless (gst_byte_writer_put_uint8 (&writer, 0xff));
 158   fail_unless (gst_byte_writer_set_pos (&writer, 0));
 159   fail_unless (gst_byte_reader_get_uint64_be (GST_BYTE_READER (&writer), &l));
 160   fail_unless_equals_uint64 (l, G_GUINT64_CONSTANT (0xff34567890abcdef));
 161   fail_unless (gst_byte_writer_set_pos (&writer, 8));
 162   fail_unless (gst_byte_writer_put_uint64_be (&writer,
 163           G_GUINT64_CONSTANT (0x1234567890abcdef)));
 164
 165   data = gst_byte_writer_reset_and_get_data (&writer);
 166   fail_unless (data != NULL);
 167   fail_unless (memcmp (&end_data, data, 8) == 0);
 168   end_data = GUINT64_TO_BE (G_GUINT64_CONSTANT (0x1234567890abcdef));
 169   fail_unless (memcmp (&end_data, data + 8, 8) == 0);
 170   g_free (data);
 171 }
 172
 173 GST_END_TEST;
 174
 175 GST_START_TEST (test_from_data)
 176 {
 177   GstByteWriter writer;
 178   guint8 data[] = { 0x12, 0x34, 0x56, 0x78,
 179     0x90, 0xab, 0xcd, 0xef
 180   };
 181   guint8 *data2;
 182
 183   gst_byte_writer_init_with_data (&writer, data, sizeof (data), TRUE);
 184   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), 8);
 185   fail_unless (gst_byte_writer_put_uint8 (&writer, 0xff));
 186   fail_unless_equals_int (data[0], 0xff);
 187   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), 7);
 188   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 1);
 189   fail_if (gst_byte_writer_put_uint64_be (&writer,
 190           G_GUINT64_CONSTANT (0x1234567890abcdef)));
 191   data2 = gst_byte_writer_reset_and_get_data (&writer);
 192   fail_unless (data2 != NULL);
 193   fail_if (data2 == data);
 194   fail_unless (memcmp (data, data2, 8) == 0);
 195   g_free (data2);
 196 }
 197
 198 GST_END_TEST;
 199
 200 GST_START_TEST (test_put_data_strings)
 201 {
 202   GstByteWriter writer;
 203   guint8 data[] = { 0x12, 0x34, 0x56, 0x78,
 204     0x90, 0xab, 0xcd, 0xef
 205   };
 206   guint8 *data2;
 207
 208   gst_byte_writer_init (&writer);
 209   fail_unless (gst_byte_writer_put_data (&writer, data, 8));
 210   fail_unless (gst_byte_writer_put_string (&writer, "somerandomteststring"));
 211   fail_unless_equals_int (gst_byte_writer_get_pos (&writer),
 212       8 + sizeof ("somerandomteststring"));
 213
 214   data2 = gst_byte_writer_reset_and_get_data (&writer);
 215   fail_unless (data2 != NULL);
 216   fail_unless (memcmp (data2, data, 8) == 0);
 217   g_free (data2);
 218 }
 219
 220 GST_END_TEST;
 221
 222 GST_START_TEST (test_fill)
 223 {
 224   GstByteWriter writer;
 225   guint8 data[] = { 0x0, 0x0, 0x0, 0x0, 0x5, 0x5 };
 226   guint8 *data2;
 227
 228   gst_byte_writer_init (&writer);
 229   fail_unless (gst_byte_writer_fill (&writer, 0, 4));
 230   fail_unless (gst_byte_writer_fill (&writer, 5, 2));
 231
 232   data2 = gst_byte_writer_reset_and_get_data (&writer);
 233   fail_unless (data2 != NULL);
 234   fail_unless (memcmp (data2, data, 6) == 0);
 235   g_free (data2);
 236 }
 237
 238 GST_END_TEST;
 239 static Suite *
 240 gst_byte_writer_suite (void)
 241 {
 242   Suite *s = suite_create ("GstByteWriter");
 243   TCase *tc_chain = tcase_create ("general");
 244
 245   suite_add_tcase (s, tc_chain);
 246
 247   tcase_add_test (tc_chain, test_initialization);
 248   tcase_add_test (tc_chain, test_write_fixed);
 249   tcase_add_test (tc_chain, test_write_non_fixed);
 250   tcase_add_test (tc_chain, test_from_data);
 251   tcase_add_test (tc_chain, test_put_data_strings);
 252   tcase_add_test (tc_chain, test_fill);
 253
 254   return s;
 255 }
 256
 257
 258 GST_CHECK_MAIN (gst_byte_writer);