1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     3 *

     4 * This library is free software; you can redistribute it and/or

     5 * modify it under the terms of the GNU Lesser General Public

     6 * License as published by the Free Software Foundation; either

     7 * version 2 of the License, or (at your option) any later version.

     8 *

     9 * This library is distributed in the hope that it will be useful,

    10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12 * Lesser General Public License for more details.

    13 *

    14 * You should have received a copy of the GNU Lesser General Public

    15 * License along with this library; if not, write to the

    16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    17 * Boston, MA 02111-1307, USA.

    18 *

    19 * Description:

    20 *

    21 */

    22 

    23 /* GStreamer

    24  * Copyright (C) <2004> David Schleef <david at schleef dot org>

    25  * Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>

    26  *

    27  * gstvalue.c: Unit tests for GstValue

    28  *

    29  * This library is free software; you can redistribute it and/or

    30  * modify it under the terms of the GNU Library General Public

    31  * License as published by the Free Software Foundation; either

    32  * version 2 of the License, or (at your option) any later version.

    33  *

    34  * This library is distributed in the hope that it will be useful,

    35  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    36  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    37  * Library General Public License for more details.

    38  *

    39  * You should have received a copy of the GNU Library General Public

    40  * License along with this library; if not, write to the

    41  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    42  * Boston, MA 02111-1307, USA.

    43  */

    44 

    45 

    46 

    47 #include <gst/gst_global.h>

    48 #include <gst/check/gstcheck.h>

    49 

    50 #define LOG_FILE "c:\\logs\\gstvalue_logs.txt" 

    51 #include "std_log_result.h" 

    52 #define LOG_FILENAME_LINE __FILE__, __LINE__

    53 

    54 //char* xmlfile = "gstvalue";

    55 

    56 void create_xml(int result)

    57 {

    58     if(result)

    59         assert_failed = 1;

    60     

    61     testResultXml(xmlfile);

    62     close_log_file();

    63 }

    64 

    65 

    66 void test_deserialize_buffer()

    67 {

    68   GValue value = { 0 };

    69   GstBuffer *buf;

    70   

    71     xmlfile = "test_deserialize_buffer";

    72   std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_buffer");

    73 

    74 

    75   g_value_init (&value, GST_TYPE_BUFFER);

    76   fail_unless (gst_value_deserialize (&value, "1234567890abcdef"));

    77   

    78   /* does not increase the refcount */

    79   buf = GST_BUFFER (gst_value_get_mini_object (&value));

    80   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);

    81 

    82   /* does not increase the refcount */

    83   buf = gst_value_get_buffer (&value);

    84   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);

    85 

    86   /* cleanup */

    87   g_value_unset (&value);

    88     

    89     std_log(LOG_FILENAME_LINE, "Test Successful");

    90   create_xml(0);

    91 }

    92 

    93 

    94 

    95 /* create and serialize a buffer */

    96 void test_serialize_buffer()

    97 {

    98   GValue value = { 0 };

    99   GstBuffer *buf;

   100   gchar *serialized;

   101   static const char *buf_data = "1234567890abcdef";

   102   gint len;

   103   

   104     xmlfile = "test_serialize_buffer";

   105   std_log(LOG_FILENAME_LINE, "Test Started test_serialize_buffer");

   106 

   107 

   108   len = strlen (buf_data);

   109   buf = gst_buffer_new_and_alloc (len);

   110   memcpy (GST_BUFFER_DATA (buf), buf_data, len);

   111   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);

   112 

   113   /* and assign buffer to mini object */

   114   g_value_init (&value, GST_TYPE_BUFFER);

   115   gst_value_take_buffer (&value, buf);

   116   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);

   117 

   118   /* now serialize it */

   119   serialized = gst_value_serialize (&value);

   120   GST_DEBUG ("serialized buffer to %s", serialized);

   121   fail_unless (serialized != NULL);

   122   

   123 

   124   /* refcount should not change */

   125   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);

   126 

   127   /* cleanup */

   128   g_free (serialized);

   129   g_value_unset (&value);

   130 

   131   /* take NULL buffer */

   132   g_value_init (&value, GST_TYPE_BUFFER);

   133   GST_DEBUG ("setting NULL buffer");

   134   gst_value_take_buffer (&value, NULL);

   135 

   136   /* now serialize it */

   137   GST_DEBUG ("serializing NULL buffer");

   138   serialized = gst_value_serialize (&value);

   139   /* should return NULL */

   140   fail_unless (serialized == NULL);

   141   

   142 

   143   g_free (serialized);

   144   g_value_unset (&value);

   145   

   146     std_log(LOG_FILENAME_LINE, "Test Successful");

   147   create_xml(0);

   148 }

   149 

   150 

   151 

   152 void test_deserialize_gint()

   153 {

   154   GValue value = { 0 };

   155   const char *strings[] = {

   156     "123456",

   157     "-123456",

   158     "0xFFFF",

   159     "0x0000FFFF",

   160     /* a positive long long, serializing to highest possible positive sint */

   161     "0x7FFFFFFF",

   162     /* a positive long long, serializing to lowest possible negative sint */

   163     "0x80000000",

   164     /* a negative long long, serializing to lowest possible negative sint */

   165     "0xFFFFFFFF80000000",

   166     "0xFF000000",

   167     /* a positive long long serializing to -1 */

   168     "0xFFFFFFFF",

   169     "0xFFFFFFFF",

   170     /* a negative long long serializing to -1 */

   171     "0xFFFFFFFFFFFFFFFF",

   172     "0xFFFFFFFFFFFFFFFF",

   173     "0xEFFFFFFF",

   174   };

   175   /* some casts need to be explicit because of unsigned -> signed */

   176   gint results[] = {

   177     123456,

   178     -123456,

   179     0xFFFF,

   180     0xFFFF,

   181     0x7FFFFFFF,

   182     (gint) 0x80000000,

   183     (gint) 0x80000000,

   184     (gint) 0xFF000000,

   185     -1,

   186     (gint) 0xFFFFFFFF,

   187     -1,

   188     (gint) 0xFFFFFFFFFFFFFFFFLL,

   189     (gint) 0xEFFFFFFF,

   190   };

   191   int i;

   192   

   193     xmlfile = "test_deserialize_gint";

   194   std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_gint");

   195 

   196 

   197   g_value_init (&value, G_TYPE_INT);

   198 

   199   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {

   200     fail_unless (gst_value_deserialize (&value, strings[i]),

   201         "could not deserialize %s (%d)", strings[i], i);

   202         

   203     fail_unless (g_value_get_int (&value) == results[i],

   204         "resulting value is %d, not %d, for string %s (%d)",

   205         g_value_get_int (&value), results[i], strings[i], i);

   206         

   207   }

   208   

   209     std_log(LOG_FILENAME_LINE, "Test Successful");

   210   create_xml(0);

   211 }

   212 

   213 

   214 void test_deserialize_gint_failures()

   215 {

   216   GValue value = { 0 };

   217   const char *strings[] = {

   218     "-",                        /* not a complete number */

   219     "- TEST",                   /* not a complete number */

   220     "0x0000000100000000",       /* lowest long long that cannot fit in 32 bits */

   221     "0xF000000000000000",

   222     "0xFFFFFFF000000000",

   223     "0xFFFFFFFF00000000",

   224     "0x10000000000000000",      /* first number too long to fit into a long long */

   225     /* invent a new processor first before trying to make this one pass */

   226     "0x10000000000000000000000000000000000000000000",

   227   };

   228   int i;

   229   

   230     xmlfile = "test_deserialize_gint_failures";

   231   std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_gint_failures");

   232 

   233 

   234   g_value_init (&value, G_TYPE_INT);

   235 

   236   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {

   237     fail_if (gst_value_deserialize (&value, strings[i]),

   238         "deserialized %s (%d), while it should have failed", strings[i], i);

   239         

   240   }

   241   

   242     std_log(LOG_FILENAME_LINE, "Test Successful");

   243   create_xml(0);

   244 }

   245 

   246 void test_deserialize_guint()

   247 {

   248   GValue value = { 0 };

   249   const char *strings[] = {

   250     "123456",

   251     "-123456",

   252     "0xFFFF",

   253     "0x0000FFFF",

   254     /* a positive long long, serializing to highest possible positive sint */

   255     "0x7FFFFFFF",

   256     /* a positive long long, serializing to lowest possible negative sint */

   257     "0x80000000",

   258     "2147483648",

   259     /* a negative long long, serializing to lowest possible negative sint */

   260     "0xFFFFFFFF80000000",

   261     /* a value typically used for rgb masks */

   262     "0xFF000000",

   263     /* a positive long long serializing to highest possible positive uint */

   264     "0xFFFFFFFF",

   265     "0xFFFFFFFF",

   266     /* a negative long long serializing to highest possible positive uint */

   267     "0xFFFFFFFFFFFFFFFF",

   268     "0xEFFFFFFF",

   269   };

   270   guint results[] = {

   271     123456,

   272     (guint) - 123456,

   273     0xFFFF,

   274     0xFFFF,

   275     0x7FFFFFFF,

   276     0x80000000,

   277     (guint) 2147483648LL,

   278     0x80000000,

   279     0xFF000000,

   280     0xFFFFFFFF,

   281     G_MAXUINT,

   282     (guint) 0xFFFFFFFFFFFFFFFFLL,

   283     0xEFFFFFFF,

   284   };

   285   int i;

   286   

   287     xmlfile = "test_deserialize_guint";

   288   std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_guint");

   289 

   290 

   291   g_value_init (&value, G_TYPE_UINT);

   292 

   293   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {

   294     fail_unless (gst_value_deserialize (&value, strings[i]),

   295         "could not deserialize %s (%d)", strings[i], i);

   296         

   297     fail_unless (g_value_get_uint (&value) == results[i],

   298         "resulting value is %d, not %d, for string %s (%d)",

   299         g_value_get_uint (&value), results[i], strings[i], i);

   300         

   301   }

   302     std_log(LOG_FILENAME_LINE, "Test Successful");

   303   create_xml(0);

   304 }

   305 

   306 void test_deserialize_guint_failures()

   307 {

   308   GValue value = { 0 };

   309   const char *strings[] = {

   310     "-",                        /* not a complete number */

   311     "- TEST",                   /* not a complete number */

   312 #if 0

   313 /* FIXME: these values should not be deserializable, since they overflow

   314  * the target format */

   315     "0x0000000100000000",       /* lowest long long that cannot fit in 32 bits */

   316     "0xF000000000000000",

   317     "0xFFFFFFF000000000",

   318     "0xFFFFFFFF00000000",

   319     "0x10000000000000000",      /* first number too long to fit into a long long */

   320     /* invent a new processor first before trying to make this one pass */

   321     "0x10000000000000000000000000000000000000000000",

   322 #endif

   323   };

   324   int i;

   325   

   326     xmlfile = "test_deserialize_guint_failures";

   327   std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_guint_failures");

   328 

   329 

   330   g_value_init (&value, G_TYPE_UINT);

   331 

   332   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {

   333     fail_if (gst_value_deserialize (&value, strings[i]),

   334         "deserialized %s (%d), while it should have failed", strings[i], i);

   335         

   336   }

   337     std_log(LOG_FILENAME_LINE, "Test Successful");

   338   create_xml(0);

   339 }

   340 

   341 

   342 void test_deserialize_gint64()

   343 {

   344   GValue value = { 0 };

   345   const char *strings[] = {

   346     "12345678901",

   347     "-12345678901",

   348   };

   349   gint64 results[] = {

   350     12345678901LL,

   351     -12345678901LL,

   352   };

   353   int i;

   354   

   355     xmlfile = "test_deserialize_gint64";

   356   std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_gint64");

   357 

   358 

   359   g_value_init (&value, G_TYPE_INT64);

   360 

   361   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {

   362     fail_unless (gst_value_deserialize (&value, strings[i]),

   363         "could not deserialize %s (%d)", strings[i], i);

   364         

   365     fail_unless (g_value_get_int64 (&value) == results[i],

   366         "resulting value is %" G_GINT64_FORMAT ", not %" G_GINT64_FORMAT

   367         ", for string %s (%d)", g_value_get_int64 (&value),

   368         results[i], strings[i], i);

   369         

   370   }

   371   

   372     std_log(LOG_FILENAME_LINE, "Test Successful");

   373   create_xml(0);

   374 }

   375 

   376 

   377 

   378 

   379 

   380 void test_deserialize_gstfraction()

   381 {

   382   GValue value = { 0 };

   383   const char *strings[] = {

   384     "4/5",

   385     "-8/9"

   386   };

   387   gint64 result_numers[] = {

   388     4,

   389     -8

   390   };

   391   gint64 result_denoms[] = {

   392     5,

   393     9

   394   };

   395 

   396   int i;

   397   

   398     xmlfile = "test_deserialize_gstfraction";

   399   std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_gstfraction");

   400 

   401 

   402   g_value_init (&value, GST_TYPE_FRACTION);

   403   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {

   404     fail_unless (gst_value_deserialize (&value, strings[i]),

   405         "could not deserialize %s (%d)", strings[i], i);

   406         

   407     fail_unless (gst_value_get_fraction_numerator (&value) == result_numers[i],

   408         "resulting numerator value is %d, not %d"

   409         ", for string %s (%d)", gst_value_get_fraction_numerator (&value),

   410         result_numers[i], strings[i], i);

   411         

   412     fail_unless (gst_value_get_fraction_denominator (&value) ==

   413         result_denoms[i], "resulting denominator value is %d, not %d"

   414         ", for string %s (%d)", gst_value_get_fraction_denominator (&value),

   415         result_denoms[i], strings[i], i);

   416         

   417   }

   418   

   419     std_log(LOG_FILENAME_LINE, "Test Successful");

   420   create_xml(0);

   421 }

   422 

   423 

   424 

   425 void test_serialize_flags()

   426 {

   427   GValue value = { 0 };

   428   gchar *string;

   429   GstSeekFlags flags[] = {

   430     0,

   431     GST_SEEK_FLAG_NONE,

   432     GST_SEEK_FLAG_FLUSH,

   433     GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,

   434   };

   435   const char *results[] = {

   436     "GST_SEEK_FLAG_NONE",

   437     "GST_SEEK_FLAG_NONE",

   438     "GST_SEEK_FLAG_FLUSH",

   439     "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",

   440   };

   441   int i;

   442   

   443     xmlfile = "test_serialize_flags";

   444   std_log(LOG_FILENAME_LINE, "Test Started test_serialize_flags");

   445 

   446 

   447   g_value_init (&value, GST_TYPE_SEEK_FLAGS);

   448 

   449   for (i = 0; i < G_N_ELEMENTS (flags); ++i) {

   450     g_value_set_flags (&value, flags[i]);

   451     string = gst_value_serialize (&value);

   452     fail_if (string == NULL, "could not serialize flags %d", i);

   453     

   454     fail_unless (strcmp (string, results[i]) == 0,

   455         "resulting value is %s, not %s, for flags #%d", string, results[i], i);

   456         

   457     g_free (string);

   458   }

   459     std_log(LOG_FILENAME_LINE, "Test Successful");

   460   create_xml(0);

   461 }

   462 

   463 

   464 

   465 

   466 void test_deserialize_flags()

   467 {

   468   GValue value = { 0 };

   469   const char *strings[] = {

   470     "",

   471     "0",

   472     "GST_SEEK_FLAG_NONE",

   473     "GST_SEEK_FLAG_FLUSH",

   474     "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",

   475   };

   476   GstSeekFlags results[] = {

   477     GST_SEEK_FLAG_NONE,

   478     GST_SEEK_FLAG_NONE,

   479     GST_SEEK_FLAG_NONE,

   480     GST_SEEK_FLAG_FLUSH,

   481     GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,

   482   };

   483   int i;

   484   

   485     xmlfile = "test_deserialize_flags";

   486   std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_flags");

   487 

   488 

   489   g_value_init (&value, GST_TYPE_SEEK_FLAGS);

   490 

   491   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {

   492     fail_unless (gst_value_deserialize (&value, strings[i]),

   493         "could not deserialize %s (%d)", strings[i], i);

   494         

   495     fail_unless (g_value_get_flags (&value) == results[i],

   496         "resulting value is %d, not %d, for string %s (%d)",

   497         g_value_get_flags (&value), results[i], strings[i], i);

   498         

   499   }

   500     std_log(LOG_FILENAME_LINE, "Test Successful");

   501   create_xml(0);

   502 }

   503 

   504 

   505 void test_serialize_deserialize_format_enum()

   506 {

   507   GstStructure *s, *s2;

   508   GstFormat foobar_fmt;

   509   gchar *str, *str2, *end = NULL;

   510   

   511     xmlfile = "test_serialize_deserialize_format_enum";

   512   std_log(LOG_FILENAME_LINE, "Test Started test_serialize_deserialize_format_enum");

   513 

   514 

   515   /* make sure custom formats are serialised properly as well */

   516   foobar_fmt = gst_format_register ("foobar", "GST_FORMAT_FOOBAR");

   517   fail_unless (foobar_fmt != GST_FORMAT_UNDEFINED);

   518   

   519 

   520   s = gst_structure_new ("foo/bar", "format1", GST_TYPE_FORMAT,

   521       GST_FORMAT_BYTES, "format2", GST_TYPE_FORMAT, GST_FORMAT_TIME,

   522       "format3", GST_TYPE_FORMAT, GST_FORMAT_DEFAULT, "format4",

   523       GST_TYPE_FORMAT, foobar_fmt, NULL);

   524 

   525   str = gst_structure_to_string (s);

   526   GST_LOG ("Got structure string '%s'", GST_STR_NULL (str));

   527   fail_unless (str != NULL);

   528   

   529   fail_unless (strstr (str, "TIME") != NULL);

   530   

   531   fail_unless (strstr (str, "BYTE") != NULL);

   532   

   533   fail_unless (strstr (str, "DEFAULT") != NULL);

   534   

   535   fail_unless (strstr (str, "FOOBAR") != NULL);

   536   

   537 

   538   s2 = gst_structure_from_string (str, &end);

   539   fail_unless (s2 != NULL);

   540   

   541 

   542   str2 = gst_structure_to_string (s2);

   543   fail_unless (str2 != NULL);

   544   

   545 

   546   fail_unless (g_str_equal (str, str2));

   547   

   548 

   549   g_free (str);

   550   g_free (str2);

   551   gst_structure_free (s);

   552   gst_structure_free (s2);

   553   

   554     std_log(LOG_FILENAME_LINE, "Test Successful");

   555   create_xml(0);

   556 }

   557 

   558 

   559 void test_string()

   560 {

   561   gchar *try[] = {

   562     "Dude",

   563     "Hi, I'm a string",

   564     "tüüüt!"

   565   };

   566   gchar *tmp;

   567   GValue v = { 0, };

   568   guint i;

   569   

   570     xmlfile = "test_string";

   571   std_log(LOG_FILENAME_LINE, "Test Started test_string");

   572 

   573 

   574   g_value_init (&v, G_TYPE_STRING);

   575   for (i = 0; i < G_N_ELEMENTS (try); i++) {

   576     g_value_set_string (&v, try[i]);

   577     tmp = gst_value_serialize (&v);

   578     fail_if (tmp == NULL, "couldn't serialize: %s\n", try[i]);

   579     

   580     fail_unless (gst_value_deserialize (&v, tmp),

   581         "couldn't deserialize: %s\n", tmp);

   582         

   583     g_free (tmp);

   584 

   585     fail_unless (g_str_equal (g_value_get_string (&v), try[i]),

   586         "\nserialized  : %s\ndeserialized: %s", try[i],

   587         g_value_get_string (&v));

   588         

   589   }

   590   /* NULL strings should not be serializable */

   591   g_value_set_string (&v, NULL);

   592   fail_unless (gst_value_serialize (&v) == NULL);

   593   

   594   g_value_unset (&v);

   595   

   596     std_log(LOG_FILENAME_LINE, "Test Successful");

   597   create_xml(0);

   598 }

   599 

   600 

   601 

   602 void test_deserialize_string()

   603 {

   604   struct

   605   {

   606     gchar *from;

   607     gchar *to;

   608   } tests[] = {

   609     {

   610     "", ""},                    /* empty strings */

   611     {

   612     "\"\"", ""},                /* FAILURES */

   613     {

   614     "\"", NULL},                /* missing second quote */

   615     {

   616     "\"Hello\\ World", NULL},   /* missing second quote */

   617     {

   618     "\"\\", NULL},              /* quote at end, missing second quote */

   619     {

   620     "\"\\0", NULL},             /* missing second quote */

   621     {

   622     "\"\\0\"", NULL},           /* unfinished escaped character */

   623     {

   624     "\" \"", NULL},             /* spaces must be escaped */

   625 #if 0

   626         /* FIXME 0.9: this test should fail, but it doesn't */

   627     {

   628     "tüüt", NULL}             /* string with special chars must be escaped */

   629 #endif

   630   };

   631   guint i;

   632   GValue v = { 0, };

   633   gboolean ret = TRUE;

   634   

   635     xmlfile = "test_deserialize_string";

   636   std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_string");

   637 

   638 

   639   g_value_init (&v, G_TYPE_STRING);

   640   for (i = 0; i < G_N_ELEMENTS (tests); i++) {

   641     if (gst_value_deserialize (&v, tests[i].from)) {

   642       fail_if (tests[i].to == NULL,

   643           "I got %s instead of a failure", g_value_get_string (&v));

   644           

   645       fail_unless (g_str_equal (g_value_get_string (&v), tests[i].to),

   646           "\nwanted: %s\ngot    : %s", tests[i].to, g_value_get_string (&v));

   647           

   648     } else {

   649       fail_if (tests[i].to != NULL, "failed, but wanted: %s", tests[i].to);

   650       

   651       ret = FALSE;

   652     }

   653   }

   654   g_value_unset (&v);

   655   

   656     std_log(LOG_FILENAME_LINE, "Test Successful");

   657   create_xml(0);

   658 }

   659 

   660 

   661 void test_value_intersect()

   662 {

   663   GValue dest = { 0 };

   664   GValue src1 = { 0 };

   665   GValue src2 = { 0 };

   666   GValue item = { 0 };

   667   gboolean ret;

   668   

   669     xmlfile = "test_value_intersect";

   670   std_log(LOG_FILENAME_LINE, "Test Started test_value_intersect");

   671 

   672 

   673   g_value_init (&src1, G_TYPE_INT);

   674   g_value_set_int (&src1, 10);

   675   g_value_init (&src2, G_TYPE_INT);

   676   g_value_set_int (&src2, 20);

   677   ret = gst_value_intersect (&dest, &src1, &src2);

   678   fail_unless (ret == FALSE);

   679   

   680   g_value_unset (&src1);

   681   g_value_unset (&src2);

   682 

   683   g_value_init (&src1, GST_TYPE_FOURCC);

   684   gst_value_set_fourcc (&src1, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));

   685   g_value_init (&src2, GST_TYPE_LIST);

   686   g_value_init (&item, GST_TYPE_FOURCC);

   687   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));

   688   gst_value_list_append_value (&src2, &item);

   689   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('I', '4', '2', '0'));

   690   gst_value_list_append_value (&src2, &item);

   691   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('A', 'B', 'C', 'D'));

   692   gst_value_list_append_value (&src2, &item);

   693 

   694   fail_unless (gst_value_intersect (&dest, &src1, &src2));

   695   

   696   fail_unless (GST_VALUE_HOLDS_FOURCC (&dest));

   697   

   698   fail_unless (gst_value_get_fourcc (&dest) ==

   699       GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));

   700       

   701 

   702   g_value_unset (&src1);

   703   g_value_unset (&src2);

   704   

   705     std_log(LOG_FILENAME_LINE, "Test Successful");

   706   create_xml(0);

   707 }

   708 

   709 

   710 void test_date()

   711 {

   712   GstStructure *s;

   713   GDate *date, *date2;

   714   gchar *str;

   715   

   716     xmlfile = "test_date";

   717   std_log(LOG_FILENAME_LINE, "Test Started test_date");

   718 

   719 

   720   date = g_date_new_dmy (22, 9, 2005);

   721 

   722   s = gst_structure_new ("media/x-type", "SOME_DATE_TAG", GST_TYPE_DATE,

   723       date, NULL);

   724 

   725   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",

   726           GST_TYPE_DATE));

   727           

   728   fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date2));

   729   

   730   fail_unless (date2 != NULL);

   731   

   732   fail_unless (g_date_valid (date2));

   733   

   734   fail_unless (g_date_compare (date, date2) == 0);

   735   

   736 

   737   g_date_free (date);

   738   g_date_free (date2);

   739   date = NULL;

   740   date2 = NULL;

   741 

   742   str = gst_structure_to_string (s);

   743   gst_structure_free (s);

   744   s = NULL;

   745 

   746   fail_unless (g_str_equal (str,

   747           "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22;"));

   748           

   749 

   750   s = gst_structure_from_string (str, NULL);

   751   g_free (str);

   752   str = NULL;

   753 

   754   fail_unless (s != NULL);

   755   

   756   fail_unless (gst_structure_has_name (s, "media/x-type"));

   757   

   758   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",

   759           GST_TYPE_DATE));

   760           

   761   fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date));

   762   

   763   fail_unless (date != NULL);

   764   

   765   fail_unless (g_date_valid (date));

   766   

   767   fail_unless (g_date_get_day (date) == 22);

   768   

   769   fail_unless (g_date_get_month (date) == 9);

   770   

   771   fail_unless (g_date_get_year (date) == 2005);

   772   

   773   g_date_free (date);

   774   date = NULL;

   775 

   776   str = gst_structure_to_string (s);

   777   gst_structure_free (s);

   778   s = NULL;

   779 

   780   fail_unless (g_str_equal (str,

   781           "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22;"));

   782           

   783   g_free (str);

   784   str = NULL;

   785   

   786     std_log(LOG_FILENAME_LINE, "Test Successful");

   787   create_xml(0);

   788 }

   789 

   790 

   791 void test_fraction_range()

   792 {

   793   GValue range = { 0, };

   794   GValue start = { 0, }, end = {

   795   0,};

   796   GValue src = { 0, }, dest = {

   797   0,};

   798   GValue range2 = { 0, };

   799   

   800     xmlfile = "test_fraction_range";

   801   std_log(LOG_FILENAME_LINE, "Test Started test_fraction_range");

   802 

   803 

   804   g_value_init (&range, GST_TYPE_FRACTION_RANGE);

   805   g_value_init (&range2, GST_TYPE_FRACTION_RANGE);

   806   g_value_init (&start, GST_TYPE_FRACTION);

   807   g_value_init (&end, GST_TYPE_FRACTION);

   808   g_value_init (&src, GST_TYPE_FRACTION);

   809 

   810   gst_value_set_fraction (&src, 1, 2);

   811 

   812   /* Check that a intersection of fraction & range = fraction */

   813   gst_value_set_fraction (&start, 1, 4);

   814   gst_value_set_fraction (&end, 2, 3);

   815   gst_value_set_fraction_range (&range, &start, &end);

   816 

   817   fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);

   818   

   819   fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION);

   820   

   821   fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);

   822   

   823 

   824   /* Check that a intersection selects the overlapping range */

   825   gst_value_set_fraction (&start, 1, 3);

   826   gst_value_set_fraction (&end, 2, 3);

   827   gst_value_set_fraction_range (&range2, &start, &end);

   828   g_value_unset (&dest);

   829   fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);

   830   

   831   fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);

   832   

   833 

   834   gst_value_set_fraction_range (&range2, &start, &end);

   835   fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);

   836   

   837 

   838   /* Check that non intersection ranges don't intersect */

   839   gst_value_set_fraction (&start, 4, 2);

   840   gst_value_set_fraction (&end, 5, 2);

   841   gst_value_set_fraction_range (&range2, &start, &end);

   842   g_value_unset (&dest);

   843   fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);

   844   

   845 

   846   g_value_unset (&start);

   847   g_value_unset (&end);

   848   g_value_unset (&range);

   849   g_value_unset (&range2);

   850   g_value_unset (&src);

   851   

   852     std_log(LOG_FILENAME_LINE, "Test Successful");

   853   create_xml(0);

   854 }

   855 

   856 /* Test arithmetic subtraction of fractions */

   857 void test_value_subtract_fraction()

   858 {

   859   GValue result = { 0 };

   860   GValue src1 = { 0 };

   861   GValue src2 = { 0 };

   862   

   863     xmlfile = "test_value_subtract_fraction";

   864   std_log(LOG_FILENAME_LINE, "Test Started test_value_subtract_fraction");

   865 

   866 

   867   /* Subtract 1/4 from 1/2 */

   868   g_value_init (&src1, GST_TYPE_FRACTION);

   869   g_value_init (&src2, GST_TYPE_FRACTION);

   870   g_value_init (&result, GST_TYPE_FRACTION);

   871   gst_value_set_fraction (&src1, 1, 2);

   872   gst_value_set_fraction (&src2, 1, 4);

   873   fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);

   874   

   875   fail_unless (gst_value_get_fraction_numerator (&result) == 1);

   876   

   877   fail_unless (gst_value_get_fraction_denominator (&result) == 4);

   878   

   879 

   880   g_value_unset (&src1);

   881   g_value_unset (&src2);

   882   g_value_unset (&result);

   883 

   884   /* Subtract 1/12 from 7/8 */

   885   g_value_init (&src1, GST_TYPE_FRACTION);

   886   g_value_init (&src2, GST_TYPE_FRACTION);

   887   g_value_init (&result, GST_TYPE_FRACTION);

   888   gst_value_set_fraction (&src1, 7, 8);

   889   gst_value_set_fraction (&src2, 1, 12);

   890   fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);

   891   

   892   fail_unless (gst_value_get_fraction_numerator (&result) == 19);

   893   

   894   fail_unless (gst_value_get_fraction_denominator (&result) == 24);

   895   

   896 

   897   g_value_unset (&src1);

   898   g_value_unset (&src2);

   899   g_value_unset (&result);

   900 

   901   /* Subtract 12/13 from 4/3 */

   902   g_value_init (&src1, GST_TYPE_FRACTION);

   903   g_value_init (&src2, GST_TYPE_FRACTION);

   904   g_value_init (&result, GST_TYPE_FRACTION);

   905   gst_value_set_fraction (&src1, 4, 3);

   906   gst_value_set_fraction (&src2, 12, 13);

   907   fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);

   908   

   909   fail_unless (gst_value_get_fraction_numerator (&result) == 16);

   910   

   911   fail_unless (gst_value_get_fraction_denominator (&result) == 39);

   912   

   913 

   914   g_value_unset (&src1);

   915   g_value_unset (&src2);

   916   g_value_unset (&result);

   917   

   918     std_log(LOG_FILENAME_LINE, "Test Successful");

   919   create_xml(0);

   920 

   921   /* Subtract 1/12 from 7/8 */

   922 }

   923 

   924 

   925 void test_value_compare()

   926 {

   927   GValue value1 = { 0 };

   928   GValue value2 = { 0 };

   929   GValue tmp = { 0 };

   930   

   931     xmlfile = "test_value_compare";

   932   std_log(LOG_FILENAME_LINE, "Test Started test_range");

   933 

   934 

   935   g_value_init (&value1, G_TYPE_INT);

   936   g_value_set_int (&value1, 10);

   937   g_value_init (&value2, G_TYPE_INT);

   938   g_value_set_int (&value2, 20);

   939   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);

   940   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);

   941   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);

   942   g_value_unset (&value1);

   943   g_value_unset (&value2);

   944 

   945   g_value_init (&value1, G_TYPE_DOUBLE);

   946   g_value_set_double (&value1, 10);

   947   g_value_init (&value2, G_TYPE_DOUBLE);

   948   g_value_set_double (&value2, 20);

   949   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);

   950   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);

   951   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);

   952   g_value_unset (&value1);

   953   g_value_unset (&value2);

   954 

   955   g_value_init (&value1, G_TYPE_STRING);

   956   g_value_set_string (&value1, "a");

   957   g_value_init (&value2, G_TYPE_STRING);

   958   g_value_set_string (&value2, "b");

   959   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);

   960   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);

   961   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);

   962   g_value_unset (&value1);

   963   g_value_unset (&value2);

   964 

   965   g_value_init (&value1, GST_TYPE_FOURCC);

   966   gst_value_set_fourcc (&value1, GST_MAKE_FOURCC ('a', 'b', 'c', 'd'));

   967   g_value_init (&value2, GST_TYPE_FOURCC);

   968   gst_value_set_fourcc (&value2, GST_MAKE_FOURCC ('1', '2', '3', '4'));

   969   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);

   970   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);

   971   g_value_unset (&value1);

   972   g_value_unset (&value2);

   973 

   974   /* comparing 2/3 with 3/4 */

   975   g_value_init (&value1, GST_TYPE_FRACTION);

   976   gst_value_set_fraction (&value1, 2, 3);

   977   g_value_init (&value2, GST_TYPE_FRACTION);

   978   gst_value_set_fraction (&value2, 3, 4);

   979   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);

   980   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);

   981   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);

   982   g_value_unset (&value1);

   983   g_value_unset (&value2);

   984 

   985   /* comparing -4/5 with 2/-3 */

   986   g_value_init (&value1, GST_TYPE_FRACTION);

   987   gst_value_set_fraction (&value1, -4, 5);

   988   g_value_init (&value2, GST_TYPE_FRACTION);

   989   gst_value_set_fraction (&value2, 2, -3);

   990   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);

   991   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);

   992   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);

   993   g_value_unset (&value1);

   994   g_value_unset (&value2);

   995 

   996   /* comparing 10/100 with 200/2000 */

   997   g_value_init (&value1, GST_TYPE_FRACTION);

   998   gst_value_set_fraction (&value1, 10, 100);

   999   g_value_init (&value2, GST_TYPE_FRACTION);

  1000   gst_value_set_fraction (&value2, 200, 2000);

  1001   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL);

  1002   g_value_unset (&value1);

  1003   g_value_unset (&value2);

  1004 

  1005   /* comparing -4/5 with 2/-3 */

  1006   g_value_init (&value1, GST_TYPE_FRACTION);

  1007   gst_value_set_fraction (&value1, -4, 5);

  1008   g_value_init (&value2, GST_TYPE_FRACTION);

  1009   gst_value_set_fraction (&value2, 2, -3);

  1010   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);

  1011   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);

  1012   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);

  1013   g_value_unset (&value1);

  1014   g_value_unset (&value2);

  1015 

  1016   /* Check that lists are equal regardless of order */

  1017   g_value_init (&value1, GST_TYPE_LIST);

  1018   g_value_init (&tmp, G_TYPE_INT);

  1019   g_value_set_int (&tmp, 1);

  1020   gst_value_list_append_value (&value1, &tmp);

  1021   g_value_set_int (&tmp, 2);

  1022   gst_value_list_append_value (&value1, &tmp);

  1023   g_value_set_int (&tmp, 3);

  1024   gst_value_list_append_value (&value1, &tmp);

  1025   g_value_set_int (&tmp, 4);

  1026   gst_value_list_append_value (&value1, &tmp);

  1027 

  1028   g_value_init (&value2, GST_TYPE_LIST);

  1029   g_value_set_int (&tmp, 4);

  1030   gst_value_list_append_value (&value2, &tmp);

  1031   g_value_set_int (&tmp, 3);

  1032   gst_value_list_append_value (&value2, &tmp);

  1033   g_value_set_int (&tmp, 2);

  1034   gst_value_list_append_value (&value2, &tmp);

  1035   g_value_set_int (&tmp, 1);

  1036   gst_value_list_append_value (&value2, &tmp);

  1037 

  1038   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,

  1039       "value lists with different order were not equal when they should be");

  1040   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL,

  1041       "value lists with same order were not equal when they should be");

  1042   fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL,

  1043       "value lists with same order were not equal when they should be");

  1044 

  1045   /* Carry over the lists to this next check: */

  1046   /* Lists with different sizes are unequal */

  1047   g_value_set_int (&tmp, 1);

  1048   gst_value_list_append_value (&value2, &tmp);

  1049 

  1050   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,

  1051       "Value lists with different size were equal when they shouldn't be");

  1052 

  1053   /* Carry over the lists to this next check: */

  1054   /* Lists with same size but list1 contains one more element not in list2 */

  1055   g_value_set_int (&tmp, 5);

  1056   gst_value_list_append_value (&value1, &tmp);

  1057 

  1058   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,

  1059       "Value lists with different elements were equal when they shouldn't be");

  1060   fail_if (gst_value_compare (&value2, &value1) == GST_VALUE_EQUAL,

  1061       "Value lists with different elements were equal when they shouldn't be");

  1062 

  1063   g_value_unset (&value1);

  1064   g_value_unset (&value2);

  1065   g_value_unset (&tmp);

  1066 

  1067   /* Arrays are only equal when in the same order */

  1068   g_value_init (&value1, GST_TYPE_ARRAY);

  1069   g_value_init (&tmp, G_TYPE_INT);

  1070   g_value_set_int (&tmp, 1);

  1071   gst_value_array_append_value (&value1, &tmp);

  1072   g_value_set_int (&tmp, 2);

  1073   gst_value_array_append_value (&value1, &tmp);

  1074   g_value_set_int (&tmp, 3);

  1075   gst_value_array_append_value (&value1, &tmp);

  1076   g_value_set_int (&tmp, 4);

  1077   gst_value_array_append_value (&value1, &tmp);

  1078 

  1079   g_value_init (&value2, GST_TYPE_ARRAY);

  1080   g_value_set_int (&tmp, 4);

  1081   gst_value_array_append_value (&value2, &tmp);

  1082   g_value_set_int (&tmp, 3);

  1083   gst_value_array_append_value (&value2, &tmp);

  1084   g_value_set_int (&tmp, 2);

  1085   gst_value_array_append_value (&value2, &tmp);

  1086   g_value_set_int (&tmp, 1);

  1087   gst_value_array_append_value (&value2, &tmp);

  1088 

  1089   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,

  1090       "Value arrays with different order were equal when they shouldn't be");

  1091   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL,

  1092       "Identical value arrays were not equal when they should be");

  1093   fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL,

  1094       "Identical value arrays were not equal when they should be");

  1095 

  1096   /* Carry over the arrays to this next check: */

  1097   /* Arrays with different sizes are unequal */

  1098   g_value_unset (&value2);

  1099   g_value_init (&value2, GST_TYPE_ARRAY);

  1100   g_value_copy (&value1, &value2);

  1101 

  1102   g_value_set_int (&tmp, 1);

  1103   gst_value_array_append_value (&value2, &tmp);

  1104 

  1105   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,

  1106       "Value arrays with different size were equal when they shouldn't be");

  1107   /* order should not matter */

  1108   fail_if (gst_value_compare (&value2, &value1) == GST_VALUE_EQUAL,

  1109       "Value arrays with different size were equal when they shouldn't be");

  1110 

  1111   g_value_unset (&value1);

  1112   g_value_unset (&value2);

  1113   g_value_unset (&tmp);

  1114   

  1115     std_log(LOG_FILENAME_LINE, "Test Successful");

  1116   create_xml(0);

  1117 }

  1118 

  1119 

  1120 void test_value_subtract_int()

  1121 {

  1122   GValue dest = { 0 };

  1123   GValue src1 = { 0 };

  1124   GValue src2 = { 0 };

  1125   const GValue *tmp;

  1126   gboolean ret;

  1127   

  1128     xmlfile = "test_value_subtract_int";

  1129   std_log(LOG_FILENAME_LINE, "Test Started test_range");

  1130 

  1131 

  1132   /*  int <-> int

  1133    */

  1134   g_value_init (&src1, G_TYPE_INT);