/* GStreamer

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

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

 *

 * gstvalue.c: Unit tests for GstValue

 *

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

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

 * License as published by the Free Software Foundation; either

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

 *

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

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

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

 * Library General Public License for more details.

 *

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

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

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

 * Boston, MA 02111-1307, USA.

 */

#include <gst/gst_global.h>

#include <gst/check/gstcheck.h>

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

#include "std_log_result.h" 

#define LOG_FILENAME_LINE __FILE__, __LINE__

//char* xmlfile = "gstvalue";

void create_xml(int result)

{

    if(result)

    {

        assert_failed = 1;

    } 

    testResultXml(xmlfile);

    close_log_file();

    if(result)

    {

        exit (-1);

    }    

}

void test_deserialize_buffer()

{

  GValue value = { 0 };

  GstBuffer *buf;

    xmlfile = "test_deserialize_buffer";

  std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_buffer");

  g_value_init (&value, GST_TYPE_BUFFER);

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

  /* does not increase the refcount */

  buf = GST_BUFFER (gst_value_get_mini_object (&value));

  ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);

  /* does not increase the refcount */

  buf = gst_value_get_buffer (&value);

  ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);

  /* cleanup */

  g_value_unset (&value);

    std_log(LOG_FILENAME_LINE, "Test Successful");

  create_xml(0);

}

/* create and serialize a buffer */

void test_serialize_buffer()

{

  GValue value = { 0 };

  GstBuffer *buf;

  gchar *serialized;

  static const char *buf_data = "1234567890abcdef";

  gint len;

    xmlfile = "test_serialize_buffer";

  std_log(LOG_FILENAME_LINE, "Test Started test_serialize_buffer");

  len = strlen (buf_data);

  buf = gst_buffer_new_and_alloc (len);

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

  ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);

  /* and assign buffer to mini object */

  g_value_init (&value, GST_TYPE_BUFFER);

  gst_value_take_buffer (&value, buf);

  ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);

  /* now serialize it */

  serialized = gst_value_serialize (&value);

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

  fail_unless (serialized != NULL);

  /* refcount should not change */

  ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);

  /* cleanup */

  g_free (serialized);

  g_value_unset (&value);

  /* take NULL buffer */

  g_value_init (&value, GST_TYPE_BUFFER);

  GST_DEBUG ("setting NULL buffer");

  gst_value_take_buffer (&value, NULL);

  /* now serialize it */

  GST_DEBUG ("serializing NULL buffer");

  serialized = gst_value_serialize (&value);

  /* should return NULL */

  fail_unless (serialized == NULL);

  g_free (serialized);

  g_value_unset (&value);

    std_log(LOG_FILENAME_LINE, "Test Successful");

  create_xml(0);

}

void test_deserialize_gint()

{

  GValue value = { 0 };

  const char *strings[] = {

    "123456",

    "-123456",

    "0xFFFF",

    "0x0000FFFF",

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

    "0x7FFFFFFF",

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

    "0x80000000",

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

    "0xFFFFFFFF80000000",

    "0xFF000000",

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

    "0xFFFFFFFF",

    "0xFFFFFFFF",

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

    "0xFFFFFFFFFFFFFFFF",

    "0xFFFFFFFFFFFFFFFF",

    "0xEFFFFFFF",

  };

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

  gint results[] = {

    123456,

    -123456,

    0xFFFF,

    0xFFFF,

    0x7FFFFFFF,

    (gint) 0x80000000,

    (gint) 0x80000000,

    (gint) 0xFF000000,

    -1,

    (gint) 0xFFFFFFFF,

    -1,

    (gint) 0xFFFFFFFFFFFFFFFFLL,

    (gint) 0xEFFFFFFF,

  };

  int i;

    xmlfile = "test_deserialize_gint";

  std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_gint");

  g_value_init (&value, G_TYPE_INT);

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

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

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

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

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

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

  }

    std_log(LOG_FILENAME_LINE, "Test Successful");

  create_xml(0);

}

void test_deserialize_gint_failures()

{

  GValue value = { 0 };

  const char *strings[] = {

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

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

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

    "0xF000000000000000",

    "0xFFFFFFF000000000",

    "0xFFFFFFFF00000000",

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

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

    "0x10000000000000000000000000000000000000000000",

  };

  int i;

    xmlfile = "test_deserialize_gint_failures";

  std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_gint_failures");

  g_value_init (&value, G_TYPE_INT);

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

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

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

  }

    std_log(LOG_FILENAME_LINE, "Test Successful");

  create_xml(0);

}

void test_deserialize_guint()

{

  GValue value = { 0 };

  const char *strings[] = {

    "123456",

    "-123456",

    "0xFFFF",

    "0x0000FFFF",

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

    "0x7FFFFFFF",

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

    "0x80000000",

    "2147483648",

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

    "0xFFFFFFFF80000000",

    /* a value typically used for rgb masks */

    "0xFF000000",

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

    "0xFFFFFFFF",

    "0xFFFFFFFF",

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

    "0xFFFFFFFFFFFFFFFF",

    "0xEFFFFFFF",

  };

  guint results[] = {

    123456,

    (guint) - 123456,

    0xFFFF,

    0xFFFF,

    0x7FFFFFFF,

    0x80000000,

    (guint) 2147483648LL,

    0x80000000,

    0xFF000000,

    0xFFFFFFFF,

    G_MAXUINT,

    (guint) 0xFFFFFFFFFFFFFFFFLL,

    0xEFFFFFFF,

  };

  int i;

    xmlfile = "test_deserialize_guint";

  std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_guint");

  g_value_init (&value, G_TYPE_UINT);

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

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

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

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

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

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

  }

    std_log(LOG_FILENAME_LINE, "Test Successful");

  create_xml(0);

}

void test_deserialize_guint_failures()

{

  GValue value = { 0 };

  const char *strings[] = {

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

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

#if 0

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

 * the target format */

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

    "0xF000000000000000",

    "0xFFFFFFF000000000",

    "0xFFFFFFFF00000000",

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

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

    "0x10000000000000000000000000000000000000000000",

#endif

  };

  int i;

    xmlfile = "test_deserialize_guint_failures";

  std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_guint_failures");

  g_value_init (&value, G_TYPE_UINT);

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

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

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

  }

    std_log(LOG_FILENAME_LINE, "Test Successful");

  create_xml(0);

}

void test_deserialize_gint64()

{

  GValue value = { 0 };

  const char *strings[] = {

    "12345678901",

    "-12345678901",

  };

  gint64 results[] = {

    12345678901LL,

    -12345678901LL,

  };

  int i;

    xmlfile = "test_deserialize_gint64";

  std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_gint64");

  g_value_init (&value, G_TYPE_INT64);

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

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

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

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

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

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

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

  }

    std_log(LOG_FILENAME_LINE, "Test Successful");

  create_xml(0);

}

void test_deserialize_gstfraction()

{

  GValue value = { 0 };

  const char *strings[] = {

    "4/5",

    "-8/9"

  };

  gint64 result_numers[] = {

    4,

    -8

  };

  gint64 result_denoms[] = {

    5,

    9

  };

  int i;

    xmlfile = "test_deserialize_gstfraction";

  std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_gstfraction");

  g_value_init (&value, GST_TYPE_FRACTION);

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

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

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

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

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

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

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

    fail_unless (gst_value_get_fraction_denominator (&value) ==

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

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

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

  }

    std_log(LOG_FILENAME_LINE, "Test Successful");

  create_xml(0);

}

void test_serialize_flags()

{

  GValue value = { 0 };

  gchar *string;

  GstSeekFlags flags[] = {

    0,

    GST_SEEK_FLAG_NONE,

    GST_SEEK_FLAG_FLUSH,

    GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,

  };

  const char *results[] = {

    "GST_SEEK_FLAG_NONE",

    "GST_SEEK_FLAG_NONE",

    "GST_SEEK_FLAG_FLUSH",

    "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",

  };

  int i;

    xmlfile = "test_serialize_flags";

  std_log(LOG_FILENAME_LINE, "Test Started test_serialize_flags");

  g_value_init (&value, GST_TYPE_SEEK_FLAGS);

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

    g_value_set_flags (&value, flags[i]);

    string = gst_value_serialize (&value);

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

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

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

    g_free (string);

  }

    std_log(LOG_FILENAME_LINE, "Test Successful");

  create_xml(0);

}

void test_deserialize_flags()

{

  GValue value = { 0 };

  const char *strings[] = {

    "",

    "0",

    "GST_SEEK_FLAG_NONE",

    "GST_SEEK_FLAG_FLUSH",

    "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",

  };

  GstSeekFlags results[] = {

    GST_SEEK_FLAG_NONE,

    GST_SEEK_FLAG_NONE,

    GST_SEEK_FLAG_NONE,

    GST_SEEK_FLAG_FLUSH,

    GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,

  };

  int i;

    xmlfile = "test_deserialize_flags";

  std_log(LOG_FILENAME_LINE, "Test Started test_deserialize_flags");

  g_value_init (&value, GST_TYPE_SEEK_FLAGS);

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

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

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

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

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

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

  }

    std_log(LOG_FILENAME_LINE, "Test Successful");

  create_xml(0);

}

void test_serialize_deserialize_format_enum()

{

  GstStructure *s, *s2;

  GstFormat foobar_fmt;

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

    xmlfile = "test_serialize_deserialize_format_enum";

  std_log(LOG_FILENAME_LINE, "Test Started test_serialize_deserialize_format_enum");

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

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

  fail_unless (foobar_fmt != GST_FORMAT_UNDEFINED);

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

      GST_FORMAT_BYTES, "format2", GST_TYPE_FORMAT, GST_FORMAT_TIME,

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

      GST_TYPE_FORMAT, foobar_fmt, NULL);

  str = gst_structure_to_string (s);

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

  fail_unless (str != NULL);

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

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

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

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

  s2 = gst_structure_from_string (str, &end);

  fail_unless (s2 != NULL);