1  /*

     2  *  Copyright © 2008 Nokia Corporation.

     3  *  This material, including documentation and any related 

     4  *  computer programs, is protected by copyright controlled by 

     5  *  Nokia Corporation. All rights are reserved. Copying, 

     6  *  including reproducing, storing, adapting or translating, any 

     7  *  or all of this material requires the prior written consent of 

     8  *  Nokia Corporation. This material also contains confidential 

     9  *  information which may not be disclosed to others without the 

    10  *  prior written consent of Nokia Corporation.

    11  * ============================================================================

    12  */

    13 

    14 /* GStreamer

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

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

    17  *

    18  * gstvalue.c: Unit tests for GstValue

    19  *

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

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

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

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

    24  *

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

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

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

    28  * Library General Public License for more details.

    29  *

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

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

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

    33  * Boston, MA 02111-1307, USA.

    34  */

    35 

    36 

    37 

    38 #include <gst/gst_global.h>

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

    40 

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

    42 #include "std_log_result.h" 

    43 #define LOG_FILENAME_LINE __FILE__, __LINE__

    44 

    45 //char* xmlfile = "gstvalue";

    46 

    47 void create_xml(int result)

    48 {

    49     if(result)

    50         assert_failed = 1;

    51     

    52     testResultXml(xmlfile);

    53     close_log_file();

    54 }

    55 

    56 

    57 void test_deserialize_buffer()

    58 {

    59   GValue value = { 0 };

    60   GstBuffer *buf;

    61   

    62     xmlfile = "test_deserialize_buffer";

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

    64 

    65 

    66   g_value_init (&value, GST_TYPE_BUFFER);

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

    68   

    69   /* does not increase the refcount */

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

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

    72 

    73   /* does not increase the refcount */

    74   buf = gst_value_get_buffer (&value);

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

    76 

    77   /* cleanup */

    78   g_value_unset (&value);

    79     

    80     std_log(LOG_FILENAME_LINE, "Test Successful");

    81   create_xml(0);

    82 }

    83 

    84 

    85 

    86 /* create and serialize a buffer */

    87 void test_serialize_buffer()

    88 {

    89   GValue value = { 0 };

    90   GstBuffer *buf;

    91   gchar *serialized;

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

    93   gint len;

    94   

    95     xmlfile = "test_serialize_buffer";

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

    97 

    98 

    99   len = strlen (buf_data);

   100   buf = gst_buffer_new_and_alloc (len);

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

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

   103 

   104   /* and assign buffer to mini object */

   105   g_value_init (&value, GST_TYPE_BUFFER);

   106   gst_value_take_buffer (&value, buf);

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

   108 

   109   /* now serialize it */

   110   serialized = gst_value_serialize (&value);

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

   112   fail_unless (serialized != NULL);

   113   

   114 

   115   /* refcount should not change */

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

   117 

   118   /* cleanup */

   119   g_free (serialized);

   120   g_value_unset (&value);

   121 

   122   /* take NULL buffer */

   123   g_value_init (&value, GST_TYPE_BUFFER);

   124   GST_DEBUG ("setting NULL buffer");

   125   gst_value_take_buffer (&value, NULL);

   126 

   127   /* now serialize it */

   128   GST_DEBUG ("serializing NULL buffer");

   129   serialized = gst_value_serialize (&value);

   130   /* should return NULL */

   131   fail_unless (serialized == NULL);

   132   

   133 

   134   g_free (serialized);

   135   g_value_unset (&value);

   136   

   137     std_log(LOG_FILENAME_LINE, "Test Successful");

   138   create_xml(0);

   139 }

   140 

   141 

   142 

   143 void test_deserialize_gint()

   144 {

   145   GValue value = { 0 };

   146   const char *strings[] = {

   147     "123456",

   148     "-123456",

   149     "0xFFFF",

   150     "0x0000FFFF",

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

   152     "0x7FFFFFFF",

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

   154     "0x80000000",

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

   156     "0xFFFFFFFF80000000",

   157     "0xFF000000",

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

   159     "0xFFFFFFFF",

   160     "0xFFFFFFFF",

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

   162     "0xFFFFFFFFFFFFFFFF",

   163     "0xFFFFFFFFFFFFFFFF",

   164     "0xEFFFFFFF",

   165   };

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

   167   gint results[] = {

   168     123456,

   169     -123456,

   170     0xFFFF,

   171     0xFFFF,

   172     0x7FFFFFFF,

   173     (gint) 0x80000000,

   174     (gint) 0x80000000,

   175     (gint) 0xFF000000,

   176     -1,

   177     (gint) 0xFFFFFFFF,

   178     -1,

   179     (gint) 0xFFFFFFFFFFFFFFFFLL,

   180     (gint) 0xEFFFFFFF,

   181   };

   182   int i;

   183   

   184     xmlfile = "test_deserialize_gint";

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

   186 

   187 

   188   g_value_init (&value, G_TYPE_INT);

   189 

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

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

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

   193         

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

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

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

   197         

   198   }

   199   

   200     std_log(LOG_FILENAME_LINE, "Test Successful");

   201   create_xml(0);

   202 }

   203 

   204 

   205 void test_deserialize_gint_failures()

   206 {

   207   GValue value = { 0 };

   208   const char *strings[] = {

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

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

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

   212     "0xF000000000000000",

   213     "0xFFFFFFF000000000",

   214     "0xFFFFFFFF00000000",

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

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

   217     "0x10000000000000000000000000000000000000000000",

   218   };

   219   int i;

   220   

   221     xmlfile = "test_deserialize_gint_failures";

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

   223 

   224 

   225   g_value_init (&value, G_TYPE_INT);

   226 

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

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

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

   230         

   231   }

   232   

   233     std_log(LOG_FILENAME_LINE, "Test Successful");

   234   create_xml(0);

   235 }

   236 

   237 void test_deserialize_guint()

   238 {

   239   GValue value = { 0 };

   240   const char *strings[] = {

   241     "123456",

   242     "-123456",

   243     "0xFFFF",

   244     "0x0000FFFF",

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

   246     "0x7FFFFFFF",

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

   248     "0x80000000",

   249     "2147483648",

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

   251     "0xFFFFFFFF80000000",

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

   253     "0xFF000000",

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

   255     "0xFFFFFFFF",

   256     "0xFFFFFFFF",

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

   258     "0xFFFFFFFFFFFFFFFF",

   259     "0xEFFFFFFF",

   260   };

   261   guint results[] = {

   262     123456,

   263     (guint) - 123456,

   264     0xFFFF,

   265     0xFFFF,

   266     0x7FFFFFFF,

   267     0x80000000,

   268     (guint) 2147483648LL,

   269     0x80000000,

   270     0xFF000000,

   271     0xFFFFFFFF,

   272     G_MAXUINT,

   273     (guint) 0xFFFFFFFFFFFFFFFFLL,

   274     0xEFFFFFFF,

   275   };

   276   int i;

   277   

   278     xmlfile = "test_deserialize_guint";

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

   280 

   281 

   282   g_value_init (&value, G_TYPE_UINT);

   283 

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

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

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

   287         

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

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

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

   291         

   292   }

   293     std_log(LOG_FILENAME_LINE, "Test Successful");

   294   create_xml(0);

   295 }

   296 

   297 void test_deserialize_guint_failures()

   298 {

   299   GValue value = { 0 };

   300   const char *strings[] = {

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

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

   303 #if 0

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

   305  * the target format */

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

   307     "0xF000000000000000",

   308     "0xFFFFFFF000000000",

   309     "0xFFFFFFFF00000000",

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

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

   312     "0x10000000000000000000000000000000000000000000",

   313 #endif

   314   };

   315   int i;

   316   

   317     xmlfile = "test_deserialize_guint_failures";

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

   319 

   320 

   321   g_value_init (&value, G_TYPE_UINT);

   322 

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

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

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

   326         

   327   }

   328     std_log(LOG_FILENAME_LINE, "Test Successful");

   329   create_xml(0);

   330 }

   331 

   332 

   333 void test_deserialize_gint64()

   334 {

   335   GValue value = { 0 };

   336   const char *strings[] = {

   337     "12345678901",

   338     "-12345678901",

   339   };

   340   gint64 results[] = {

   341     12345678901LL,

   342     -12345678901LL,

   343   };

   344   int i;

   345   

   346     xmlfile = "test_deserialize_gint64";

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

   348 

   349 

   350   g_value_init (&value, G_TYPE_INT64);

   351 

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

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

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

   355         

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

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

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

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

   360         

   361   }

   362   

   363     std_log(LOG_FILENAME_LINE, "Test Successful");

   364   create_xml(0);

   365 }

   366 

   367 

   368 

   369 

   370 

   371 void test_deserialize_gstfraction()

   372 {

   373   GValue value = { 0 };

   374   const char *strings[] = {

   375     "4/5",

   376     "-8/9"

   377   };

   378   gint64 result_numers[] = {

   379     4,

   380     -8

   381   };

   382   gint64 result_denoms[] = {

   383     5,

   384     9

   385   };

   386 

   387   int i;

   388   

   389     xmlfile = "test_deserialize_gstfraction";

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

   391 

   392 

   393   g_value_init (&value, GST_TYPE_FRACTION);

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

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

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

   397         

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

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

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

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

   402         

   403     fail_unless (gst_value_get_fraction_denominator (&value) ==

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

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

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

   407         

   408   }

   409   

   410     std_log(LOG_FILENAME_LINE, "Test Successful");

   411   create_xml(0);

   412 }

   413 

   414 

   415 

   416 void test_serialize_flags()

   417 {

   418   GValue value = { 0 };

   419   gchar *string;

   420   GstSeekFlags flags[] = {

   421     0,

   422     GST_SEEK_FLAG_NONE,

   423     GST_SEEK_FLAG_FLUSH,

   424     GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,

   425   };

   426   const char *results[] = {

   427     "GST_SEEK_FLAG_NONE",

   428     "GST_SEEK_FLAG_NONE",

   429     "GST_SEEK_FLAG_FLUSH",

   430     "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",

   431   };

   432   int i;

   433   

   434     xmlfile = "test_serialize_flags";

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

   436 

   437 

   438   g_value_init (&value, GST_TYPE_SEEK_FLAGS);

   439 

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

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

   442     string = gst_value_serialize (&value);

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

   444     

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

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

   447         

   448     g_free (string);

   449   }

   450     std_log(LOG_FILENAME_LINE, "Test Successful");

   451   create_xml(0);

   452 }

   453 

   454 

   455 

   456 

   457 void test_deserialize_flags()

   458 {

   459   GValue value = { 0 };

   460   const char *strings[] = {

   461     "",

   462     "0",

   463     "GST_SEEK_FLAG_NONE",

   464     "GST_SEEK_FLAG_FLUSH",

   465     "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",

   466   };

   467   GstSeekFlags results[] = {

   468     GST_SEEK_FLAG_NONE,

   469     GST_SEEK_FLAG_NONE,

   470     GST_SEEK_FLAG_NONE,

   471     GST_SEEK_FLAG_FLUSH,

   472     GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,

   473   };

   474   int i;

   475   

   476     xmlfile = "test_deserialize_flags";

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

   478 

   479 

   480   g_value_init (&value, GST_TYPE_SEEK_FLAGS);

   481 

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

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

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

   485         

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

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

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

   489         

   490   }

   491     std_log(LOG_FILENAME_LINE, "Test Successful");

   492   create_xml(0);

   493 }

   494 

   495 

   496 void test_serialize_deserialize_format_enum()

   497 {

   498   GstStructure *s, *s2;

   499   GstFormat foobar_fmt;

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

   501   

   502     xmlfile = "test_serialize_deserialize_format_enum";

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

   504 

   505 

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

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

   508   fail_unless (foobar_fmt != GST_FORMAT_UNDEFINED);

   509   

   510 

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

   512       GST_FORMAT_BYTES, "format2", GST_TYPE_FORMAT, GST_FORMAT_TIME,

   513       "format3", GST_TYPE_FORMAT, GST_FORMAT_DEFAULT, "format4",

   514       GST_TYPE_FORMAT, foobar_fmt, NULL);

   515 

   516   str = gst_structure_to_string (s);

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

   518   fail_unless (str != NULL);

   519   

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

   521   

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

   523   

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

   525   

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

   527   

   528 

   529   s2 = gst_structure_from_string (str, &end);

   530   fail_unless (s2 != NULL);

   531   

   532 

   533   str2 = gst_structure_to_string (s2);

   534   fail_unless (str2 != NULL);

   535   

   536 

   537   fail_unless (g_str_equal (str, str2));

   538   

   539 

   540   g_free (str);

   541   g_free (str2);

   542   gst_structure_free (s);

   543   gst_structure_free (s2);

   544   

   545     std_log(LOG_FILENAME_LINE, "Test Successful");

   546   create_xml(0);

   547 }

   548 

   549 

   550 void test_string()

   551 {

   552   gchar *try[] = {

   553     "Dude",

   554     "Hi, I'm a string",

   555     "tüüüt!"

   556   };

   557   gchar *tmp;

   558   GValue v = { 0, };

   559   guint i;

   560   

   561     xmlfile = "test_string";

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

   563 

   564 

   565   g_value_init (&v, G_TYPE_STRING);

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

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

   568     tmp = gst_value_serialize (&v);

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

   570     

   571     fail_unless (gst_value_deserialize (&v, tmp),

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

   573         

   574     g_free (tmp);

   575 

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

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

   578         g_value_get_string (&v));

   579         

   580   }

   581   /* NULL strings should not be serializable */

   582   g_value_set_string (&v, NULL);

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

   584   

   585   g_value_unset (&v);

   586   

   587     std_log(LOG_FILENAME_LINE, "Test Successful");

   588   create_xml(0);

   589 }

   590 

   591 

   592 

   593 void test_deserialize_string()

   594 {

   595   struct

   596   {

   597     gchar *from;

   598     gchar *to;

   599   } tests[] = {

   600     {

   601     "", ""},                    /* empty strings */

   602     {

   603     "\"\"", ""},                /* FAILURES */

   604     {

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

   606     {

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

   608     {

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

   610     {

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

   612     {

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

   614     {

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

   616 #if 0

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

   618     {

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

   620 #endif

   621   };

   622   guint i;

   623   GValue v = { 0, };

   624   gboolean ret = TRUE;

   625   

   626     xmlfile = "test_deserialize_string";

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

   628 

   629 

   630   g_value_init (&v, G_TYPE_STRING);

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

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

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

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

   635           

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

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

   638           

   639     } else {

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

   641       

   642       ret = FALSE;

   643     }

   644   }

   645   g_value_unset (&v);

   646   

   647     std_log(LOG_FILENAME_LINE, "Test Successful");

   648   create_xml(0);

   649 }

   650 

   651 

   652 void test_value_intersect()

   653 {

   654   GValue dest = { 0 };

   655   GValue src1 = { 0 };

   656   GValue src2 = { 0 };

   657   GValue item = { 0 };

   658   gboolean ret;

   659   

   660     xmlfile = "test_value_intersect";

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

   662 

   663 

   664   g_value_init (&src1, G_TYPE_INT);

   665   g_value_set_int (&src1, 10);

   666   g_value_init (&src2, G_TYPE_INT);

   667   g_value_set_int (&src2, 20);

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

   669   fail_unless (ret == FALSE);

   670   

   671   g_value_unset (&src1);

   672   g_value_unset (&src2);

   673 

   674   g_value_init (&src1, GST_TYPE_FOURCC);

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

   676   g_value_init (&src2, GST_TYPE_LIST);

   677   g_value_init (&item, GST_TYPE_FOURCC);

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

   679   gst_value_list_append_value (&src2, &item);

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

   681   gst_value_list_append_value (&src2, &item);

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

   683   gst_value_list_append_value (&src2, &item);

   684 

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

   686   

   687   fail_unless (GST_VALUE_HOLDS_FOURCC (&dest));

   688   

   689   fail_unless (gst_value_get_fourcc (&dest) ==

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

   691       

   692 

   693   g_value_unset (&src1);

   694   g_value_unset (&src2);

   695   

   696     std_log(LOG_FILENAME_LINE, "Test Successful");

   697   create_xml(0);

   698 }

   699 

   700 

   701 void test_date()

   702 {

   703   GstStructure *s;

   704   GDate *date, *date2;

   705   gchar *str;

   706   

   707     xmlfile = "test_date";

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

   709 

   710 

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

   712 

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

   714       date, NULL);

   715 

   716   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",

   717           GST_TYPE_DATE));

   718           

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

   720   

   721   fail_unless (date2 != NULL);

   722   

   723   fail_unless (g_date_valid (date2));

   724   

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

   726   

   727 

   728   g_date_free (date);

   729   g_date_free (date2);

   730   date = NULL;

   731   date2 = NULL;

   732 

   733   str = gst_structure_to_string (s);

   734   gst_structure_free (s);

   735   s = NULL;

   736 

   737   fail_unless (g_str_equal (str,

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

   739           

   740 

   741   s = gst_structure_from_string (str, NULL);

   742   g_free (str);

   743   str = NULL;

   744 

   745   fail_unless (s != NULL);

   746   

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

   748   

   749   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",

   750           GST_TYPE_DATE));

   751           

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

   753   

   754   fail_unless (date != NULL);

   755   

   756   fail_unless (g_date_valid (date));

   757   

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

   759   

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

   761   

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

   763   

   764   g_date_free (date);

   765   date = NULL;

   766 

   767   str = gst_structure_to_string (s);

   768   gst_structure_free (s);

   769   s = NULL;

   770 

   771   fail_unless (g_str_equal (str,

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

   773           

   774   g_free (str);

   775   str = NULL;

   776   

   777     std_log(LOG_FILENAME_LINE, "Test Successful");

   778   create_xml(0);

   779 }

   780 

   781 

   782 void test_fraction_range()

   783 {

   784   GValue range = { 0, };

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

   786   0,};

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

   788   0,};

   789   GValue range2 = { 0, };

   790   

   791     xmlfile = "test_fraction_range";

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

   793 

   794 

   795   g_value_init (&range, GST_TYPE_FRACTION_RANGE);

   796   g_value_init (&range2, GST_TYPE_FRACTION_RANGE);

   797   g_value_init (&start, GST_TYPE_FRACTION);

   798   g_value_init (&end, GST_TYPE_FRACTION);

   799   g_value_init (&src, GST_TYPE_FRACTION);

   800 

   801   gst_value_set_fraction (&src, 1, 2);

   802 

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

   804   gst_value_set_fraction (&start, 1, 4);

   805   gst_value_set_fraction (&end, 2, 3);

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

   807 

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

   809   

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

   811   

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

   813   

   814 

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

   816   gst_value_set_fraction (&start, 1, 3);

   817   gst_value_set_fraction (&end, 2, 3);

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

   819   g_value_unset (&dest);

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

   821   

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

   823   

   824 

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

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

   827   

   828 

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

   830   gst_value_set_fraction (&start, 4, 2);

   831   gst_value_set_fraction (&end, 5, 2);

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

   833   g_value_unset (&dest);

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

   835   

   836 

   837   g_value_unset (&start);

   838   g_value_unset (&end);

   839   g_value_unset (&range);

   840   g_value_unset (&range2);

   841   g_value_unset (&src);

   842   

   843     std_log(LOG_FILENAME_LINE, "Test Successful");

   844   create_xml(0);

   845 }

   846 

   847 /* Test arithmetic subtraction of fractions */

   848 void test_value_subtract_fraction()

   849 {

   850   GValue result = { 0 };

   851   GValue src1 = { 0 };

   852   GValue src2 = { 0 };

   853   

   854     xmlfile = "test_value_subtract_fraction";

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

   856 

   857 

   858   /* Subtract 1/4 from 1/2 */

   859   g_value_init (&src1, GST_TYPE_FRACTION);

   860   g_value_init (&src2, GST_TYPE_FRACTION);

   861   g_value_init (&result, GST_TYPE_FRACTION);

   862   gst_value_set_fraction (&src1, 1, 2);

   863   gst_value_set_fraction (&src2, 1, 4);

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

   865   

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

   867   

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

   869   

   870 

   871   g_value_unset (&src1);

   872   g_value_unset (&src2);

   873   g_value_unset (&result);

   874 

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

   876   g_value_init (&src1, GST_TYPE_FRACTION);

   877   g_value_init (&src2, GST_TYPE_FRACTION);

   878   g_value_init (&result, GST_TYPE_FRACTION);

   879   gst_value_set_fraction (&src1, 7, 8);

   880   gst_value_set_fraction (&src2, 1, 12);

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

   882   

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

   884   

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

   886   

   887 

   888   g_value_unset (&src1);

   889   g_value_unset (&src2);

   890   g_value_unset (&result);

   891 

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

   893   g_value_init (&src1, GST_TYPE_FRACTION);

   894   g_value_init (&src2, GST_TYPE_FRACTION);

   895   g_value_init (&result, GST_TYPE_FRACTION);

   896   gst_value_set_fraction (&src1, 4, 3);

   897   gst_value_set_fraction (&src2, 12, 13);

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

   899   

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

   901   

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

   903   

   904 

   905   g_value_unset (&src1);

   906   g_value_unset (&src2);

   907   g_value_unset (&result);

   908   

   909     std_log(LOG_FILENAME_LINE, "Test Successful");

   910   create_xml(0);

   911 

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

   913 }

   914 

   915 

   916 void test_value_compare()

   917 {

   918   GValue value1 = { 0 };

   919   GValue value2 = { 0 };

   920   GValue tmp = { 0 };

   921   

   922     xmlfile = "test_value_compare";

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

   924 

   925 

   926   g_value_init (&value1, G_TYPE_INT);

   927   g_value_set_int (&value1, 10);

   928   g_value_init (&value2, G_TYPE_INT);

   929   g_value_set_int (&value2, 20);

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

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

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

   933   g_value_unset (&value1);

   934   g_value_unset (&value2);

   935 

   936   g_value_init (&value1, G_TYPE_DOUBLE);

   937   g_value_set_double (&value1, 10);

   938   g_value_init (&value2, G_TYPE_DOUBLE);

   939   g_value_set_double (&value2, 20);

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

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

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

   943   g_value_unset (&value1);

   944   g_value_unset (&value2);

   945 

   946   g_value_init (&value1, G_TYPE_STRING);

   947   g_value_set_string (&value1, "a");

   948   g_value_init (&value2, G_TYPE_STRING);

   949   g_value_set_string (&value2, "b");

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

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

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

   953   g_value_unset (&value1);

   954   g_value_unset (&value2);

   955 

   956   g_value_init (&value1, GST_TYPE_FOURCC);

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

   958   g_value_init (&value2, GST_TYPE_FOURCC);

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

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

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

   962   g_value_unset (&value1);

   963   g_value_unset (&value2);

   964 

   965   /* comparing 2/3 with 3/4 */

   966   g_value_init (&value1, GST_TYPE_FRACTION);

   967   gst_value_set_fraction (&value1, 2, 3);

   968   g_value_init (&value2, GST_TYPE_FRACTION);

   969   gst_value_set_fraction (&value2, 3, 4);

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

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

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

   973   g_value_unset (&value1);

   974   g_value_unset (&value2);

   975 

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

   977   g_value_init (&value1, GST_TYPE_FRACTION);

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

   979   g_value_init (&value2, GST_TYPE_FRACTION);

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

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

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

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

   984   g_value_unset (&value1);

   985   g_value_unset (&value2);

   986 

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

   988   g_value_init (&value1, GST_TYPE_FRACTION);

   989   gst_value_set_fraction (&value1, 10, 100);

   990   g_value_init (&value2, GST_TYPE_FRACTION);

   991   gst_value_set_fraction (&value2, 200, 2000);

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

   993   g_value_unset (&value1);

   994   g_value_unset (&value2);

   995 

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

   997   g_value_init (&value1, GST_TYPE_FRACTION);

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

   999   g_value_init (&value2, GST_TYPE_FRACTION);

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

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

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

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

  1004   g_value_unset (&value1);

  1005   g_value_unset (&value2);

  1006 

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

  1008   g_value_init (&value1, GST_TYPE_LIST);

  1009   g_value_init (&tmp, G_TYPE_INT);

  1010   g_value_set_int (&tmp, 1);

  1011   gst_value_list_append_value (&value1, &tmp);

  1012   g_value_set_int (&tmp, 2);

  1013   gst_value_list_append_value (&value1, &tmp);

  1014   g_value_set_int (&tmp, 3);

  1015   gst_value_list_append_value (&value1, &tmp);

  1016   g_value_set_int (&tmp, 4);

  1017   gst_value_list_append_value (&value1, &tmp);

  1018 

  1019   g_value_init (&value2, GST_TYPE_LIST);

  1020   g_value_set_int (&tmp, 4);

  1021   gst_value_list_append_value (&value2, &tmp);

  1022   g_value_set_int (&tmp, 3);

  1023   gst_value_list_append_value (&value2, &tmp);

  1024   g_value_set_int (&tmp, 2);

  1025   gst_value_list_append_value (&value2, &tmp);

  1026   g_value_set_int (&tmp, 1);

  1027   gst_value_list_append_value (&value2, &tmp);

  1028 

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

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

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

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

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

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

  1035 

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

  1037   /* Lists with different sizes are unequal */

  1038   g_value_set_int (&tmp, 1);

  1039   gst_value_list_append_value (&value2, &tmp);

  1040 

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

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

  1043 

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

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

  1046   g_value_set_int (&tmp, 5);

  1047   gst_value_list_append_value (&value1, &tmp);

  1048 

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

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

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

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

  1053 

  1054   g_value_unset (&value1);

  1055   g_value_unset (&value2);

  1056   g_value_unset (&tmp);

  1057 

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

  1059   g_value_init (&value1, GST_TYPE_ARRAY);

  1060   g_value_init (&tmp, G_TYPE_INT);

  1061   g_value_set_int (&tmp, 1);

  1062   gst_value_array_append_value (&value1, &tmp);

  1063   g_value_set_int (&tmp, 2);

  1064   gst_value_array_append_value (&value1, &tmp);

  1065   g_value_set_int (&tmp, 3);

  1066   gst_value_array_append_value (&value1, &tmp);

  1067   g_value_set_int (&tmp, 4);

  1068   gst_value_array_append_value (&value1, &tmp);

  1069 

  1070   g_value_init (&value2, GST_TYPE_ARRAY);

  1071   g_value_set_int (&tmp, 4);

  1072   gst_value_array_append_value (&value2, &tmp);

  1073   g_value_set_int (&tmp, 3);

  1074   gst_value_array_append_value (&value2, &tmp);

  1075   g_value_set_int (&tmp, 2);

  1076   gst_value_array_append_value (&value2, &tmp);

  1077   g_value_set_int (&tmp, 1);

  1078   gst_value_array_append_value (&value2, &tmp);

  1079 

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

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

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

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

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

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

  1086 

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

  1088   /* Arrays with different sizes are unequal */

  1089   g_value_unset (&value2);

  1090   g_value_init (&value2, GST_TYPE_ARRAY);

  1091   g_value_copy (&value1, &value2);

  1092 

  1093   g_value_set_int (&tmp, 1);

  1094   gst_value_array_append_value (&value2, &tmp);

  1095 

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

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

  1098   /* order should not matter */

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

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

  1101 

  1102   g_value_unset (&value1);

  1103   g_value_unset (&value2);

  1104   g_value_unset (&tmp);

  1105   

  1106     std_log(LOG_FILENAME_LINE, "Test Successful");

  1107   create_xml(0);

  1108 }

  1109 

  1110 

  1111 void test_value_subtract_int()

  1112 {

  1113   GValue dest = { 0 };

  1114   GValue src1 = { 0 };

  1115   GValue src2 = { 0 };

  1116   const GValue *tmp;

  1117   gboolean ret;

  1118   

  1119     xmlfile = "test_value_subtract_int";

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

  1121 

  1122 

  1123   /*  int <-> int

  1124    */

  1125   g_value_init (&src1, G_TYPE_INT);

  1126   g_value_set_int (&src1, 10);

  1127   g_value_init (&src2, G_TYPE_INT);

  1128   g_value_set_int (&src2, 20);

  1129   /* subtract as in sets, result is 10 */

  1130   ret = gst_value_subtract (&dest, &src1, &src2);

  1131   fail_unless (ret == TRUE);

  1132   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);

  1133   g_value_unset (&dest);

  1134 

  1135   /* same values, yields empty set */