int main (int argc, char *argv[])
{
int i;
int ret;
int failed = 0;
OilParameter param;
//xmlfile = "proto3";
std_log(LOG_FILENAME_LINE, "Test Started testsuite_proto3");
for(i=0;good_params[i];i++){
ret = oil_param_from_string (¶m, good_params[i]);
if (!ret) {
printf("***ERROR***\n");
std_log(LOG_FILENAME_LINE, "***ERROR***");
failed = 1;
}
print_param (¶m);
}
for(i=0;bad_params[i];i++){
ret = oil_param_from_string (¶m, bad_params[i]);
if (ret) {
printf("***ERROR***\n");
std_log(LOG_FILENAME_LINE, "***ERROR***");
failed = 1;
}
}
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
return failed;
}
void test_lock_start()
{
GstTask *t;
gboolean ret;
//xmlfile = "test_lock_start";
std_log(LOG_FILENAME_LINE, "Test Started test_lock_start");
t = gst_task_create (task_func, NULL);
fail_if (t == NULL);
TEST_ASSERT_FAIL
gst_task_set_lock (t, &task_mutex);
task_cond = g_cond_new ();
task_lock = g_mutex_new ();
g_mutex_lock (task_lock);
GST_DEBUG ("starting");
ret = gst_task_start (t);
fail_unless (ret == TRUE);
TEST_ASSERT_FAIL
/* wait for it to spin up */
GST_DEBUG ("waiting");
g_cond_wait (task_cond, task_lock);
GST_DEBUG ("done waiting");
g_mutex_unlock (task_lock);
/* cannot set mutex now */
ASSERT_WARNING (gst_task_set_lock (t, &task_mutex));//b failing
GST_DEBUG ("joining");
ret = gst_task_join (t);
fail_unless (ret == TRUE);
TEST_ASSERT_FAIL
gst_object_unref (t);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
void test_no_lock()
{
GstTask *t;
gboolean ret;
//xmlfile = "test_no_lock";
std_log(LOG_FILENAME_LINE, "Test Started test_no_lock");
t = gst_task_create (task_func, NULL);
fail_if (t == NULL);
TEST_ASSERT_FAIL
/* stop should be possible without lock */
gst_task_stop (t);
/* pause should give a warning */
ASSERT_WARNING (ret = gst_task_pause (t)); //b failing
fail_unless (ret == FALSE);
TEST_ASSERT_FAIL
/* start should give a warning */
ASSERT_WARNING (ret = gst_task_start (t));
fail_unless (ret == FALSE);
TEST_ASSERT_FAIL
/* stop should be possible without lock */
gst_task_stop (t);
gst_object_unref (t);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
int main()
{
DBusMessage* msg;
msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
if(!msg)
{
std_log(LOG_FILENAME_LINE,"Fail to create Message");
create_xml(1);
return 1;
}
if(DBUS_MESSAGE_TYPE_METHOD_CALL != dbus_message_get_type(msg))
{
std_log(LOG_FILENAME_LINE,"Mismatch in Message type.");
create_xml(1);
return 1;
}
std_log(LOG_FILENAME_LINE,"Test Successful");
create_xml(0);
return 0;
}
void test_gdouble_to_guint64()
{
gdouble from[] = { 0., 1., 100., 10000., 9223372036854775808.,
9223372036854775809., 13835058055282163712.
};
guint64 to[] = { 0, 1, 100, 10000, (guint64) (1) << 63,
((guint64) (1) << 63) + 1,
((guint64) (1) << 63) + (G_GINT64_CONSTANT (1) << 62)
};
guint64 tolerance[] = { 0, 0, 0, 0, 0, 1, 1 };
gint i;
gdouble result;
guint64 delta;
xmlfile = "gstutils_test_gdouble_to_guint64";
std_log(LOG_FILENAME_LINE, "Test Started gstutils_test_gdouble_to_guint64");
for (i = 0; i < G_N_ELEMENTS (from); ++i) {
result = gst_util_gdouble_to_guint64 (from[i]);
delta = ABS (to[i] - result);
fail_unless (delta <= tolerance[i],
"Could not convert %f: %" G_GUINT64_FORMAT
" -> %d, got %d instead, delta of %e with tolerance of %e",
i, from[i], to[i], result, delta, tolerance[i]);
}
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
void test_yuv2rgbx_sub2_u8()
{
uint8_t src1[MAX_SIZE], src2[MAX_SIZE], src3[MAX_SIZE];
uint8_t res[RES_SIZE],check[RES_SIZE]={0,134,0,0,0,135,0,0,0,135,0,0,0,136,0,0,0,136,0,0,0,137,0,0,0,137,0,0,0,138,0,0,0,138,0,0,0,139,0,0};
int i;
for(i=0;i<MAX_SIZE;i++)
{
src1[i]=i;
src2[i]=i+1;
src3[i]=i+1;
}
for(i=0;i<RES_SIZE;i++)
res[i]=0;
oil_yuv2rgbx_sub2_u8(res,src1,src2,src3,MAX_SIZE);
for(i=0;i<RES_SIZE;i++)
if(res[i] == check[i])
{
std_log(LOG_FILENAME_LINE,"oil_yuv2rgbx_sub2_u8 successful, res[%d] = %d", i,res[i]);
}
else
{
assert_failed=1;
std_log(LOG_FILENAME_LINE,"oil_yuv2rgbx_sub2_u8 unsuccessful, Expected =%d,Obtained =%d",check[i],res[i]);
}
}
int main()
{
DBusError src;
DBusError dest;
char err[] = "Sample Error0";
dbus_error_init(&src);
dbus_error_init(&dest);
dbus_set_error(&src, err, NULL);
dbus_move_error(&src, &dest);
if(!CheckMovedError(&src, &dest, err))
{
std_log(LOG_FILENAME_LINE, "Test Fail");
dbus_error_free(&src);
dbus_error_free(&dest);
create_xml(1);
return 1;
}
else
{
std_log(LOG_FILENAME_LINE, "Test Successful");
dbus_error_free(&dest);
create_xml(0);
return 0;
}
}
void test_flags()
{
GstElement *element;
GError *err = NULL;
xmlfile = "test_flags";
std_log(LOG_FILENAME_LINE, "Test Started test_flags");
/* avoid misleading 'no such element' error debug messages when using cvs */
if (!g_getenv ("GST_DEBUG"))
gst_debug_set_default_threshold (GST_LEVEL_NONE);
/* default behaviour is to return any already constructed bins/elements */
element = gst_parse_launch_full ("fakesrc ! coffeesink", NULL, 0, &err);
fail_unless (err != NULL, "expected error");
fail_unless_equals_int (err->code, GST_PARSE_ERROR_NO_SUCH_ELEMENT);
fail_unless (element != NULL, "expected partial pipeline/element");
g_error_free (err);
err = NULL;
gst_object_unref (element);
/* test GST_PARSE_FLAG_FATAL_ERRORS */
element = gst_parse_launch_full ("fakesrc ! coffeesink", NULL,
GST_PARSE_FLAG_FATAL_ERRORS, &err);
fail_unless (err != NULL, "expected error");
fail_unless_equals_int (err->code, GST_PARSE_ERROR_NO_SUCH_ELEMENT);
fail_unless (element == NULL, "expected NULL return with FATAL_ERRORS");
g_error_free (err);
err = NULL;
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
static inline void
_rw_check_init (bool init, int line, const char *func)
{
if (init && !driver_initialized) {
fprintf (stderr, "%s:%d: %s: test driver already initialized\n",
__FILE__, line, func);
std_log(LOG_FILENAME_LINE,"%s:%d: %s: test driver already initialized\n",
__FILE__, line, func);
abort ();
}
if (!init && driver_initialized) {
fprintf (stderr, "%s:%d: %s: test driver not initialized yet\n",
__FILE__, line, func);
std_log(LOG_FILENAME_LINE,"%s:%d: %s: test driver not initialized yet\n",
__FILE__, line, func);
abort ();
}
if (driver_finished) {
fprintf (stderr, "%s:%d: %s: test finished, cannot call\n",
__FILE__, line, func);
std_log(LOG_FILENAME_LINE,"%s:%d: %s: test finished, cannot call\n",
__FILE__, line, func);
}
}
static void
test_fill (const std::size_t N)
{
rw_info (0, 0, 0,
"template <class %s, class %s> "
"void std::fill (%1$s, %1$s, const %2$s&)",
"ForwardIterator", "T");
if (rw_opt_no_fwd_iter) {
rw_note (0, __FILE__, __LINE__, "ForwardIterator test disabled");
std_log(LOG_FILENAME_LINE,"ForwardIterator test disabled");
}
else {
test_fill (N, FwdIter<X>(), (X*)0);
}
if (rw_opt_no_bidir_iter) {
rw_note (0, __FILE__, __LINE__, "BidirectionalIterator test disabled");
std_log(LOG_FILENAME_LINE,"BidirectionalIterator test disabled");
}
else {
test_fill (N, BidirIter<X>(), (X*)0);
}
if (rw_opt_no_rnd_iter) {
rw_note (0, __FILE__, __LINE__, "RandomAccessIterator test disabled");
std_log(LOG_FILENAME_LINE,"RandomAccessIterator test disabled");
}
else {
test_fill (N, RandomAccessIter<X>(), (X*)0);
}
}
int
main (int argc,
char *argv[])
{
GstElement *pipeline;
GstElement *source, *filter, *sink;
xmlfile = "test_elementlink";
std_log(LOG_FILENAME_LINE, "Test Started element link");
/* init */
gst_init (&argc, &argv);
/* create pipeline */
pipeline = gst_pipeline_new ("my-pipeline");
/* create elements */
source = gst_element_factory_make ("fakesrc", "source");
filter = gst_element_factory_make ("identity", "filter");
sink = gst_element_factory_make ("fakesink", "sink");
/* must add elements to pipeline before linking them */
gst_bin_add_many (GST_BIN (pipeline), source, filter, sink, NULL);
/* link */
if (!gst_element_link_many (source, filter, sink, NULL)) {
g_warning ("Failed to link elements!");
}
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
/*** block b from ../../../docs/manual/basics-elements.xml ***/
return 0;
/*** block c from ../../../docs/manual/basics-elements.xml ***/
}
int main()
{
DBusError error;
char* err = "Sample Error0";
dbus_error_init(&error);
dbus_set_error(&error, err, NULL);
if(strcmp(err, error.name))
{
std_log(LOG_FILENAME_LINE, "Mismatch in Error Name");
create_xml(1);
return 1;
}
if(strcmp(err, error.message))
{
std_log(LOG_FILENAME_LINE, "Message set to :: %s", error.message);
std_log(LOG_FILENAME_LINE, "Message is not set to NULL");
create_xml(1);
return 1;
}
dbus_error_free(&error);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
return 0;
}
int main()
{
DBusMessage* msg;
char* path = "/";
msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
if(!msg)
{
std_log(LOG_FILENAME_LINE,"Fail to create Message");
create_xml(1);
return 1;
}
if(!dbus_message_set_path(msg, path))
{
std_log(LOG_FILENAME_LINE,"Not enough Memory.");
create_xml(1);
return 1;
}
if(strcmp(path, dbus_message_get_path(msg)))
{
std_log(LOG_FILENAME_LINE,"Path is not correct");
create_xml(1);
return 1;
}
std_log(LOG_FILENAME_LINE,"Test Successful");
create_xml(0);
return 0;
}
void test_pipelines()
{
gint quality;
xmlfile = "test_pipelines";
std_log(LOG_FILENAME_LINE, "Test Started test_pipelines");
/* Test qualities 0, 5 and 10 */
for (quality = 0; quality < 11; quality += 5) {
test_pipeline (8, FALSE, 44100, 48000, quality);
test_pipeline (8, FALSE, 48000, 44100, quality);
test_pipeline (16, FALSE, 44100, 48000, quality);
test_pipeline (16, FALSE, 48000, 44100, quality);
test_pipeline (24, FALSE, 44100, 48000, quality);
test_pipeline (24, FALSE, 48000, 44100, quality);
test_pipeline (32, FALSE, 44100, 48000, quality);
test_pipeline (32, FALSE, 48000, 44100, quality);
test_pipeline (32, TRUE, 44100, 48000, quality);
test_pipeline (32, TRUE, 48000, 44100, quality);
test_pipeline (64, TRUE, 44100, 48000, quality);
test_pipeline (64, TRUE, 48000, 44100, quality);
}
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
int main()
{
std_log(LOG_FILENAME_LINE,"[Test Case for intrusive_ptr_test]");
n_element_type::test();
n_constructors::test();
n_destructor::test();
n_assignment::test();
n_access::test();
n_swap::test();
n_comparison::test();
n_static_cast::test();
n_dynamic_cast::test();
n_transitive::test();
n_report_1::test();
#ifdef __SYMBIAN32__
int failures = boost::report_errors();
if(failures)
{
std_log(LOG_FILENAME_LINE,"Result : Failed");
assert_failed = true;
}
else
{
std_log(LOG_FILENAME_LINE,"Result : Passed");
}
std_log(LOG_FILENAME_LINE,"[End Test Case ]");
#endif
testResultXml("intrusive_ptr_test");
close_log_file();
return failures;
}
void test()
{
OilTest *test;
OilParameter *p;
int16_t *data;
int n;
int footer;
int footer_increment = 10;
OilFunctionClass *klass;
OilFunctionImpl *impl;
klass = oil_class_get("abs_f32_f32");
if(klass != NULL)
{
test = (OilTest *)oil_test_new(klass);
if(test != NULL)
{
impl = (OilFunctionImpl*)calloc(sizeof(OilFunctionImpl), 0);
impl->func = (void*)abs_f32_f32_test;
impl->name = "abs_f32_f32_test";
impl->klass = klass;
oil_test_set_impl(test, impl);
if(test->impl != impl)
{
std_log(LOG_FILENAME_LINE,"oil_test_set_impl failed. errno = %d", errno);
assert_failed = 1;
}
p = &test->params[1];
footer = p->test_footer;
oil_test_set_test_footer(test, p, OIL_TEST_FOOTER+footer_increment);
if(p->test_footer != footer+footer_increment)
{
std_log(LOG_FILENAME_LINE,"oil_test_set_test_footer failed. errno = %d", errno);
assert_failed = 1;
}
data = (int16_t *)oil_test_get_source_data (test, OIL_ARG_SRC1);
n = oil_test_get_arg_pre_n (test, OIL_ARG_SRC1);
oil_test_cleanup(test);
oil_test_free(test);
}
else
{
std_log(LOG_FILENAME_LINE,"oil_test_new returned NULL. errno = %d", errno);
assert_failed = 1;
}
}
else
{
std_log(LOG_FILENAME_LINE,"oil_class_get returned NULL. errno = %d", errno);
assert_failed = 1;
}
}
void test_parse_launch_errors()
{
GstElement *pipe;
GError *err;
const gchar *arr[] = { "fakesrc", "fakesink", NULL };
std_log(LOG_FILENAME_LINE, "Test started test_parse_launch_errors");
err = NULL;
pipe = gst_parse_launch ("fakesrc ! fakesink", &err);
fail_unless (err != NULL, "expected an error, but did not get one");
fail_unless (pipe == NULL, "got pipeline, but expected NULL");
fail_unless (err->domain == GST_CORE_ERROR);
fail_unless (err->code == GST_CORE_ERROR_DISABLED);
g_error_free (err);
err = NULL;
pipe = gst_parse_bin_from_description ("fakesrc ! fakesink", TRUE, &err);
fail_unless (err != NULL, "expected an error, but did not get one");
fail_unless (pipe == NULL, "got pipeline, but expected NULL");
fail_unless (err->domain == GST_CORE_ERROR);
fail_unless (err->code == GST_CORE_ERROR_DISABLED);
g_error_free (err);
err = NULL;
pipe = gst_parse_launchv (arr, &err);
fail_unless (err != NULL, "expected an error, but did not get one");
fail_unless (pipe == NULL, "got pipeline, but expected NULL");
fail_unless (err->domain == GST_CORE_ERROR);
fail_unless (err->code == GST_CORE_ERROR_DISABLED);
g_error_free (err);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
void test_is_writable()
{
GstBuffer *buffer;
GstMiniObject *mobj;
xmlfile = "gstminiobject_test_is_writable";
std_log(LOG_FILENAME_LINE, "Test Started test_is_writable");
buffer = gst_buffer_new_and_alloc (4);
mobj = GST_MINI_OBJECT (buffer);
fail_unless (gst_mini_object_is_writable (mobj),
"A buffer with one ref should be writable");
GST_MINI_OBJECT_FLAG_SET (mobj, GST_MINI_OBJECT_FLAG_READONLY);
fail_if (gst_mini_object_is_writable (mobj),
"A buffer with READONLY set should not be writable");
GST_MINI_OBJECT_FLAG_UNSET (mobj, GST_MINI_OBJECT_FLAG_READONLY);
fail_unless (gst_mini_object_is_writable (mobj),
"A buffer with one ref and READONLY not set should be writable");
fail_if (gst_mini_object_ref (mobj) == NULL, "Could not ref the mobj");
fail_if (gst_mini_object_is_writable (mobj),
"A buffer with two refs should not be writable");
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
void test_refcounts()
{
GstNetTimeProvider *ntp;
GstClock *clock;
xmlfile = "test_refcounts";
std_log(LOG_FILENAME_LINE, "Test Started test_refcounts");
clock = gst_system_clock_obtain ();
fail_unless (clock != NULL, "failed to get system clock");
/* one for gstreamer, one for us */
ASSERT_OBJECT_REFCOUNT (clock, "system clock", 2);
ntp = gst_net_time_provider_new (clock, NULL, 0);
fail_unless (ntp != NULL, "failed to create net time provider");
/* one for ntp, one for gstreamer, one for us */
ASSERT_OBJECT_REFCOUNT (clock, "system clock", 3);
/* one for us */
ASSERT_OBJECT_REFCOUNT (ntp, "net time provider", 1);
gst_object_unref (ntp);
ASSERT_OBJECT_REFCOUNT (clock, "net time provider", 2);
gst_object_unref (clock);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
void test_make_writable()
{
GstBuffer *buffer;
GstMiniObject *mobj, *mobj2, *mobj3;
xmlfile = "gstminiobject_test_make_writable";
std_log(LOG_FILENAME_LINE, "Test Started test_make_writable");
buffer = gst_buffer_new_and_alloc (4);
mobj = GST_MINI_OBJECT (buffer);
mobj2 = gst_mini_object_make_writable (mobj);
fail_unless (GST_IS_BUFFER (mobj2), "make_writable did not return a buffer");
fail_unless (mobj == mobj2,
"make_writable returned a copy for a buffer with refcount 1");
mobj2 = gst_mini_object_ref (mobj);
mobj3 = gst_mini_object_make_writable (mobj);
fail_unless (GST_IS_BUFFER (mobj3), "make_writable did not return a buffer");
fail_if (mobj == mobj3,
"make_writable returned same object for a buffer with refcount > 1");
fail_unless (GST_MINI_OBJECT_REFCOUNT_VALUE (mobj) == 1,
"refcount of original mobj object should be back to 1");
mobj2 = gst_mini_object_make_writable (mobj);
fail_unless (GST_IS_BUFFER (mobj2), "make_writable did not return a buffer");
fail_unless (mobj == mobj2,
"make_writable returned a copy for a buffer with refcount 1");
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
void test_no_clients()
{
GstElement *sink;
GstBuffer *buffer;
GstCaps *caps;
std_log(LOG_FILENAME_LINE, "Test Started test_no_clients");
sink = setup_multifdsink ();
ASSERT_SET_STATE (sink, GST_STATE_PLAYING, GST_STATE_CHANGE_ASYNC);
caps = gst_caps_from_string ("application/x-gst-check");
buffer = gst_buffer_new_and_alloc (4);
gst_buffer_set_caps (buffer, caps);
gst_caps_unref (caps);
fail_unless (gst_pad_push (mysrcpad, buffer) == GST_FLOW_OK);
GST_DEBUG ("cleaning up multifdsink");
ASSERT_SET_STATE (sink, GST_STATE_NULL, GST_STATE_CHANGE_SUCCESS); //commented bz..select() blocks indefinitly
cleanup_multifdsink (sink);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
void test_unref_threaded()
{
GstBuffer *buffer;
GstMiniObject *mobj;
int i;
xmlfile = "gstminiobject_test_unref_threaded";
std_log(LOG_FILENAME_LINE, "Test Started test_unref_threaded");
buffer = gst_buffer_new_and_alloc (4);
mobj = GST_MINI_OBJECT (buffer);
for (i = 0; i < num_threads * refs_per_thread; ++i)
gst_mini_object_ref (mobj);
MAIN_START_THREADS (num_threads, thread_unref, mobj);
MAIN_STOP_THREADS ();
ASSERT_MINI_OBJECT_REFCOUNT (mobj, "miniobject", 1);
/* final unref */
gst_mini_object_unref (mobj);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
void test_without_implements_interface()
{
GstElement *element;
std_log(LOG_FILENAME_LINE, "Test Started test_without_implements_interface");
/* we shouldn't crash if someone tries to use
* gst_element_implements_interface() on an element which doesn't implement
* the GstImplementsInterface (neither if the element does implement the
* requested interface, nor if it doesn't) */
element = gst_element_factory_make ("filesrc", "filesrc");
fail_unless (element != NULL, "Could not create filesrc element");
/* does not implement GstImplementsInterface, but does implement the
* GstUriHandler interface, so should just return TRUE */
fail_if (!gst_element_implements_interface (element, GST_TYPE_URI_HANDLER));
fail_if (gst_element_implements_interface (element,
GST_TYPE_IMPLEMENTS_INTERFACE));
gst_object_unref (element);
element = gst_element_factory_make ("identity", "identity");
fail_unless (element != NULL, "Could not create identity element");
fail_if (gst_element_implements_interface (element, GST_TYPE_URI_HANDLER));
fail_if (gst_element_implements_interface (element,
GST_TYPE_IMPLEMENTS_INTERFACE));
gst_object_unref (element);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
void test_value_collection()
{
GstBuffer *buf = NULL;
MyFoo *foo;
xmlfile = "gstminiobject_test_value_collection";
std_log(LOG_FILENAME_LINE, "Test Started test_value_collection");
foo = (MyFoo *) g_object_new (my_foo_get_type (), NULL);
/* test g_object_get() refcounting */
g_object_get (foo, "buffer", &buf, NULL);
g_assert (GST_IS_BUFFER (buf));
g_assert (GST_MINI_OBJECT_REFCOUNT_VALUE (GST_MINI_OBJECT_CAST (buf)) == 1);
gst_buffer_unref (buf);
/* test g_object_set() refcounting */
buf = gst_buffer_new_and_alloc (1024);
g_object_set (foo, "buffer", buf, NULL);
g_assert (GST_MINI_OBJECT_REFCOUNT_VALUE (GST_MINI_OBJECT_CAST (buf)) == 1);
gst_buffer_unref (buf);
g_object_unref (foo);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
void test_one_buffer()
{
GstElement *identity;
GstBuffer *buffer;
xmlfile = "identity_test_one_buffer";
std_log(LOG_FILENAME_LINE, "Test Started test_one_buffer");
identity = setup_identity ();
fail_unless (gst_element_set_state (identity,
GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
"could not set to playing");
buffer = gst_buffer_new_and_alloc (4);
ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
memcpy (GST_BUFFER_DATA (buffer), "data", 4);
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, buffer) == GST_FLOW_OK,
"Failed pushing buffer to identity");
/* ... but it should end up being collected on the global buffer list */
fail_unless (g_list_length (buffers) == 1);
fail_unless ((GstBuffer *) (g_list_first (buffers)->data) == buffer);
ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
/* cleanup */
cleanup_identity (identity);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
int main (int argc, char *argv[])
{
std_log(LOG_FILENAME_LINE,"[Test Case for string assign]");
#ifndef __SYMBIAN32__
return rw_test (argc, argv, __FILE__,
"lib.string.assign",
0 /* no comment */, run_test,
0 /* co command line options */);
#else
rw_test (argc, argv, __FILE__,
"lib.string.assign",
0 /* no comment */, run_test,
0 /* co command line options */);
if(failures)
{
assert_failed = true;
std_log(LOG_FILENAME_LINE,"Result: Failed");
}
else
{
std_log(LOG_FILENAME_LINE,"Result: Passed");
}
std_log(LOG_FILENAME_LINE,"[End Test Case]");
testResultXml("21_string_assign");
close_log_file();
#endif
return failures;
}
void test_lock()
{
GstTask *t;
gboolean ret;
//xmlfile = "test_lock";
std_log(LOG_FILENAME_LINE, "Test Started test_lock");
t = gst_task_create (task_func, NULL);
fail_if (t == NULL);
TEST_ASSERT_FAIL
gst_task_set_lock (t, &task_mutex);
GST_DEBUG ("pause");
ret = gst_task_pause (t);
fail_unless (ret == TRUE);
TEST_ASSERT_FAIL
g_usleep (1 * G_USEC_PER_SEC / 2);
GST_DEBUG ("joining");
ret = gst_task_join (t);
fail_unless (ret == TRUE);
TEST_ASSERT_FAIL
g_usleep (1 * G_USEC_PER_SEC / 2);
gst_object_unref (t);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
int main()
{
DBusError error;
DBusConnection* connection;
dbus_int32_t data_slot = -1;
dbus_error_init(&error);
connection = dbus_bus_get_private(DBUS_BUS_SESSION, &error);
if(!CheckConnection(connection, &error))
{
create_xml(1);
return 1;
}
if(!dbus_connection_allocate_data_slot(&data_slot))
{
std_log(LOG_FILENAME_LINE, "Out of Memory");
create_xml(1);
return 1;
}
dbus_connection_free_data_slot(&data_slot);
dbus_connection_close(connection);
dbus_connection_unref(connection);
dbus_shutdown();
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
return 0;
}
int main()
{
DBusGConnection* connection;
DBusGProxy* proxy;
GError* error = NULL;
char* path = "/Test/Proxy/Path";
g_type_init();
connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
if (connection == NULL)
{
std_log(LOG_FILENAME_LINE, "Failed to open connection to bus: %s\n",
error->message);
g_error_free (error);
create_xml(1);
return 1;
}
proxy = dbus_g_proxy_new_for_name(connection, "Test.Glib.Proxy.Path", path, "Test.Proxy.Interface");
if(strcmp(path, dbus_g_proxy_get_path(proxy)))
{
std_log(LOG_FILENAME_LINE, "Fail to check interface %s", path);
create_xml(1);
return 1;
}
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
return 0;
}
void test_load_coreelements()
{
GstPlugin *unloaded_plugin;
GstPlugin *loaded_plugin;
//xmlfile = "test_load_coreelements";
std_log(LOG_FILENAME_LINE, "Test Started test_load_coreelements");
unloaded_plugin = gst_default_registry_find_plugin ("coreelements");
fail_if (unloaded_plugin == NULL, "Failed to find coreelements plugin");
fail_if (GST_OBJECT_REFCOUNT_VALUE (unloaded_plugin) != 2,
"Refcount of unloaded plugin in registry initially should be 2");
GST_DEBUG ("refcount %d", GST_OBJECT_REFCOUNT_VALUE (unloaded_plugin));
loaded_plugin = gst_plugin_load (unloaded_plugin);
fail_if (loaded_plugin == NULL, "Failed to load plugin");
if (loaded_plugin != unloaded_plugin) {
fail_if (GST_OBJECT_REFCOUNT_VALUE (loaded_plugin) != 2,
"Refcount of loaded plugin in registry should be 2");
GST_DEBUG ("refcount %d", GST_OBJECT_REFCOUNT_VALUE (loaded_plugin));
fail_if (GST_OBJECT_REFCOUNT_VALUE (unloaded_plugin) != 1,
"Refcount of replaced plugin should be 1");
GST_DEBUG ("refcount %d", GST_OBJECT_REFCOUNT_VALUE (unloaded_plugin));
}
gst_object_unref (unloaded_plugin);
gst_object_unref (loaded_plugin);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
