tests/check/libs/bytereader.c

   1 /* GStreamer
   2  *
   3  * unit test for GstByteReader
   4  *
   5  * Copyright (C) <2008> 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/gstbytereader.h>
  30
  31 #ifndef fail_unless_equals_int64
  32 #define fail_unless_equals_int64(a, b)                                  \
  33 G_STMT_START {                                                          \
  34   gint64 first = a;                                                     \
  35   gint64 second = b;                                                    \
  36   fail_unless(first == second,                                          \
  37     "'" #a "' (%" G_GINT64_FORMAT ") is not equal to '" #b"' (%"        \
  38     G_GINT64_FORMAT ")", first, second);                                \
  39 } G_STMT_END;
  40 #endif
  41
  42 GST_START_TEST (test_initialization)
  43 {
  44   guint8 data[] = { 0x01, 0x02, 0x03, 0x04 };
  45   GstBuffer *buffer = gst_buffer_new ();
  46   GstByteReader reader = GST_BYTE_READER_INIT (data, 4);
  47   GstByteReader *reader2;
  48   guint8 x = 0;
  49   guint8 *bdata;
  50   gsize bsize;
  51
  52   gst_buffer_take_memory (buffer, -1,
  53       gst_memory_new_wrapped (GST_MEMORY_FLAG_READONLY, data, NULL, 4, 0, 4));
  54
  55   fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
  56   fail_unless_equals_int (x, 0x01);
  57   fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
  58   fail_unless_equals_int (x, 0x02);
  59
  60   memset (&reader, 0, sizeof (GstByteReader));
  61
  62   gst_byte_reader_init (&reader, data, 4);
  63   fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
  64   fail_unless_equals_int (x, 0x01);
  65   fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
  66   fail_unless_equals_int (x, 0x02);
  67
  68   bdata = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_READ);
  69   gst_byte_reader_init (&reader, bdata, bsize);
  70   fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
  71   fail_unless_equals_int (x, 0x01);
  72   fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
  73   fail_unless_equals_int (x, 0x02);
  74   gst_buffer_unmap (buffer, bdata, bsize);
  75
  76   reader2 = gst_byte_reader_new (data, 4);
  77   fail_unless (gst_byte_reader_get_uint8 (reader2, &x));
  78   fail_unless_equals_int (x, 0x01);
  79   fail_unless (gst_byte_reader_get_uint8 (reader2, &x));
  80   fail_unless_equals_int (x, 0x02);
  81   gst_byte_reader_free (reader2);
  82
  83   bdata = gst_buffer_map (buffer, &bsize, NULL, GST_MAP_READ);
  84   reader2 = gst_byte_reader_new (bdata, bsize);
  85   fail_unless (gst_byte_reader_get_uint8 (reader2, &x));
  86   fail_unless_equals_int (x, 0x01);
  87   fail_unless (gst_byte_reader_get_uint8 (reader2, &x));
  88   fail_unless_equals_int (x, 0x02);
  89   gst_byte_reader_free (reader2);
  90   gst_buffer_unmap (buffer, bdata, bsize);
  91
  92   gst_buffer_unref (buffer);
  93 }
  94
  95 GST_END_TEST;
  96
  97 #define GET_CHECK8(reader, dest, val) { \
  98   fail_unless (gst_byte_reader_get_uint8 (reader, &dest)); \
  99   fail_unless_equals_uint64 (dest, val); \
 100 }
 101
 102 #define GET_CHECK(reader, dest, bits, endianness, val) { \
 103   fail_unless (gst_byte_reader_get_uint##bits##_##endianness (reader, &dest)); \
 104   fail_unless_equals_uint64 (dest, val); \
 105 }
 106
 107 #define GET_CHECK_FAIL8(reader, dest) { \
 108   fail_if (gst_byte_reader_get_uint8 (reader, &dest)); \
 109 }
 110
 111 #define GET_CHECK_FAIL(reader, dest, bits, endianness) { \
 112   fail_if (gst_byte_reader_get_uint##bits##_##endianness (reader, &dest)); \
 113 }
 114
 115 #define PEEK_CHECK8(reader, dest, val) { \
 116   fail_unless (gst_byte_reader_peek_uint8 (reader, &dest)); \
 117   fail_unless_equals_uint64 (dest, val); \
 118 }
 119
 120 #define PEEK_CHECK(reader, dest, bits, endianness, val) { \
 121   fail_unless (gst_byte_reader_peek_uint##bits##_##endianness (reader, &dest)); \
 122   fail_unless_equals_uint64 (dest, val); \
 123 }
 124
 125 #define PEEK_CHECK_FAIL8(reader, dest) { \
 126   fail_if (gst_byte_reader_peek_uint8 (reader, &dest)); \
 127 }
 128
 129 #define PEEK_CHECK_FAIL(reader, dest, bits, endianness) { \
 130   fail_if (gst_byte_reader_peek_uint##bits##_##endianness (reader, &dest)); \
 131 }
 132
 133 GST_START_TEST (test_get_uint_le)
 134 {
 135   guint8 data[] = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
 136     0xfe, 0xdc, 0xba, 0x09, 0x87, 0x65, 0x43, 0x21
 137   };
 138   GstByteReader reader = GST_BYTE_READER_INIT (data, 16);
 139   guint8 a = 0;
 140   guint16 b = 0;
 141   guint32 c = 0;
 142   guint64 d = 0;
 143
 144   GET_CHECK8 (&reader, a, 0x12);
 145   GET_CHECK (&reader, b, 16, le, 0x5634);
 146   GET_CHECK (&reader, c, 24, le, 0xab9078);
 147   GET_CHECK (&reader, c, 32, le, 0xdcfeefcd);
 148   fail_unless (gst_byte_reader_set_pos (&reader, 0));
 149   GET_CHECK (&reader, d, 64, le, G_GINT64_CONSTANT (0xefcdab9078563412));
 150   GET_CHECK (&reader, d, 64, le, G_GINT64_CONSTANT (0x2143658709badcfe));
 151
 152   GET_CHECK_FAIL8 (&reader, a);
 153   GET_CHECK_FAIL (&reader, b, 16, le);
 154   GET_CHECK_FAIL (&reader, c, 24, le);
 155   GET_CHECK_FAIL (&reader, c, 32, le);
 156   GET_CHECK_FAIL (&reader, d, 64, le);
 157
 158   fail_unless (gst_byte_reader_set_pos (&reader, 0));
 159
 160   PEEK_CHECK8 (&reader, a, 0x12);
 161   PEEK_CHECK (&reader, b, 16, le, 0x3412);
 162   PEEK_CHECK (&reader, c, 24, le, 0x563412);
 163   PEEK_CHECK (&reader, c, 32, le, 0x78563412);
 164   PEEK_CHECK (&reader, d, 64, le, G_GINT64_CONSTANT (0xefcdab9078563412));
 165
 166   fail_unless (gst_byte_reader_set_pos (&reader, 16));
 167   PEEK_CHECK_FAIL8 (&reader, a);
 168   PEEK_CHECK_FAIL (&reader, b, 16, le);
 169   PEEK_CHECK_FAIL (&reader, c, 24, le);
 170   PEEK_CHECK_FAIL (&reader, c, 32, le);
 171   PEEK_CHECK_FAIL (&reader, d, 64, le);
 172 }
 173
 174 GST_END_TEST;
 175
 176 GST_START_TEST (test_get_uint_be)
 177 {
 178   guint8 data[] = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
 179     0xfe, 0xdc, 0xba, 0x09, 0x87, 0x65, 0x43, 0x21
 180   };
 181   GstByteReader reader = GST_BYTE_READER_INIT (data, 16);
 182   guint8 a = 0;
 183   guint16 b = 0;
 184   guint32 c = 0;
 185   guint64 d = 0;
 186
 187   GET_CHECK8 (&reader, a, 0x12);
 188   GET_CHECK (&reader, b, 16, be, 0x3456);
 189   GET_CHECK (&reader, c, 24, be, 0x7890ab);
 190   GET_CHECK (&reader, c, 32, be, 0xcdeffedc);
 191   fail_unless (gst_byte_reader_set_pos (&reader, 0));
 192   GET_CHECK (&reader, d, 64, be, G_GINT64_CONSTANT (0x1234567890abcdef));
 193   GET_CHECK (&reader, d, 64, be, G_GINT64_CONSTANT (0xfedcba0987654321));
 194
 195   GET_CHECK_FAIL8 (&reader, a);
 196   GET_CHECK_FAIL (&reader, b, 16, be);
 197   GET_CHECK_FAIL (&reader, c, 24, be);
 198   GET_CHECK_FAIL (&reader, c, 32, be);
 199   GET_CHECK_FAIL (&reader, d, 64, be);
 200
 201   fail_unless (gst_byte_reader_set_pos (&reader, 0));
 202
 203   PEEK_CHECK8 (&reader, a, 0x12);
 204   PEEK_CHECK (&reader, b, 16, be, 0x1234);
 205   PEEK_CHECK (&reader, c, 24, be, 0x123456);
 206   PEEK_CHECK (&reader, c, 32, be, 0x12345678);
 207   PEEK_CHECK (&reader, d, 64, be, G_GINT64_CONSTANT (0x1234567890abcdef));
 208
 209   fail_unless (gst_byte_reader_set_pos (&reader, 16));
 210   PEEK_CHECK_FAIL8 (&reader, a);
 211   PEEK_CHECK_FAIL (&reader, b, 16, be);
 212   PEEK_CHECK_FAIL (&reader, c, 24, be);
 213   PEEK_CHECK_FAIL (&reader, c, 32, be);
 214   PEEK_CHECK_FAIL (&reader, d, 64, be);
 215 }
 216
 217 GST_END_TEST;
 218
 219 #undef GET_CHECK8
 220 #undef GET_CHECK
 221 #undef PEEK_CHECK8
 222 #undef PEEK_CHECK
 223 #undef GET_CHECK_FAIL8
 224 #undef GET_CHECK_FAIL
 225 #undef PEEK_CHECK_FAIL8
 226 #undef PEEK_CHECK_FAIL
 227
 228 #define GET_CHECK8(reader, dest, val) { \
 229   fail_unless (gst_byte_reader_get_int8 (reader, &dest)); \
 230   fail_unless_equals_int64 (dest, val); \
 231 }
 232
 233 #define GET_CHECK(reader, dest, bits, endianness, val) { \
 234   fail_unless (gst_byte_reader_get_int##bits##_##endianness (reader, &dest)); \
 235   fail_unless_equals_int64 (dest, val); \
 236 }
 237
 238 #define GET_CHECK_FAIL8(reader, dest) { \
 239   fail_if (gst_byte_reader_get_int8 (reader, &dest)); \
 240 }
 241
 242 #define GET_CHECK_FAIL(reader, dest, bits, endianness) { \
 243   fail_if (gst_byte_reader_get_int##bits##_##endianness (reader, &dest)); \
 244 }
 245
 246 #define PEEK_CHECK8(reader, dest, val) { \
 247   fail_unless (gst_byte_reader_peek_int8 (reader, &dest)); \
 248   fail_unless_equals_int64 (dest, val); \
 249 }
 250
 251 #define PEEK_CHECK(reader, dest, bits, endianness, val) { \
 252   fail_unless (gst_byte_reader_peek_int##bits##_##endianness (reader, &dest)); \
 253   fail_unless_equals_int64 (dest, val); \
 254 }
 255
 256 #define PEEK_CHECK_FAIL8(reader, dest) { \
 257   fail_if (gst_byte_reader_peek_int8 (reader, &dest)); \
 258 }
 259
 260 #define PEEK_CHECK_FAIL(reader, dest, bits, endianness) { \
 261   fail_if (gst_byte_reader_peek_int##bits##_##endianness (reader, &dest)); \
 262 }
 263
 264 GST_START_TEST (test_get_int_le)
 265 {
 266   guint8 data[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 267     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 268   };
 269   GstByteReader reader = GST_BYTE_READER_INIT (data, 16);
 270   gint8 a = 0;
 271   gint16 b = 0;
 272   gint32 c = 0;
 273   gint64 d = 0;
 274
 275   GET_CHECK8 (&reader, a, -1);
 276   GET_CHECK (&reader, b, 16, le, -1);
 277   GET_CHECK (&reader, c, 24, le, -1);
 278   GET_CHECK (&reader, c, 32, le, -1);
 279   fail_unless (gst_byte_reader_set_pos (&reader, 0));
 280   GET_CHECK (&reader, d, 64, le, G_GINT64_CONSTANT (-1));
 281   GET_CHECK (&reader, d, 64, le, G_GINT64_CONSTANT (-1));
 282
 283   GET_CHECK_FAIL8 (&reader, a);
 284   GET_CHECK_FAIL (&reader, b, 16, le);
 285   GET_CHECK_FAIL (&reader, c, 24, le);
 286   GET_CHECK_FAIL (&reader, c, 32, le);
 287   GET_CHECK_FAIL (&reader, d, 64, le);
 288
 289   fail_unless (gst_byte_reader_set_pos (&reader, 0));
 290
 291   PEEK_CHECK8 (&reader, a, -1);
 292   PEEK_CHECK (&reader, b, 16, le, -1);
 293   PEEK_CHECK (&reader, c, 24, le, -1);
 294   PEEK_CHECK (&reader, c, 32, le, -1);
 295   PEEK_CHECK (&reader, d, 64, le, G_GINT64_CONSTANT (-1));
 296
 297   fail_unless (gst_byte_reader_set_pos (&reader, 16));
 298   PEEK_CHECK_FAIL8 (&reader, a);
 299   PEEK_CHECK_FAIL (&reader, b, 16, le);
 300   PEEK_CHECK_FAIL (&reader, c, 24, le);
 301   PEEK_CHECK_FAIL (&reader, c, 32, le);
 302   PEEK_CHECK_FAIL (&reader, d, 64, le);
 303
 304 }
 305
 306 GST_END_TEST;
 307
 308 GST_START_TEST (test_get_int_be)
 309 {
 310   guint8 data[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 311     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 312   };
 313   GstByteReader reader = GST_BYTE_READER_INIT (data, 16);
 314   gint8 a = 0;
 315   gint16 b = 0;
 316   gint32 c = 0;
 317   gint64 d = 0;
 318
 319   GET_CHECK8 (&reader, a, -1);
 320   GET_CHECK (&reader, b, 16, be, -1);
 321   GET_CHECK (&reader, c, 24, be, -1);
 322   GET_CHECK (&reader, c, 32, be, -1);
 323   fail_unless (gst_byte_reader_set_pos (&reader, 0));
 324   GET_CHECK (&reader, d, 64, be, G_GINT64_CONSTANT (-1));
 325   GET_CHECK (&reader, d, 64, be, G_GINT64_CONSTANT (-1));
 326
 327   GET_CHECK_FAIL8 (&reader, a);
 328   GET_CHECK_FAIL (&reader, b, 16, be);
 329   GET_CHECK_FAIL (&reader, c, 24, be);
 330   GET_CHECK_FAIL (&reader, c, 32, be);
 331   GET_CHECK_FAIL (&reader, d, 64, be);
 332
 333   fail_unless (gst_byte_reader_set_pos (&reader, 0));
 334
 335   PEEK_CHECK8 (&reader, a, -1);
 336   PEEK_CHECK (&reader, b, 16, be, -1);
 337   PEEK_CHECK (&reader, c, 24, be, -1);
 338   PEEK_CHECK (&reader, c, 32, be, -1);
 339   PEEK_CHECK (&reader, d, 64, be, G_GINT64_CONSTANT (-1));
 340
 341   fail_unless (gst_byte_reader_set_pos (&reader, 16));
 342   PEEK_CHECK_FAIL8 (&reader, a);
 343   PEEK_CHECK_FAIL (&reader, b, 16, be);
 344   PEEK_CHECK_FAIL (&reader, c, 24, be);
 345   PEEK_CHECK_FAIL (&reader, c, 32, be);
 346   PEEK_CHECK_FAIL (&reader, d, 64, be);
 347
 348 }
 349
 350 GST_END_TEST;
 351
 352 #undef GET_CHECK8
 353 #undef GET_CHECK
 354 #undef PEEK_CHECK8
 355 #undef PEEK_CHECK
 356 #undef GET_CHECK_FAIL8
 357 #undef GET_CHECK_FAIL
 358 #undef PEEK_CHECK_FAIL8
 359 #undef PEEK_CHECK_FAIL
 360
 361 #define GET_CHECK(reader, dest, bits, endianness, val) { \
 362   fail_unless (gst_byte_reader_get_float##bits##_##endianness (reader, &dest)); \
 363   fail_unless_equals_float (dest, val); \
 364 }
 365
 366 #define GET_CHECK_FAIL(reader, dest, bits, endianness) { \
 367   fail_if (gst_byte_reader_get_float##bits##_##endianness (reader, &dest)); \
 368 }
 369
 370 #define PEEK_CHECK(reader, dest, bits, endianness, val) { \
 371   fail_unless (gst_byte_reader_peek_float##bits##_##endianness (reader, &dest)); \
 372   fail_unless_equals_float (dest, val); \
 373 }
 374
 375 #define PEEK_CHECK_FAIL(reader, dest, bits, endianness) { \
 376   fail_if (gst_byte_reader_peek_float##bits##_##endianness (reader, &dest)); \
 377 }
 378
 379 GST_START_TEST (test_get_float_le)
 380 {
 381   guint8 data[] = {
 382     0x00, 0x00, 0x80, 0x3f,
 383     0x00, 0x00, 0x80, 0xbf,
 384     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f,
 385     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xbf,
 386   };
 387   GstByteReader reader = GST_BYTE_READER_INIT (data, 24);
 388   gfloat a = 0.0;
 389   gdouble b = 0.0;
 390
 391   PEEK_CHECK (&reader, a, 32, le, 1.0);
 392   GET_CHECK (&reader, a, 32, le, 1.0);
 393   GET_CHECK (&reader, a, 32, le, -1.0);
 394   PEEK_CHECK (&reader, b, 64, le, 1.0);
 395   GET_CHECK (&reader, b, 64, le, 1.0);
 396   GET_CHECK (&reader, b, 64, le, -1.0);
 397   GET_CHECK_FAIL (&reader, a, 32, le);
 398   GET_CHECK_FAIL (&reader, b, 64, le);
 399   PEEK_CHECK_FAIL (&reader, a, 32, le);
 400   PEEK_CHECK_FAIL (&reader, b, 64, le);
 401 }
 402
 403 GST_END_TEST;
 404
 405 GST_START_TEST (test_get_float_be)
 406 {
 407   guint8 data[] = {
 408     0x3f, 0x80, 0x00, 0x00,
 409     0xbf, 0x80, 0x00, 0x00,
 410     0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 411     0xbf, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 412   };
 413   GstByteReader reader = GST_BYTE_READER_INIT (data, 24);
 414   gfloat a = 0.0;
 415   gdouble b = 0.0;
 416
 417   PEEK_CHECK (&reader, a, 32, be, 1.0);
 418   GET_CHECK (&reader, a, 32, be, 1.0);
 419   GET_CHECK (&reader, a, 32, be, -1.0);
 420   PEEK_CHECK (&reader, b, 64, be, 1.0);
 421   GET_CHECK (&reader, b, 64, be, 1.0);
 422   GET_CHECK (&reader, b, 64, be, -1.0);
 423   GET_CHECK_FAIL (&reader, a, 32, be);
 424   GET_CHECK_FAIL (&reader, b, 64, be);
 425   PEEK_CHECK_FAIL (&reader, a, 32, be);
 426   PEEK_CHECK_FAIL (&reader, b, 64, be);
 427 }
 428
 429 GST_END_TEST;
 430
 431 #undef GET_CHECK
 432 #undef PEEK_CHECK
 433 #undef GET_CHECK_FAIL
 434 #undef PEEK_CHECK_FAIL
 435
 436 GST_START_TEST (test_position_tracking)
 437 {
 438   guint8 data[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 439     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 440   };
 441   GstByteReader reader = GST_BYTE_READER_INIT (data, 16);
 442   guint8 a = 0;
 443
 444   fail_unless_equals_int (gst_byte_reader_get_pos (&reader), 0);
 445   fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 16);
 446
 447   fail_unless (gst_byte_reader_get_uint8 (&reader, &a));
 448   fail_unless_equals_int (gst_byte_reader_get_pos (&reader), 1);
 449   fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 16 - 1);
 450
 451   fail_unless (gst_byte_reader_set_pos (&reader, 8));
 452   fail_unless_equals_int (gst_byte_reader_get_pos (&reader), 8);
 453   fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 16 - 8);
 454
 455   fail_unless (gst_byte_reader_skip (&reader, 4));
 456   fail_unless_equals_int (gst_byte_reader_get_pos (&reader), 12);
 457   fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 16 - 12);
 458
 459   fail_unless (gst_byte_reader_set_pos (&reader, 16));
 460   fail_unless_equals_int (gst_byte_reader_get_pos (&reader), 16);
 461   fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 0);
 462
 463   fail_unless (gst_byte_reader_skip (&reader, 0));
 464   fail_if (gst_byte_reader_skip (&reader, 1));
 465 }
 466
 467 GST_END_TEST;
 468
 469 #define do_scan(r,m,p,o,s,x) \
 470     fail_unless_equals_int (gst_byte_reader_masked_scan_uint32 (r,m,p,o,s), x);
 471
 472 GST_START_TEST (test_scan)
 473 {
 474   GstByteReader reader;
 475   guint8 data[200];
 476   guint i;
 477
 478   /* fill half the buffer with a pattern */
 479   for (i = 0; i < 100; i++)
 480     data[i] = i;
 481
 482   gst_byte_reader_init (&reader, data, 100);
 483
 484   /* find first bytes */
 485   do_scan (&reader, 0xffffffff, 0x00010203, 0, 100, 0);
 486   do_scan (&reader, 0xffffffff, 0x01020304, 0, 100, 1);
 487   do_scan (&reader, 0xffffffff, 0x01020304, 1, 99, 1);
 488   /* offset is past the pattern start */
 489   do_scan (&reader, 0xffffffff, 0x01020304, 2, 98, -1);
 490   /* not enough bytes to find the pattern */
 491   do_scan (&reader, 0xffffffff, 0x02030405, 2, 3, -1);
 492   do_scan (&reader, 0xffffffff, 0x02030405, 2, 4, 2);
 493   /* size does not include the last scanned byte */
 494   do_scan (&reader, 0xffffffff, 0x40414243, 0, 0x41, -1);
 495   do_scan (&reader, 0xffffffff, 0x40414243, 0, 0x43, -1);
 496   do_scan (&reader, 0xffffffff, 0x40414243, 0, 0x44, 0x40);
 497   /* past the start */
 498   do_scan (&reader, 0xffffffff, 0x40414243, 65, 10, -1);
 499   do_scan (&reader, 0xffffffff, 0x40414243, 64, 5, 64);
 500   do_scan (&reader, 0xffffffff, 0x60616263, 65, 35, 0x60);
 501   do_scan (&reader, 0xffffffff, 0x60616263, 0x60, 4, 0x60);
 502   /* past the start */
 503   do_scan (&reader, 0xffffffff, 0x60616263, 0x61, 3, -1);
 504   do_scan (&reader, 0xffffffff, 0x60616263, 99, 1, -1);
 505
 506   /* add more data to the buffer */
 507   for (i = 100; i < 200; i++)
 508     data[i] = i;
 509   gst_byte_reader_init (&reader, data, 200);
 510
 511   /* past the start */
 512   do_scan (&reader, 0xffffffff, 0x60616263, 0x61, 6, -1);
 513   /* this should work */
 514   do_scan (&reader, 0xffffffff, 0x61626364, 0x61, 4, 0x61);
 515   /* not enough data */
 516   do_scan (&reader, 0xffffffff, 0x62636465, 0x61, 4, -1);
 517   do_scan (&reader, 0xffffffff, 0x62636465, 0x61, 5, 0x62);
 518   do_scan (&reader, 0xffffffff, 0x62636465, 0, 120, 0x62);
 519
 520   /* border conditions */
 521   do_scan (&reader, 0xffffffff, 0x62636465, 0, 200, 0x62);
 522   do_scan (&reader, 0xffffffff, 0x63646566, 0, 200, 0x63);
 523   /* we completely searched the first list */
 524   do_scan (&reader, 0xffffffff, 0x64656667, 0, 200, 0x64);
 525   /* skip first buffer */
 526   do_scan (&reader, 0xffffffff, 0x64656667, 0x64, 100, 0x64);
 527   /* past the start */
 528   do_scan (&reader, 0xffffffff, 0x64656667, 0x65, 10, -1);
 529   /* not enough data to scan */
 530   do_scan (&reader, 0xffffffff, 0x64656667, 0x63, 4, -1);
 531   do_scan (&reader, 0xffffffff, 0x64656667, 0x63, 5, 0x64);
 532   do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 0, 199, -1);
 533   do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 0x62, 102, 0xc4);
 534   /* different masks */
 535   do_scan (&reader, 0x00ffffff, 0x00656667, 0x64, 100, 0x64);
 536   do_scan (&reader, 0x000000ff, 0x00000000, 0, 100, -1);
 537   do_scan (&reader, 0x000000ff, 0x00000003, 0, 100, 0);
 538   do_scan (&reader, 0x000000ff, 0x00000061, 0x61, 100, -1);
 539   do_scan (&reader, 0xff000000, 0x61000000, 0, 0x62, -1);
 540   /* does not even exist */
 541   do_scan (&reader, 0x00ffffff, 0xffffffff, 0x65, 99, -1);
 542
 543   /* flush some bytes */
 544   fail_unless (gst_byte_reader_skip (&reader, 0x20));
 545
 546   do_scan (&reader, 0xffffffff, 0x20212223, 0, 100, 0);
 547   do_scan (&reader, 0xffffffff, 0x20212223, 0, 4, 0);
 548   do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 0x62, 70, 0xa4);
 549   do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 0, 168, 0xa4);
 550
 551   do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 164, 4, 0xa4);
 552   do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 0x44, 100, 0xa4);
 553
 554   /* not enough bytes */
 555   do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 0x44, 99, -1);
 556 }
 557
 558 GST_END_TEST;
 559
 560 GST_START_TEST (test_string_funcs)
 561 {
 562   GstByteReader reader, backup;
 563   const gchar *s8;
 564   guint32 *c32;
 565   guint16 *c16;
 566   gchar *c8;
 567   guint8 data[200], *d = 0;
 568   guint i;
 569
 570   /* fill half the buffer with a pattern */
 571   for (i = 0; i < 100; i++)
 572     data[i] = i + 1;
 573
 574   gst_byte_reader_init (&reader, data, 100);
 575
 576   /* no NUL terminator, so these should all fail */
 577   fail_if (gst_byte_reader_get_string (&reader, &s8));
 578   fail_if (gst_byte_reader_get_string_utf8 (&reader, &s8));
 579   fail_if (gst_byte_reader_dup_string (&reader, &c8));
 580   fail_if (gst_byte_reader_dup_string_utf8 (&reader, &c8));
 581   fail_if (gst_byte_reader_skip_string (&reader));
 582   fail_if (gst_byte_reader_skip_string_utf8 (&reader));
 583   fail_if (gst_byte_reader_skip_string_utf16 (&reader));
 584   fail_if (gst_byte_reader_skip_string_utf32 (&reader));
 585   fail_if (gst_byte_reader_peek_string (&reader, &s8));
 586   fail_if (gst_byte_reader_peek_string_utf8 (&reader, &s8));
 587   fail_if (gst_byte_reader_dup_string_utf16 (&reader, &c16));
 588   fail_if (gst_byte_reader_dup_string_utf32 (&reader, &c32));
 589
 590   /* let's add a single NUL terminator */
 591   data[80] = '\0';
 592   backup = reader;
 593   fail_if (gst_byte_reader_skip_string_utf32 (&reader));
 594   fail_if (gst_byte_reader_skip_string_utf16 (&reader));
 595   fail_if (gst_byte_reader_dup_string_utf16 (&reader, &c16));
 596   fail_if (gst_byte_reader_dup_string_utf32 (&reader, &c32));
 597   fail_unless (gst_byte_reader_skip_string (&reader));
 598   reader = backup;
 599   fail_unless (gst_byte_reader_skip_string_utf8 (&reader));
 600   reader = backup;
 601   fail_unless (gst_byte_reader_peek_string (&reader, &s8));
 602   fail_unless (gst_byte_reader_peek_string_utf8 (&reader, &s8));
 603   fail_if (gst_byte_reader_dup_string_utf16 (&reader, &c16));
 604   fail_if (gst_byte_reader_dup_string_utf32 (&reader, &c32));
 605
 606   /* let's add another NUL terminator */
 607   data[81] = '\0';
 608   reader = backup;
 609   fail_if (gst_byte_reader_skip_string_utf32 (&reader));
 610   fail_if (gst_byte_reader_dup_string_utf32 (&reader, &c32));
 611   fail_unless (gst_byte_reader_skip_string_utf16 (&reader));
 612   reader = backup;
 613   fail_unless (gst_byte_reader_dup_string_utf16 (&reader, &c16));
 614   g_free (c16);
 615   reader = backup;
 616   fail_unless (gst_byte_reader_skip_string (&reader));
 617   reader = backup;
 618   fail_unless (gst_byte_reader_skip_string_utf8 (&reader));
 619   reader = backup;
 620   fail_unless (gst_byte_reader_peek_string (&reader, &s8));
 621   fail_unless (gst_byte_reader_peek_string_utf8 (&reader, &s8));
 622   fail_if (gst_byte_reader_dup_string_utf32 (&reader, &c32));
 623
 624   /* two more NUL terminators */
 625   data[79] = '\0';
 626   data[82] = '\0';
 627   reader = backup;
 628   /* we're at pos. 80 now, so have only 3 NUL terminators in front of us */
 629   fail_if (gst_byte_reader_skip_string_utf32 (&reader));
 630   /* let's rewind */
 631   gst_byte_reader_init (&reader, data, 100);
 632   backup = reader;
 633   /* oops, 79 is not dividable by 4, so not aligned, so should fail as well! */
 634   fail_if (gst_byte_reader_skip_string_utf32 (&reader));
 635   /* let's try that again */
 636   data[83] = '\0';
 637   gst_byte_reader_init (&reader, data, 100);
 638   backup = reader;
 639   fail_unless (gst_byte_reader_skip_string_utf16 (&reader));
 640   reader = backup;
 641   fail_unless (gst_byte_reader_skip_string (&reader));
 642   reader = backup;
 643   fail_unless (gst_byte_reader_skip_string_utf8 (&reader));
 644   reader = backup;
 645   fail_unless (gst_byte_reader_peek_string (&reader, &s8));
 646   fail_unless (gst_byte_reader_peek_string_utf8 (&reader, &s8));
 647   fail_unless (gst_byte_reader_dup_string_utf16 (&reader, &c16));
 648   g_free (c16);
 649   reader = backup;
 650   fail_unless (gst_byte_reader_dup_string_utf32 (&reader, &c32));
 651   g_free (c32);
 652
 653   /* and again from the start */
 654   gst_byte_reader_init (&reader, data, 100);
 655   fail_unless (gst_byte_reader_skip_string_utf16 (&reader));
 656   fail_if (gst_byte_reader_dup_data (&reader, 200, &d));
 657   fail_if (gst_byte_reader_dup_data (&reader, 100, &d));
 658   fail_if (gst_byte_reader_dup_data (&reader, 20, &d));
 659   fail_unless (gst_byte_reader_dup_data (&reader, 10, &d));
 660   fail_unless_equals_int (d[0], 0);
 661   fail_unless_equals_int (d[1], 0);
 662   fail_unless_equals_int (d[2], 85);
 663   fail_unless_equals_int (d[3], 86);
 664   g_free (d);
 665 }
 666
 667 GST_END_TEST;
 668
 669 GST_START_TEST (test_dup_string)
 670 {
 671   const gchar moredata[] = { 0x99, 0x10, 'f', '0', '0', '!', '\0', 0xff };
 672   GstByteReader reader;
 673   guint16 num = 0;
 674   guint8 x = 0;
 675   gchar *s;
 676
 677   gst_byte_reader_init (&reader, (guint8 *) moredata, sizeof (moredata));
 678   fail_unless (gst_byte_reader_get_uint16_be (&reader, &num));
 679   fail_unless_equals_int (num, 0x9910);
 680   fail_unless (gst_byte_reader_dup_string (&reader, &s));
 681   fail_unless_equals_string (s, "f00!");
 682   fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
 683   fail_unless_equals_int (x, 0xff);
 684   g_free (s);
 685 }
 686
 687 GST_END_TEST;
 688
 689 static Suite *
 690 gst_byte_reader_suite (void)
 691 {
 692   Suite *s = suite_create ("GstByteReader");
 693   TCase *tc_chain = tcase_create ("general");
 694
 695   suite_add_tcase (s, tc_chain);
 696
 697   tcase_add_test (tc_chain, test_initialization);
 698   tcase_add_test (tc_chain, test_get_uint_le);
 699   tcase_add_test (tc_chain, test_get_uint_be);
 700   tcase_add_test (tc_chain, test_get_int_le);
 701   tcase_add_test (tc_chain, test_get_int_be);
 702   tcase_add_test (tc_chain, test_get_float_le);
 703   tcase_add_test (tc_chain, test_get_float_be);
 704   tcase_add_test (tc_chain, test_position_tracking);
 705   tcase_add_test (tc_chain, test_scan);
 706   tcase_add_test (tc_chain, test_string_funcs);
 707   tcase_add_test (tc_chain, test_dup_string);
 708
 709   return s;
 710 }
 711
 712
 713 GST_CHECK_MAIN (gst_byte_reader);