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., 51 Franklin St, Fifth Floor,
  20  * Boston, MA 02110-1301, 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 #ifdef TIZEN_FEATURE_UPSTREAM
  31 #include "gst/glib-compat-private.h"
  32 #endif /* TIZEN_FEATURE_UPSTREAM */
  33
  34 GST_START_TEST (test_initialization)
  35 {
  36   GstByteWriter writer, *writer2;
  37   static guint8 sdata[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  38   guint8 *data, *tmp;
  39
  40   gst_byte_writer_init_with_size (&writer, 24, FALSE);
  41   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 0);
  42   fail_unless_equals_int (gst_byte_writer_get_size (&writer), 0);
  43   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), -1);
  44   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
  45           (&writer)), 0);
  46   gst_byte_writer_reset (&writer);
  47
  48 #ifdef TIZEN_FEATURE_UPSTREAM
  49   data = g_memdup2 (sdata, sizeof (sdata));
  50 #else /* TIZEN_FEATURE_UPSTREAM */
  51   data = g_memdup (sdata, sizeof (sdata));
  52 #endif /* TIZEN_FEATURE_UPSTREAM */
  53   gst_byte_writer_init_with_data (&writer, data, sizeof (sdata), FALSE);
  54   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 0);
  55   fail_unless_equals_int (gst_byte_writer_get_size (&writer), 0);
  56   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer),
  57       sizeof (sdata));
  58   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
  59           (&writer)), 0)
  60       tmp = gst_byte_writer_reset_and_get_data (&writer);
  61   fail_if (tmp == data);
  62   g_free (tmp);
  63   g_free (data);
  64   data = tmp = NULL;
  65
  66 #ifdef TIZEN_FEATURE_UPSTREAM
  67   data = g_memdup2 (sdata, sizeof (sdata));
  68 #else /* TIZEN_FEATURE_UPSTREAM */
  69   data = g_memdup (sdata, sizeof (sdata));
  70 #endif /* TIZEN_FEATURE_UPSTREAM */
  71   gst_byte_writer_init_with_data (&writer, data, sizeof (sdata), TRUE);
  72   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 0);
  73   fail_unless_equals_int (gst_byte_writer_get_size (&writer), sizeof (sdata));
  74   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer),
  75       sizeof (sdata));
  76   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
  77           (&writer)), sizeof (sdata));
  78   tmp = gst_byte_writer_reset_and_get_data (&writer);
  79   fail_unless (tmp != data);
  80   g_free (tmp);
  81   g_free (data);
  82   data = tmp = NULL;
  83
  84   writer2 = gst_byte_writer_new_with_size (24, FALSE);
  85   data = gst_byte_writer_free_and_get_data (writer2);
  86   fail_unless (data != NULL);
  87   g_free (data);
  88 }
  89
  90 GST_END_TEST;
  91
  92 GST_START_TEST (test_write_fixed)
  93 {
  94   GstByteWriter writer;
  95   guint64 end_data = G_GUINT64_CONSTANT (0xff34567890abcdef);
  96   guint8 *data;
  97   guint8 b = 0;
  98   guint64 l = 0;
  99
 100   end_data = GUINT64_TO_BE (end_data);
 101
 102   gst_byte_writer_init_with_size (&writer, 8, TRUE);
 103   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), 8);
 104
 105   fail_unless (gst_byte_writer_put_uint8 (&writer, 0x12));
 106   fail_unless (gst_byte_writer_put_uint16_be (&writer, 0x3456));
 107   fail_unless (gst_byte_writer_put_uint16_le (&writer, 0x9078));
 108   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 5);
 109   fail_unless_equals_int (gst_byte_writer_get_size (&writer), 5);
 110   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), 8 - 5);
 111   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
 112           (&writer)), 0);
 113   fail_if (gst_byte_reader_get_uint8 (GST_BYTE_READER (&writer), &b));
 114   fail_unless (gst_byte_writer_put_uint24_be (&writer, 0xabcdef));
 115   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 8);
 116   fail_unless_equals_int (gst_byte_writer_get_size (&writer), 8);
 117   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), 8 - 8);
 118   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
 119           (&writer)), 0);
 120   fail_if (gst_byte_writer_put_uint8 (&writer, 0x12));
 121   fail_unless (gst_byte_writer_set_pos (&writer, 0));
 122   fail_unless (gst_byte_reader_peek_uint64_be (GST_BYTE_READER (&writer), &l));
 123   fail_unless_equals_uint64 (l, G_GUINT64_CONSTANT (0x1234567890abcdef));
 124   fail_unless (gst_byte_writer_put_uint8 (&writer, 0xff));
 125   fail_unless (gst_byte_writer_set_pos (&writer, 0));
 126   fail_unless (gst_byte_reader_get_uint64_be (GST_BYTE_READER (&writer), &l));
 127   fail_unless_equals_uint64 (l, G_GUINT64_CONSTANT (0xff34567890abcdef));
 128   fail_if (gst_byte_writer_put_uint64_be (&writer,
 129           G_GUINT64_CONSTANT (0x1234567890abcdef)));
 130
 131   data = gst_byte_writer_reset_and_get_data (&writer);
 132   fail_unless (data != NULL);
 133   fail_unless (memcmp (&end_data, data, 8) == 0);
 134   g_free (data);
 135 }
 136
 137 GST_END_TEST;
 138
 139 GST_START_TEST (test_write_non_fixed)
 140 {
 141   GstByteWriter writer;
 142   guint64 end_data = G_GUINT64_CONSTANT (0xff34567890abcdef);
 143   guint8 *data;
 144   guint64 l = 0;
 145
 146   end_data = GUINT64_TO_BE (end_data);
 147
 148   gst_byte_writer_init_with_size (&writer, 6, FALSE);
 149   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), -1);
 150
 151   fail_unless (gst_byte_writer_put_uint8 (&writer, 0x12));
 152   fail_unless (gst_byte_writer_put_uint16_be (&writer, 0x3456));
 153   fail_unless (gst_byte_writer_put_uint16_le (&writer, 0x9078));
 154   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 5);
 155   fail_unless_equals_int (gst_byte_writer_get_size (&writer), 5);
 156   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), -1);
 157   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
 158           (&writer)), 0);
 159   fail_unless (gst_byte_writer_put_uint24_be (&writer, 0xabcdef));
 160   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 8);
 161   fail_unless_equals_int (gst_byte_writer_get_size (&writer), 8);
 162   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), -1);
 163   fail_unless_equals_int (gst_byte_reader_get_remaining (GST_BYTE_READER
 164           (&writer)), 0);
 165   fail_unless (gst_byte_writer_set_pos (&writer, 0));
 166   fail_unless (gst_byte_reader_peek_uint64_be (GST_BYTE_READER (&writer), &l));
 167   fail_unless_equals_uint64 (l, G_GUINT64_CONSTANT (0x1234567890abcdef));
 168   fail_unless (gst_byte_writer_put_uint8 (&writer, 0xff));
 169   fail_unless (gst_byte_writer_set_pos (&writer, 0));
 170   fail_unless (gst_byte_reader_get_uint64_be (GST_BYTE_READER (&writer), &l));
 171   fail_unless_equals_uint64 (l, G_GUINT64_CONSTANT (0xff34567890abcdef));
 172   fail_unless (gst_byte_writer_set_pos (&writer, 8));
 173   fail_unless (gst_byte_writer_put_uint64_be (&writer,
 174           G_GUINT64_CONSTANT (0x1234567890abcdef)));
 175
 176   data = gst_byte_writer_reset_and_get_data (&writer);
 177   fail_unless (data != NULL);
 178   fail_unless (memcmp (&end_data, data, 8) == 0);
 179   end_data = GUINT64_TO_BE (G_GUINT64_CONSTANT (0x1234567890abcdef));
 180   fail_unless (memcmp (&end_data, data + 8, 8) == 0);
 181   g_free (data);
 182 }
 183
 184 GST_END_TEST;
 185
 186 GST_START_TEST (test_from_data)
 187 {
 188   GstByteWriter writer;
 189   guint8 data[] = { 0x12, 0x34, 0x56, 0x78,
 190     0x90, 0xab, 0xcd, 0xef
 191   };
 192   guint8 *data2;
 193
 194   gst_byte_writer_init_with_data (&writer, data, sizeof (data), TRUE);
 195   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), 8);
 196   fail_unless (gst_byte_writer_put_uint8 (&writer, 0xff));
 197   fail_unless_equals_int (data[0], 0xff);
 198   fail_unless_equals_int (gst_byte_writer_get_remaining (&writer), 7);
 199   fail_unless_equals_int (gst_byte_writer_get_pos (&writer), 1);
 200   fail_if (gst_byte_writer_put_uint64_be (&writer,
 201           G_GUINT64_CONSTANT (0x1234567890abcdef)));
 202   data2 = gst_byte_writer_reset_and_get_data (&writer);
 203   fail_unless (data2 != NULL);
 204   fail_if (data2 == data);
 205   fail_unless (memcmp (data, data2, 8) == 0);
 206   g_free (data2);
 207 }
 208
 209 GST_END_TEST;
 210
 211 GST_START_TEST (test_put_data_strings)
 212 {
 213   GstByteWriter writer;
 214   guint8 data[] = { 0x12, 0x34, 0x56, 0x78,
 215     0x90, 0xab, 0xcd, 0xef
 216   };
 217   guint8 *data2;
 218
 219   gst_byte_writer_init (&writer);
 220   fail_unless (gst_byte_writer_put_data (&writer, data, 8));
 221   fail_unless (gst_byte_writer_put_string (&writer, "somerandomteststring"));
 222   fail_unless_equals_int (gst_byte_writer_get_pos (&writer),
 223       8 + sizeof ("somerandomteststring"));
 224
 225   data2 = gst_byte_writer_reset_and_get_data (&writer);
 226   fail_unless (data2 != NULL);
 227   fail_unless (memcmp (data2, data, 8) == 0);
 228   g_free (data2);
 229 }
 230
 231 GST_END_TEST;
 232
 233 GST_START_TEST (test_fill)
 234 {
 235   GstByteWriter writer;
 236   guint8 data[] = { 0x0, 0x0, 0x0, 0x0, 0x5, 0x5 };
 237   guint8 *data2;
 238
 239   gst_byte_writer_init (&writer);
 240   fail_unless (gst_byte_writer_fill (&writer, 0, 4));
 241   fail_unless (gst_byte_writer_fill (&writer, 5, 2));
 242
 243   data2 = gst_byte_writer_reset_and_get_data (&writer);
 244   fail_unless (data2 != NULL);
 245   fail_unless (memcmp (data2, data, 6) == 0);
 246   g_free (data2);
 247 }
 248
 249 GST_END_TEST;
 250 static Suite *
 251 gst_byte_writer_suite (void)
 252 {
 253   Suite *s = suite_create ("GstByteWriter");
 254   TCase *tc_chain = tcase_create ("general");
 255
 256   suite_add_tcase (s, tc_chain);
 257
 258   tcase_add_test (tc_chain, test_initialization);
 259   tcase_add_test (tc_chain, test_write_fixed);
 260   tcase_add_test (tc_chain, test_write_non_fixed);
 261   tcase_add_test (tc_chain, test_from_data);
 262   tcase_add_test (tc_chain, test_put_data_strings);
 263   tcase_add_test (tc_chain, test_fill);
 264
 265   return s;
 266 }
 267
 268
 269 GST_CHECK_MAIN (gst_byte_writer);