git.maemo.org Git - mafwsubrenderer/blob - tests/check-mafw-gst-renderer.c

   1 /*
   2  * This file is a part of MAFW
   3  *
   4  * Copyright (C) 2007, 2008, 2009 Nokia Corporation, all rights reserved.
   5  *
   6  * Contact: Visa Smolander <visa.smolander@nokia.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; version 2.1 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  */
  24
  25 /*
  26  * check-gst-renderer.c
  27  *
  28  * Gst Renderer unit tests
  29  *
  30  * Copyright (C) 2007 Nokia Corporation
  31  *
  32  */
  33
  34 #include <glib.h>
  35
  36 #include <check.h>
  37 #include <string.h>
  38 #include <stdlib.h>
  39 #include <sqlite3.h>
  40 #include <gst/tag/tag.h>
  41
  42 #include <libmafw/mafw.h>
  43 #include <checkmore.h>
  44
  45 #include "config.h"
  46
  47 #include "mafw-gst-renderer.h"
  48 #include "mafw-mock-playlist.h"
  49 #include "mafw-mock-pulseaudio.h"
  50
  51 #undef  G_LOG_DOMAIN
  52 #define G_LOG_DOMAIN "check-mafw-gstreamer-renderer"
  53
  54 #define SAMPLE_AUDIO_CLIP "test.wav"
  55 #define SAMPLE_VIDEO_CLIP "test.avi"
  56 #define SAMPLE_IMAGE "testframe.png"
  57
  58 /* Base timeout used when waiting for state transitions or execution of
  59    user function callbacks associated to each mafw-renderer function */
  60 #define DEFAULT_WAIT_TOUT 2000
  61
  62 /* EOS timeout must be longer than the clip duration */
  63 #define EOS_TIMEOUT 7000
  64
  65 SRunner *configure_tests(void);
  66
  67 typedef struct {
  68         gint index;
  69         MafwPlayState state;
  70 } RendererInfo;
  71
  72 typedef struct {
  73         gboolean called;
  74         gboolean error;
  75         gint err_code;
  76         gchar *err_msg;
  77         gint seek_position;
  78         gboolean error_signal_expected;
  79         GError *error_signal_received;
  80         const gchar *property_expected;
  81         GValue *property_received;
  82 } CallbackInfo;
  83
  84 typedef struct {
  85         const gchar *expected_key;
  86         GValue *value;
  87 } MetadataChangedInfo;
  88
  89 typedef struct {
  90         const gchar *expected;
  91         GValue *received;
  92 } PropertyChangedInfo;
  93
  94 typedef struct {
  95         gboolean requested;
  96         gboolean received;
  97         gfloat value;
  98 } BufferingInfo;
  99
 100 static gint wait_tout_val;
 101
 102 /* Globals. */
 103
 104 static MafwRenderer *g_gst_renderer = NULL;
 105
 106 /* Error messages. */
 107
 108 static const gchar *callback_err_msg = "Error received when %s: (%d) %s";
 109 static const gchar *callback_no_err_msg = "No error received when %s: (%d) %s";
 110 static const gchar *no_callback_msg = "We forgot to call the user callback";
 111 static const gchar *state_err_msg = "Call %s didn't change state to %s. " \
 112 "Current state is: %d";
 113 static const gchar *index_err_msg = "Actual index is (%d) instead of the " \
 114 "expected index (%d)";
 115
 116
 117 /*----------------------------------------------------------------------------
 118   Signal handlers
 119   ----------------------------------------------------------------------------*/
 120
 121
 122 static void error_cb(MafwRenderer *s, GQuark domain, gint code, gchar *msg,
 123                      gpointer user_data)
 124 {
 125         CallbackInfo* c = (CallbackInfo*) user_data;
 126
 127         /* "MafwExtension::error" signal handler */
 128         if (user_data == NULL || !c->error_signal_expected) {
 129                 fail("Signal error received: (%d) %s", code, msg);
 130         } else {
 131                 if (c->error_signal_received != NULL) {
 132                         fail("Error received already initialized");
 133                 } else {
 134                         c->error_signal_received =
 135                                 g_error_new_literal(domain, code, msg);
 136                 }
 137         }
 138 }
 139
 140 static void state_changed_cb(MafwRenderer *s,  MafwPlayState state,
 141                              gpointer user_data)
 142 {
 143         /* "MafwRenderer::state-changed" signal handler */
 144         RendererInfo *si = (RendererInfo *) user_data;
 145         gchar *states[] = {"Stopped","Playing","Paused","Transitioning"};
 146
 147         si->state = state;
 148         g_debug("state changed (%s) ---", states[state]);
 149 }
 150
 151 static gboolean media_changed_called;
 152
 153 static void media_changed_cb(MafwRenderer *s, gint index, gchar *objectid,
 154                              gpointer user_data)
 155 {
 156         /* "MafwRenderer::media-changed" signal handler */
 157         RendererInfo *si = (RendererInfo *) user_data;
 158
 159         si->index = index;
 160         g_debug("media changed (%d) ---", index);
 161         media_changed_called = TRUE;
 162 }
 163 static void playlist_changed_cb (MafwRenderer *self,
 164                                                         GObject       *playlist,
 165                                                         gpointer       user_data)
 166 {
 167         g_debug("playlist changed");
 168         fail_if(media_changed_called, "At first playlist-changed should be called");
 169 }
 170
 171 static void metadata_changed_cb(MafwRenderer *self, const gchar *key,
 172                                 GValueArray *value, gpointer user_data)
 173 {
 174         MetadataChangedInfo *m = user_data;
 175
 176         if (m->expected_key != NULL && strcmp(key, m->expected_key) == 0)
 177         {
 178                 GValue *original;
 179
 180                 original = g_value_array_get_nth(value, 0);
 181
 182                 m->value = g_new0(GValue, 1);
 183                 g_value_init(m->value, G_VALUE_TYPE(original));
 184                 g_value_copy(original, m->value);
 185         }
 186 }
 187
 188 static void property_changed_cb(MafwExtension *extension, const gchar *name,
 189                                 const GValue *value, gpointer user_data)
 190 {
 191         PropertyChangedInfo* p = (PropertyChangedInfo*) user_data;
 192         gchar *value_string;
 193
 194         value_string = g_strdup_value_contents(value);
 195
 196         g_debug("property_changed_cb: %s (%s)", name, value_string);
 197         g_free(value_string);
 198
 199         if (p->expected != NULL &&
 200             strcmp(p->expected, name) == 0) {
 201                 p->received = g_new0(GValue, 1);
 202                 g_value_init(p->received, G_VALUE_TYPE(value));
 203                 g_value_copy(value, p->received);
 204         }
 205 }
 206
 207 static void buffering_info_cb(MafwRenderer *self, gfloat status,
 208                               gpointer user_data)
 209 {
 210         BufferingInfo *b = user_data;
 211
 212         if (b->requested) {
 213                 b->received = TRUE;
 214                 b->value = status;
 215         }
 216 }
 217
 218 /*----------------------------------------------------------------------------
 219   Function callbacks
 220   ----------------------------------------------------------------------------*/
 221
 222
 223 static void status_cb(MafwRenderer* renderer, MafwPlaylist* playlist, guint index,
 224                       MafwPlayState state,
 225                       const gchar* object_id,
 226                       gpointer user_data,
 227                       const GError *error)
 228 {
 229         /* MafwRendererStatusCB */
 230         RendererInfo* s = (RendererInfo*) user_data;
 231         g_assert(s != NULL);
 232
 233         if (error != NULL) {
 234                 fail("Error received while trying to get renderer status: (%d) %s",
 235                      error->code, error->message);
 236         }
 237         s->state = state;
 238
 239 }
 240
 241 static void playback_cb(MafwRenderer* renderer, gpointer user_data, const GError* error)
 242 {
 243         /* MafwRendererPlaybackCB:
 244
 245         Called after mafw_renderer_play(), mafw_renderer_play_uri(),
 246         mafw_renderer_play_object(), mafw_renderer_stop(), mafw_renderer_pause(),
 247         mafw_renderer_resume(), mafw_renderer_next(),   mafw_renderer_previous() or
 248         mafw_renderer_goto_index() has been called. */
 249         CallbackInfo* c = (CallbackInfo*) user_data;
 250         g_assert(c != NULL);
 251
 252         c->called = TRUE;
 253         if (error != NULL) {
 254                 c->error = TRUE;
 255                 c->err_code = error->code;
 256                 c->err_msg = g_strdup(error->message);
 257         }
 258 }
 259
 260 static void seek_cb (MafwRenderer *self, gint position, gpointer user_data,
 261                      const GError *error)
 262 {
 263         /* Called when seeking */
 264
 265         CallbackInfo* c = (CallbackInfo*) user_data;
 266         g_assert(c != NULL);
 267
 268         c->called = TRUE;
 269         c->seek_position = position;
 270         if (error != NULL) {
 271                 c->error = TRUE;
 272                 c->err_code = error->code;
 273                 c->err_msg = g_strdup(error->message);
 274         }
 275 }
 276
 277 static void  get_position_cb(MafwRenderer *self, gint position,
 278                              gpointer user_data, const GError *error)
 279 {
 280         CallbackInfo* c = (CallbackInfo*) user_data;
 281
 282         g_debug("get position cb: %d", position);
 283
 284         if (error != NULL) {
 285                 c->error = TRUE;
 286                 c->err_code = error->code;
 287                 c->err_msg = g_strdup(error->message);
 288         }
 289         c->called = TRUE;
 290 }
 291
 292 static void get_property_cb(MafwExtension *self,
 293                             const gchar *name,
 294                             GValue *value,
 295                             gpointer user_data,
 296                             const GError *error)
 297 {
 298         CallbackInfo* c = (CallbackInfo*) user_data;
 299         gchar *value_string;
 300
 301         value_string = g_strdup_value_contents(value);
 302
 303         g_debug("get property cb: %s (%s)", name, value_string);
 304         g_free(value_string);
 305
 306         if (error != NULL) {
 307                 c->error = TRUE;
 308                 c->err_code = error->code;
 309                 c->err_msg = g_strdup(error->message);
 310         }
 311
 312         if (c->property_expected != NULL &&
 313             strcmp(c->property_expected, name) == 0) {
 314                 c->property_received = g_new0(GValue, 1);
 315                 g_value_init(c->property_received, G_VALUE_TYPE(value));
 316                 g_value_copy(value, c->property_received);
 317
 318                 c->called = TRUE;
 319         }
 320 }
 321
 322 /*----------------------------------------------------------------------------
 323   Helpers
 324   ----------------------------------------------------------------------------*/
 325
 326 static gchar *get_sample_clip_path(const gchar *clip)
 327 {
 328         gchar *my_dir, *media;
 329
 330         /* Makefile.am sets TESTS_DIR, required for VPATH builds (like make
 331          * distcheck).  Otherwise assume we are running in-place. */
 332         my_dir = g_strdup(g_getenv("TESTS_DIR"));
 333         if (!my_dir)
 334                 my_dir = g_get_current_dir();
 335         media = g_strconcat("file://", my_dir, G_DIR_SEPARATOR_S,
 336                             "media" G_DIR_SEPARATOR_S, clip,
 337                             NULL);
 338         g_free(my_dir);
 339         return media;
 340 }
 341
 342 static gchar *get_sample_clip_objectid(const gchar *clip)
 343 {
 344         gchar *path = NULL;
 345         gchar *objectid = NULL;
 346
 347         path = get_sample_clip_path(clip);
 348         objectid = mafw_source_create_objectid(path);
 349         g_free(path);
 350
 351         return objectid;
 352 }
 353
 354 static gboolean stop_wait_timeout(gpointer user_data)
 355 {
 356         gboolean *do_stop = (gboolean *) user_data;
 357         g_debug("stop wait timeout");
 358         *do_stop = TRUE;
 359
 360         return FALSE;
 361 }
 362
 363 static gboolean wait_until_timeout_finishes(guint millis)
 364 {
 365         guint timeout = 0;
 366         gboolean stop_wait = FALSE;
 367         gboolean result = FALSE;
 368
 369         g_debug("Init wait_");
 370         /* We'll wait a limitted ammount of time */
 371         timeout = g_timeout_add(millis, stop_wait_timeout, &stop_wait);
 372         while(!stop_wait) {
 373                 result= g_main_context_iteration(NULL, TRUE);
 374         }
 375
 376         g_debug("End wait_");
 377         return TRUE;
 378 }
 379
 380 static gboolean wait_for_state(RendererInfo *renderer_info,
 381                                MafwPlayState expected_state, guint millis)
 382 {
 383         guint timeout = 0;
 384         gboolean stop_wait = FALSE;
 385
 386         g_debug("Init wait for state");
 387         /* We'll wait a limitted ammount of time */
 388         timeout = g_timeout_add(millis, stop_wait_timeout, &stop_wait);
 389
 390         while(renderer_info->state != expected_state  && !stop_wait) {
 391                         g_main_context_iteration(NULL, TRUE);
 392         }
 393
 394         if (!stop_wait) {
 395                 g_source_remove(timeout);
 396         }
 397
 398         g_debug("End wait for state");
 399         return (renderer_info->state == expected_state);
 400 }
 401
 402 static gboolean wait_for_callback(CallbackInfo *callback, guint millis)
 403 {
 404         guint timeout = 0;
 405         gboolean stop_wait = FALSE;
 406
 407         g_debug("Init wait for callback");
 408         /* We'll wait a limitted ammount of time */
 409         timeout = g_timeout_add(millis, stop_wait_timeout, &stop_wait);
 410
 411         while (callback->called == FALSE && !stop_wait) {
 412                 g_main_context_iteration(NULL, TRUE);
 413         }
 414         if (!stop_wait) {
 415                 g_source_remove(timeout);
 416         }
 417         g_debug("End wait for callback");
 418         return callback->called;
 419 }
 420
 421 static gboolean wait_for_metadata(MetadataChangedInfo *callback, guint millis)
 422 {
 423         guint timeout = 0;
 424         gboolean stop_wait = FALSE;
 425
 426         g_debug("Init wait for metadata");
 427         /* We'll wait a limitted ammount of time */
 428         timeout = g_timeout_add(millis, stop_wait_timeout, &stop_wait);
 429
 430         while (callback->value == NULL && !stop_wait) {
 431                 g_main_context_iteration(NULL, TRUE);
 432         }
 433         if (!stop_wait) {
 434                 g_source_remove(timeout);
 435         }
 436         g_debug("End wait for metadata");
 437         return callback->value != NULL;
 438 }
 439
 440 static gboolean wait_for_property(PropertyChangedInfo *callback, guint millis)
 441 {
 442         guint timeout = 0;
 443         gboolean stop_wait = FALSE;
 444
 445         g_debug("Init wait for property changed");
 446         /* We'll wait a limitted ammount of time */
 447         timeout = g_timeout_add(millis, stop_wait_timeout, &stop_wait);
 448
 449         while (callback->received == NULL && !stop_wait) {
 450                 g_main_context_iteration(NULL, TRUE);
 451         }
 452         if (!stop_wait) {
 453                 g_source_remove(timeout);
 454         }
 455         g_debug("End wait for callback");
 456         return callback->received != NULL;
 457 }
 458
 459 static gboolean wait_for_buffering(BufferingInfo *callback, guint millis)
 460 {
 461         guint timeout = 0;
 462         gboolean stop_wait = FALSE;
 463
 464         g_debug("Init wait for buffering info");
 465         /* We'll wait a limitted ammount of time */
 466         timeout = g_timeout_add(millis, stop_wait_timeout, &stop_wait);
 467
 468         while (!callback->received && !stop_wait) {
 469                 g_main_context_iteration(NULL, TRUE);
 470         }
 471         if (!stop_wait) {
 472                 g_source_remove(timeout);
 473         }
 474         g_debug("End wait for buffering info");
 475         return callback->received;
 476 }
 477
 478 static void reset_callback_info(CallbackInfo *callback_info)
 479 {
 480         if (callback_info->err_msg != NULL)
 481                 g_free(callback_info->err_msg);
 482
 483         callback_info->err_msg = NULL;
 484         callback_info->called = FALSE;
 485         callback_info->error = FALSE;
 486         callback_info->seek_position = 0;
 487         callback_info->error_signal_expected = FALSE;
 488         if (callback_info->error_signal_received != NULL) {
 489                 g_error_free(callback_info->error_signal_received);
 490                 callback_info->error_signal_received = NULL;
 491         }
 492         callback_info->property_expected = NULL;
 493         if (callback_info->property_received != NULL) {
 494                 g_value_unset(callback_info->property_received);
 495                 callback_info->property_received = NULL;
 496         }
 497 }
 498
 499 /*----------------------------------------------------------------------------
 500   Fixtures
 501   ----------------------------------------------------------------------------*/
 502
 503 static void fx_setup_dummy_gst_renderer(void)
 504 {
 505         MafwRegistry *registry;
 506
 507         /* Setup GLib */
 508         g_type_init();
 509
 510         /* Create a gst renderer instance */
 511         registry = MAFW_REGISTRY(mafw_registry_get_instance());
 512         fail_if(registry == NULL,
 513                 "Error: cannot get MAFW registry");
 514
 515         g_gst_renderer = MAFW_RENDERER(mafw_gst_renderer_new(registry));
 516         fail_if(!MAFW_IS_GST_RENDERER(g_gst_renderer),
 517                 "Could not create gst renderer instance");
 518 }
 519
 520 static void fx_teardown_dummy_gst_renderer(void)
 521 {
 522         g_object_unref(g_gst_renderer);
 523 }
 524
 525 /*----------------------------------------------------------------------------
 526   Mockups
 527   ----------------------------------------------------------------------------*/
 528
 529 /* GStreamer mock */
 530
 531 GstElement * gst_element_factory_make(const gchar * factoryname,
 532                                       const gchar * name)
 533 {
 534         GstElementFactory *factory;
 535         GstElement *element;
 536         const gchar *use_factoryname;
 537
 538         g_return_val_if_fail(factoryname != NULL, NULL);
 539
 540         /* For testing, use playbin instead of playbin2 */
 541         if (g_ascii_strcasecmp(factoryname, "playbin2") == 0)
 542                 use_factoryname = "playbin";
 543         else
 544                 use_factoryname = factoryname;
 545
 546         GST_LOG("gstelementfactory: make \"%s\" \"%s\"",
 547                 use_factoryname, GST_STR_NULL (name));
 548
 549         factory = gst_element_factory_find(use_factoryname);
 550         if (factory == NULL) {
 551                 /* No factory */
 552                 GST_INFO("no such element factory \"%s\"!", use_factoryname);
 553                 return NULL;
 554         }
 555
 556         GST_LOG_OBJECT(factory, "found factory %p", factory);
 557         if (g_ascii_strcasecmp(use_factoryname, "pulsesink") == 0) {
 558                 element = gst_element_factory_make("fakesink", "pulsesink");
 559                 g_object_set(G_OBJECT(element), "sync", TRUE, NULL);
 560         } else if (g_ascii_strcasecmp(use_factoryname, "xvimagesink") == 0) {
 561                 element = gst_element_factory_make("fakesink", "xvimagesink");
 562                 g_object_set(G_OBJECT(element), "sync", TRUE, NULL);
 563         } else {
 564                 element = gst_element_factory_create(factory, name);
 565         }
 566         gst_object_unref(factory);
 567
 568         if (element == NULL) {
 569                 /* Create failed */
 570                 GST_INFO_OBJECT(factory, "couldn't create instance!");
 571                 return NULL;
 572         }
 573
 574         GST_LOG("gstelementfactory: make \"%s\" \"%s\"",use_factoryname,
 575                 GST_STR_NULL(name));
 576
 577         /* Playbin will use fake renderer */
 578         if (g_ascii_strcasecmp(use_factoryname, "playbin") == 0) {
 579                 GstElement *audiorenderer = gst_element_factory_make("fakesink",
 580                                                                  "audiorenderer");
 581
 582                 g_object_set(G_OBJECT(audiorenderer), "sync", TRUE, NULL);
 583                 g_object_set(G_OBJECT(element),
 584                              "audio-sink",
 585                              audiorenderer,
 586                              NULL);
 587                 g_object_set(G_OBJECT(element),
 588                              "video-sink",
 589                              audiorenderer,
 590                              NULL);
 591         }
 592
 593         return element;
 594 }
 595
 596
 597 /*----------------------------------------------------------------------------
 598   Test cases
 599   ----------------------------------------------------------------------------*/
 600
 601 START_TEST(test_basic_playback)
 602 {
 603         RendererInfo s;
 604         CallbackInfo c;
 605         MetadataChangedInfo m;
 606         GstBus *bus = NULL;
 607         GstMessage *message = NULL;
 608
 609         /* Initialize callback info */
 610         c.err_msg = NULL;
 611         c.error_signal_expected = FALSE;
 612         c.error_signal_received = NULL;
 613         m.expected_key = NULL;
 614         m.value = NULL;
 615         c.property_expected = NULL;
 616         c.property_received = NULL;
 617
 618         /* Connect to renderer signals */
 619         g_signal_connect(g_gst_renderer, "error",
 620                          G_CALLBACK(error_cb),
 621                          &c);
 622         g_signal_connect(g_gst_renderer, "state-changed",
 623                          G_CALLBACK(state_changed_cb),
 624                          &s);
 625         g_signal_connect(g_gst_renderer, "media-changed",
 626                          G_CALLBACK(media_changed_cb),
 627                          &s);
 628         g_signal_connect(g_gst_renderer, "metadata-changed",
 629                          G_CALLBACK(metadata_changed_cb),
 630                          &m);
 631
 632         /* --- Get initial status --- */
 633
 634         reset_callback_info(&c);
 635
 636         g_debug("get status...");
 637         mafw_renderer_get_status(g_gst_renderer, status_cb, &s);
 638
 639         /* --- Play --- */
 640
 641         reset_callback_info(&c);
 642
 643         g_debug("play...");
 644         mafw_renderer_play(g_gst_renderer, playback_cb, &c);
 645
 646         if (wait_for_callback(&c, wait_tout_val)) {
 647                 /* No media item has been set so, we should get an error */
 648                 if (c.error == FALSE)
 649                         fail("Play of unset media did not return an error");
 650         } else {
 651                 fail(no_callback_msg);
 652         }
 653
 654         /* --- Play object --- */
 655
 656         reset_callback_info(&c);
 657
 658         gchar *objectid = get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
 659         g_debug("play_object... %s", objectid);
 660         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb, &c);
 661
 662
 663         if (wait_for_callback(&c, wait_tout_val)) {
 664                 if (c.error)
 665                         fail(callback_err_msg, "playing an object", c.err_code,
 666                              c.err_msg);
 667         } else {
 668                 fail(no_callback_msg);
 669         }
 670
 671         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
 672                 fail(state_err_msg, "mafw_renderer_play_object", "Transitioning",
 673                      s.state);
 674         }
 675
 676         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
 677                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
 678                      s.state);
 679         }
 680
 681         g_free(objectid);
 682
 683         /* --- Get position --- */
 684
 685         reset_callback_info(&c);
 686
 687         mafw_renderer_get_position(g_gst_renderer, get_position_cb, &c);
 688
 689         if (wait_for_callback(&c, wait_tout_val)) {
 690                 if (c.error)
 691                         fail(callback_err_msg, "get_position", c.err_code,
 692                              c.err_msg);
 693         } else {
 694                 fail(no_callback_msg);
 695         }
 696
 697         /* --- Duration emission --- */
 698
 699         m.expected_key = MAFW_METADATA_KEY_DURATION;
 700
 701         bus = MAFW_GST_RENDERER(g_gst_renderer)->worker->bus;
 702         fail_if(bus == NULL, "No GstBus");
 703
 704         message = gst_message_new_duration(NULL, GST_FORMAT_TIME,
 705                                            5 * GST_SECOND);
 706         gst_bus_post(bus, message);
 707
 708         if (wait_for_metadata(&m, wait_tout_val) == FALSE) {
 709                 fail("Expected " MAFW_METADATA_KEY_DURATION
 710                      ", but not received");
 711         }
 712
 713         fail_if(m.value == NULL, "Metadata " MAFW_METADATA_KEY_DURATION
 714                 " not received");
 715
 716         g_value_unset(m.value);
 717         g_free(m.value);
 718         m.value = NULL;
 719         m.expected_key = NULL;
 720
 721         /* --- Pause --- */
 722
 723         reset_callback_info(&c);
 724
 725         g_debug("pause...");
 726         mafw_renderer_pause(g_gst_renderer, playback_cb, &c);
 727
 728         if (wait_for_callback(&c, wait_tout_val)) {
 729                 if (c.error)
 730                         fail(callback_err_msg, "pausing", c.err_code,
 731                              c.err_msg);
 732         } else {
 733                 fail(no_callback_msg);
 734         }
 735
 736         if (wait_for_state(&s, Paused, wait_tout_val) == FALSE) {
 737                 fail(state_err_msg, "mafw_renderer_pause", "Paused", s.state);
 738         }
 739
 740         /* --- Resume --- */
 741
 742         reset_callback_info(&c);
 743
 744         g_debug("resume...");
 745         mafw_renderer_resume(g_gst_renderer, playback_cb, &c);
 746
 747         if (wait_for_callback(&c, wait_tout_val)) {
 748                 if (c.error)
 749                         fail(callback_err_msg, "resuming", c.err_code,
 750                              c.err_msg);
 751         } else {
 752                 fail(no_callback_msg);
 753         }
 754
 755         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
 756                 fail(state_err_msg, "mafw_renderer_resume", "Playing", s.state);
 757         }
 758
 759         /* --- Stop --- */
 760
 761         reset_callback_info(&c);
 762
 763         g_debug("stop...");
 764         mafw_renderer_stop(g_gst_renderer, playback_cb, &c);
 765
 766         if (wait_for_callback(&c, wait_tout_val)) {
 767                 if (c.error)
 768                         fail(callback_err_msg, "stopping", c.err_code,
 769                              c.err_msg);
 770         } else {
 771                 fail(no_callback_msg);
 772         }
 773
 774         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
 775                 fail(state_err_msg,"mafw_renderer_stop", "Stopped", s.state);
 776         }
 777
 778 }
 779 END_TEST
 780
 781 START_TEST(test_playlist_playback)
 782 {
 783         MafwPlaylist *playlist = NULL;
 784         gint i = 0;
 785         RendererInfo s = {0, };
 786         CallbackInfo c = {0, };
 787         gchar *cur_item_oid = NULL;
 788
 789         /* Initialize callback info */
 790         c.err_msg = NULL;
 791         c.error_signal_expected = FALSE;
 792         c.error_signal_received = NULL;
 793         c.property_expected = NULL;
 794         c.property_received = NULL;
 795
 796         /* Connect to renderer signals */
 797         g_signal_connect(g_gst_renderer, "error",
 798                          G_CALLBACK(error_cb),
 799                          &c);
 800
 801         g_signal_connect(g_gst_renderer, "state-changed",
 802                          G_CALLBACK(state_changed_cb),
 803                          &s);
 804         g_signal_connect(g_gst_renderer, "media-changed",
 805                          G_CALLBACK(media_changed_cb),
 806                          &s);
 807         g_signal_connect(g_gst_renderer, "playlist-changed",
 808                          G_CALLBACK(playlist_changed_cb),
 809                          NULL);
 810
 811         /* --- Create and assign a playlist --- */
 812
 813         g_debug("assign playlist...");
 814         playlist = MAFW_PLAYLIST(mafw_mock_playlist_new());
 815         cur_item_oid =
 816                 get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
 817         for (i=0; i<10; i++) {
 818                 mafw_playlist_insert_item(
 819                         playlist, i, cur_item_oid, NULL);
 820         }
 821         g_free(cur_item_oid);
 822         cur_item_oid =  get_sample_clip_objectid("unexisting.wav");
 823         mafw_playlist_insert_item(playlist, 9, cur_item_oid, NULL);
 824         g_free(cur_item_oid);
 825
 826         media_changed_called = FALSE;
 827         if (!mafw_renderer_assign_playlist(g_gst_renderer, playlist, NULL))
 828         {
 829                 fail("Assign playlist failed");
 830         }
 831
 832         wait_for_state(&s, Stopped, wait_tout_val);
 833
 834         /* --- Play --- */
 835
 836         reset_callback_info(&c);
 837
 838         g_debug("play...");
 839         mafw_renderer_play(g_gst_renderer, playback_cb, &c);
 840
 841         if (wait_for_callback(&c, wait_tout_val)) {
 842                 if (c.error)
 843                         fail(callback_err_msg, "playing", c.err_code,
 844                              c.err_msg);
 845         } else {
 846                 fail(no_callback_msg);
 847         }
 848
 849         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
 850                 fail(state_err_msg, "mafw_renderer_play", "Playing", s.state);
 851         }
 852
 853         /* --- Stop --- */
 854
 855         reset_callback_info(&c);
 856
 857         g_debug("stop...");
 858         mafw_renderer_stop(g_gst_renderer, playback_cb, &c);
 859
 860         if (wait_for_callback(&c, wait_tout_val)) {
 861                 if (c.error)
 862                         fail(callback_err_msg, "stopping", c.err_code,
 863                              c.err_msg);
 864         } else {
 865                 fail(no_callback_msg);
 866         }
 867
 868         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
 869                 fail(state_err_msg, "mafw_renderer_stop", "Stopped", s.state);
 870         }
 871
 872         /* --- Next --- */
 873
 874         /* Get actual index */
 875
 876         gint initial_index = s.index;
 877
 878         for (i=0; i<3; i++) {
 879
 880                 reset_callback_info(&c);
 881
 882                 g_debug("move to next...");
 883                 mafw_renderer_next(g_gst_renderer, playback_cb, &c);
 884
 885                 if (wait_for_callback(&c, wait_tout_val)) {
 886                         if (c.error)
 887                                 fail(callback_err_msg, "moving to next", c.err_code,
 888                                      c.err_msg);
 889                 } else {
 890                         fail(no_callback_msg);
 891                 }
 892
 893                 /* Check if the playlist index is correct */
 894                 fail_if(s.index != initial_index + (i+1), index_err_msg, s.index,
 895                         initial_index + (i+1));
 896         }
 897
 898
 899         /* --- Prev --- */
 900
 901         /* Get actual index */
 902         initial_index = s.index;
 903
 904         for (i=0; i<3; i++) {
 905
 906                 reset_callback_info(&c);
 907
 908                 g_debug("move to prev...");
 909                 mafw_renderer_previous(g_gst_renderer, playback_cb, &c);
 910
 911                 if (wait_for_callback(&c, wait_tout_val)) {
 912                         if (c.error)
 913                                 fail(callback_err_msg, "moving to prev", c.err_code,
 914                                      c.err_msg);
 915                 } else {
 916                         fail(no_callback_msg);
 917                 }
 918
 919                 /* Check if the playlist index is correct */
 920                 fail_if(s.index != initial_index - (i+1), index_err_msg, s.index,
 921                         initial_index - (i+1));
 922         }
 923
 924         /* Check if renderer remains in Stopped state after some Prev operations */
 925         fail_if(s.state != Stopped, "Gst renderer didn't remain in Stopped state "
 926                 "after doing prev. The actual state is %s and must be %s",
 927                 s.state, "Stopped");
 928
 929         /* --- Stop --- */
 930
 931         reset_callback_info(&c);
 932
 933         g_debug("stop...");
 934         mafw_renderer_stop(g_gst_renderer, playback_cb, &c);
 935
 936         if (wait_for_callback(&c, wait_tout_val)) {
 937                 if (c.error)
 938                         fail(callback_err_msg, "stopping playback",
 939                              c.err_code, c.err_msg);
 940         } else {
 941                 fail(no_callback_msg);
 942         }
 943
 944         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
 945                 fail(state_err_msg,"mafw_renderer_stop","Stopped", s.state);
 946         }
 947
 948         /* --- Go to index in Stopped state --- */
 949
 950         reset_callback_info(&c);
 951
 952         g_debug("goto index 3...");
 953         mafw_renderer_goto_index(g_gst_renderer, 3, playback_cb, &c);
 954
 955         if (wait_for_callback(&c, wait_tout_val)) {
 956                 if (c.error)
 957                         fail(callback_err_msg, "going to index 3", c.err_code,
 958                              c.err_msg);
 959         } else {
 960                 fail(no_callback_msg);
 961         }
 962
 963         /* Check if the playlist index is correct */
 964         fail_if(s.index != 3, index_err_msg, s.index, 3);
 965
 966         /* Check if renderer remains in Stopped state after running go to index */
 967         fail_if(s.state != Stopped, "Gst renderer didn't remain in Stopped state "
 968                 "after running go to index. The actual state is %s and must be"
 969                 " %s", s.state, "Stopped");
 970
 971         /* --- Play (playlist index is 3) --- */
 972
 973         reset_callback_info(&c);
 974
 975         g_debug("play...");
 976         mafw_renderer_play(g_gst_renderer, playback_cb, &c);
 977
 978         if (wait_for_callback(&c, wait_tout_val)) {
 979                 if (c.error)
 980                         fail(callback_err_msg, "playing", c.err_code,
 981                              c.err_msg);
 982         } else {
 983                 fail(no_callback_msg);
 984         }
 985
 986         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
 987                 fail(state_err_msg, "mafw_renderer_play", "Transitioning", s.state);
 988         }
 989
 990         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
 991                 fail(state_err_msg, "mafw_renderer_play", "Playing", s.state);
 992         }
 993
 994         /* --- Goto index in Playing state --- */
 995
 996         reset_callback_info(&c);
 997
 998         g_debug("goto index 5...");
 999         mafw_renderer_goto_index(g_gst_renderer, 5, playback_cb, &c);
1000
1001         if (wait_for_callback(&c, wait_tout_val)) {
1002                 if (c.error)
1003                         fail(callback_err_msg, "going to index", c.err_code,
1004                              c.err_msg);
1005         } else {
1006                 fail(no_callback_msg);
1007         }
1008
1009         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1010                 fail(state_err_msg, "mafw_renderer_goto_index", "Playing", s.state);
1011         }
1012
1013         /* Check if the index if correct */
1014         fail_if(s.index != 5, index_err_msg, s.index, 5);
1015
1016         /* Check if renderer remains in Playing state after running go to index */
1017         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1018                 fail("Gst renderer didn't remain in Playing state after running "
1019                      "go to index. The actual state is %s and must be %s",
1020                      s.state, "Playing");
1021         }
1022
1023         /* --- Goto an invalid index --- */
1024
1025         reset_callback_info(&c);
1026
1027         g_debug("goto the invalid index 20...");
1028         mafw_renderer_goto_index(g_gst_renderer, 20, playback_cb, &c);
1029
1030         if (wait_for_callback(&c, wait_tout_val)) {
1031                 if (c.error == FALSE)
1032                         fail("Error not received when we go to an incorrect"
1033                              "index");
1034         } else {
1035                 fail(no_callback_msg);
1036         }
1037
1038         /* Check if the previous index (5) remains after an incorrect go to
1039            index request */
1040         fail_if(s.index != 5, index_err_msg, 5, s.index);
1041
1042         reset_callback_info(&c);
1043
1044         /* --- Reassigning playlist --- */
1045
1046         media_changed_called = FALSE;
1047         if (!mafw_renderer_assign_playlist(g_gst_renderer,
1048                                            g_object_ref(playlist), NULL))
1049         {
1050                 fail("Assign playlist failed");
1051         }
1052
1053         wait_for_state(&s, Stopped, wait_tout_val);
1054
1055         /* --- Go to index with invalid media --- */
1056
1057         reset_callback_info(&c);
1058
1059         g_debug("goto index 9...");
1060         mafw_renderer_goto_index(g_gst_renderer, 9, playback_cb, &c);
1061
1062         if (wait_for_callback(&c, wait_tout_val)) {
1063                 if (c.error)
1064                         fail(callback_err_msg, "going to index 9", c.err_code,
1065                              c.err_msg);
1066         } else {
1067                 fail(no_callback_msg);
1068         }
1069
1070         /* Check if the playlist index is correct */
1071         fail_if(s.index != 9, index_err_msg, s.index, 9);
1072
1073         /* Check if renderer remains in Stopped state after running go
1074          * to index */
1075         fail_if(s.state != Stopped, "Gst renderer didn't remain in Stopped "
1076                 "state after running go to index. The actual state is %d and "
1077                 "must be %s", s.state, "Stopped");
1078
1079         /* --- Play (playlist index is 9) --- */
1080
1081         reset_callback_info(&c);
1082
1083         c.error_signal_expected = TRUE;
1084
1085         g_debug("play...");
1086         mafw_renderer_play(g_gst_renderer, playback_cb, &c);
1087
1088         if (wait_for_callback(&c, wait_tout_val)) {
1089                 if (c.error)
1090                         fail(callback_err_msg, "playing", c.err_code,
1091                              c.err_msg);
1092         } else {
1093                 fail(no_callback_msg);
1094         }
1095
1096         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
1097                 fail(state_err_msg, "mafw_renderer_play", "Transitioning",
1098                      s.state);
1099         }
1100
1101         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1102                 fail(state_err_msg, "mafw_renderer_play", "Playing", s.state);
1103         }
1104
1105         fail_if(c.error_signal_received == NULL ||
1106                 !g_error_matches(c.error_signal_received, MAFW_RENDERER_ERROR,
1107                                  MAFW_RENDERER_ERROR_INVALID_URI),
1108                 "No error received or incorrect one");
1109
1110         if (c.error_signal_received != NULL) {
1111                 g_error_free(c.error_signal_received);
1112                 c.error_signal_received = NULL;
1113         }
1114         c.error_signal_expected = FALSE;
1115
1116         /* --- Stop --- */
1117
1118         reset_callback_info(&c);
1119
1120         g_debug("stop...");
1121         mafw_renderer_stop(g_gst_renderer, playback_cb, &c);
1122
1123         if (wait_for_callback(&c, wait_tout_val)) {
1124                 if (c.error)
1125                         fail(callback_err_msg, "stopping playback",
1126                              c.err_code, c.err_msg);
1127         } else {
1128                 fail(no_callback_msg);
1129         }
1130
1131         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
1132                 fail(state_err_msg,"mafw_renderer_stop","Stopped", s.state);
1133         }
1134
1135         /* --- Remove last media --- */
1136
1137         mafw_playlist_remove_item(playlist, 10, NULL);
1138
1139         /* --- Go to index with invalid media --- */
1140
1141         reset_callback_info(&c);
1142
1143         g_debug("goto index 9...");
1144         mafw_renderer_goto_index(g_gst_renderer, 9, playback_cb, &c);
1145
1146         if (wait_for_callback(&c, wait_tout_val)) {
1147                 if (c.error)
1148                         fail(callback_err_msg, "going to index 9", c.err_code,
1149                              c.err_msg);
1150         } else {
1151                 fail(no_callback_msg);
1152         }
1153
1154         /* Check if the playlist index is correct */
1155         fail_if(s.index != 9, index_err_msg, s.index, 9);
1156
1157         /* Check if renderer remains in Stopped state after running go
1158          * to index */
1159         fail_if(s.state != Stopped, "Gst renderer didn't remain in Stopped "
1160                 "state after running go to index. The actual state is %d and "
1161                 "must be %s", s.state, "Stopped");
1162
1163         /* --- Play (playlist index is 9) --- */
1164
1165         reset_callback_info(&c);
1166
1167         c.error_signal_expected = TRUE;
1168
1169         g_debug("play...");
1170         mafw_renderer_play(g_gst_renderer, playback_cb, &c);
1171
1172         if (wait_for_callback(&c, wait_tout_val)) {
1173                 if (c.error)
1174                         fail(callback_err_msg, "playing", c.err_code,
1175                              c.err_msg);
1176         } else {
1177                 fail(no_callback_msg);
1178         }
1179
1180         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
1181                 fail(state_err_msg, "mafw_renderer_play", "Transitioning",
1182                      s.state);
1183         }
1184
1185         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
1186                 fail(state_err_msg, "mafw_renderer_play", "Stopped", s.state);
1187         }
1188
1189         fail_if(c.error_signal_received == NULL ||
1190                 !g_error_matches(c.error_signal_received, MAFW_RENDERER_ERROR,
1191                                  MAFW_RENDERER_ERROR_INVALID_URI),
1192                 "No error received or incorrect one");
1193
1194         if (c.error_signal_received != NULL) {
1195                 g_error_free(c.error_signal_received);
1196                 c.error_signal_received = NULL;
1197         }
1198         c.error_signal_expected = FALSE;
1199
1200         /* --- Play incorrect object --- */
1201
1202         reset_callback_info(&c);
1203
1204         c.error_signal_expected = TRUE;
1205
1206         gchar *objectid = get_sample_clip_objectid("unexisting.wav");
1207         g_debug("play_object... %s", objectid);
1208         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb, &c);
1209
1210         if (wait_for_callback(&c, wait_tout_val)) {
1211                 if (c.error)
1212                         fail(callback_err_msg, "playing an object", c.err_code,
1213                              c.err_msg);
1214         } else {
1215                 fail(no_callback_msg);
1216         }
1217
1218         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
1219                 fail(state_err_msg, "mafw_renderer_play_object",
1220                      "Transitioning",
1221                      s.state);
1222         }
1223
1224         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
1225                 fail(state_err_msg, "mafw_renderer_play_object", "Stopped",
1226                      s.state);
1227         }
1228
1229         fail_if(c.error_signal_received == NULL ||
1230                 !g_error_matches(c.error_signal_received, MAFW_RENDERER_ERROR,
1231                                  MAFW_RENDERER_ERROR_INVALID_URI),
1232                 "No error received or incorrect one");
1233
1234         if (c.error_signal_received != NULL) {
1235                 g_error_free(c.error_signal_received);
1236                 c.error_signal_received = NULL;
1237         }
1238         c.error_signal_expected = FALSE;
1239
1240         g_free(objectid);
1241
1242 }
1243 END_TEST
1244
1245
1246 START_TEST(test_repeat_mode_playback)
1247 {
1248         MafwPlaylist *playlist = NULL;
1249         gint i = 0;
1250         RendererInfo s = {0, };;
1251         CallbackInfo c = {0, };;
1252
1253         /* Initialize callback info */
1254         c.err_msg = NULL;
1255         c.error_signal_expected = FALSE;
1256         c.error_signal_received = NULL;
1257         c.property_expected = NULL;
1258         c.property_received = NULL;
1259
1260         /* Connect to renderer signals */
1261
1262         g_signal_connect(g_gst_renderer, "error",
1263                          G_CALLBACK(error_cb),
1264                          &c);
1265         g_signal_connect(g_gst_renderer, "state-changed",
1266                          G_CALLBACK(state_changed_cb),
1267                          &s);
1268         g_signal_connect(g_gst_renderer, "media-changed",
1269                          G_CALLBACK(media_changed_cb),
1270                          &s);
1271         g_signal_connect(g_gst_renderer, "playlist-changed",
1272                          G_CALLBACK(playlist_changed_cb),
1273                          NULL);
1274
1275         /* --- Create playlist --- */
1276
1277         playlist = MAFW_PLAYLIST(mafw_mock_playlist_new());
1278         for (i=0; i<10; i++) {
1279                 gchar *cur_item_oid =
1280                         get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
1281                 mafw_playlist_insert_item(
1282                         playlist, i, cur_item_oid, NULL);
1283                 g_free(cur_item_oid);
1284         }
1285
1286         /* Set repeat mode */
1287         mafw_playlist_set_repeat(playlist, TRUE);
1288
1289         /* --- Assign playlist --- */
1290
1291         g_debug("assign playlist...");
1292         media_changed_called = FALSE;
1293         if (!mafw_renderer_assign_playlist(g_gst_renderer, playlist, NULL))
1294         {
1295                 fail("Assign playlist failed");
1296         }
1297
1298         wait_for_state(&s, Stopped, wait_tout_val);
1299
1300         /* --- Play --- */
1301
1302         reset_callback_info(&c);
1303
1304         g_debug("play...");
1305         mafw_renderer_play(g_gst_renderer, playback_cb, &c);
1306
1307         if (wait_for_callback(&c, wait_tout_val)) {
1308                 if (c.error)
1309                         fail(callback_err_msg, "playing", c.err_code,
1310                              c.err_msg);
1311         } else {
1312                 fail(no_callback_msg);
1313         }
1314
1315         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
1316                 fail(state_err_msg, "mafw_renderer_play", "Transitioning", s.state);
1317         }
1318
1319         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1320                 fail(state_err_msg, "mafw_renderer_play", "Playing", s.state);
1321         }
1322
1323         /* --- Go to index --- */
1324
1325         reset_callback_info(&c);
1326
1327         g_debug("goto index 9...");
1328         /* go to the end of the playlist */
1329         mafw_renderer_goto_index(g_gst_renderer, 9, playback_cb, &c);
1330
1331         if (wait_for_callback(&c, wait_tout_val)) {
1332                 if (c.error)
1333                         fail(callback_err_msg, "going to index 9", c.err_code,
1334                              c.err_msg);
1335         } else {
1336                 fail(no_callback_msg);
1337         }
1338
1339         /* check if the movement was successful */
1340         fail_if(s.index != 9, index_err_msg, 9, s.index);
1341
1342         /* ---  Stop --- */
1343
1344         reset_callback_info(&c);
1345
1346         g_debug("stop...");
1347         mafw_renderer_stop(g_gst_renderer, playback_cb, &c);
1348
1349         if (wait_for_callback(&c, wait_tout_val)) {
1350                 if (c.error)
1351                         fail(callback_err_msg, "stopping playback", c.err_code,
1352                              c.err_msg);
1353         } else {
1354                 fail(no_callback_msg);
1355         }
1356
1357         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
1358                 fail(state_err_msg, "mafw_renderer_stop", "Stopped", s.state);
1359         }
1360
1361         /* --- Next --- */
1362
1363         reset_callback_info(&c);
1364
1365         g_debug("next...");
1366         /* The actual index is 9 */
1367         mafw_renderer_next(g_gst_renderer, playback_cb, &c);
1368
1369         if (wait_for_callback(&c, wait_tout_val)) {
1370                 if (c.error)
1371                         fail(callback_err_msg, "moving to next", c.err_code,
1372                              c.err_msg);
1373         } else {
1374                 fail(no_callback_msg);
1375         }
1376
1377         /* check if the movement was successful */
1378         fail_if(s.index != 0, index_err_msg, s.index, 0);
1379
1380         /* Check if renderer remains in Stopped state after moving to next */
1381         fail_if(s.state != Stopped, "Gst renderer didn't remain in Stopped state "
1382                 "after doing next. The actual state is %s and must be %s",
1383                 s.state, "Stopped");
1384
1385         /* --- Prev --- */
1386
1387         reset_callback_info(&c);
1388
1389         g_debug("prev...");
1390         /* The actual index is 0 */
1391         mafw_renderer_previous(g_gst_renderer, playback_cb, &c);
1392
1393         if (wait_for_callback(&c, wait_tout_val)) {
1394                 if (c.error)
1395                         fail(callback_err_msg, "moving to prev", c.err_code,
1396                              c.err_msg);
1397         } else {
1398                 fail(no_callback_msg);
1399         }
1400
1401         /* check if the movement was successful */
1402         fail_if(s.index != 9, index_err_msg, s.index, 9);
1403
1404         /* Check if renderer remains in Stopped state after moving to next */
1405         fail_if(s.state != Stopped, "Gst renderer didn't remain in Stopped state "
1406                 "after doing next. The actual state is %s and must be %s",
1407                 s.state, "Stopped");
1408 }
1409 END_TEST
1410
1411
1412 START_TEST(test_gst_renderer_mode)
1413 {
1414         MafwPlaylist *playlist = NULL;
1415         MafwGstRenderer *renderer = NULL;
1416         MafwGstRendererPlaybackMode play_mode;
1417         gchar *objectid = NULL;
1418         gint i = 0;
1419         RendererInfo s = {0, };;
1420         CallbackInfo c = {0, };;
1421         gchar *modes[] = {"MAFW_GST_RENDERER_MODE_PLAYLIST",
1422                           "MAFW_GST_RENDERER_MODE_STANDALONE"};
1423
1424         renderer = MAFW_GST_RENDERER(g_gst_renderer);
1425
1426         /* Initiliaze callback info */
1427         c.err_msg = NULL;
1428         c.error_signal_expected = FALSE;
1429         c.error_signal_received = NULL;
1430         c.property_expected = NULL;
1431         c.property_received = NULL;
1432
1433         /* Connect to renderer signals */
1434
1435         g_signal_connect(g_gst_renderer, "error",
1436                          G_CALLBACK(error_cb),
1437                          &c);
1438         g_signal_connect(g_gst_renderer, "state-changed",
1439                          G_CALLBACK(state_changed_cb),
1440                          &s);
1441         g_signal_connect(g_gst_renderer, "media-changed",
1442                          G_CALLBACK(media_changed_cb),
1443                          &s);
1444         g_signal_connect(g_gst_renderer, "playlist-changed",
1445                          G_CALLBACK(playlist_changed_cb),
1446                          NULL);
1447
1448         /* --- Create playlist --- */
1449
1450         playlist = MAFW_PLAYLIST(mafw_mock_playlist_new());
1451         for (i=0; i<10; i++) {
1452                 gchar *cur_item_oid =
1453                         get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
1454                 mafw_playlist_insert_item(
1455                         playlist, i, cur_item_oid, NULL);
1456                 g_free(cur_item_oid);
1457         }
1458
1459         /* --- Assign playlist --- */
1460
1461         g_debug("assign playlist...");
1462         media_changed_called = FALSE;
1463         if (!mafw_renderer_assign_playlist(g_gst_renderer, playlist, NULL))
1464         {
1465                 fail("Assign playlist failed");
1466         }
1467
1468         wait_for_state(&s, Stopped, wait_tout_val);
1469
1470         /* --- Play --- */
1471
1472         reset_callback_info(&c);
1473
1474         g_debug("play...");
1475
1476         mafw_renderer_play(g_gst_renderer, playback_cb, &c);
1477         if (wait_for_callback(&c, wait_tout_val)) {
1478                 if (c.error)
1479                         fail(callback_err_msg, "playing", c.err_code,
1480                              c.err_msg);
1481         } else {
1482                 fail(no_callback_msg);
1483         }
1484
1485         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
1486                 fail(state_err_msg, "mafw_renderer_play", "Transitioning", s.state);
1487         }
1488
1489         /* Check that renderer is playing a playlist */
1490         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1491                 fail(state_err_msg, "mafw_renderer_play", "Playing", s.state);
1492         }
1493         play_mode =  mafw_gst_renderer_get_playback_mode(renderer);
1494         fail_if(play_mode != MAFW_GST_RENDERER_MODE_PLAYLIST,
1495                 "Incorrect value of playback_mode: %s", modes[play_mode]);
1496
1497         /* --- Play object --- */
1498
1499         reset_callback_info(&c);
1500
1501         objectid = get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
1502         g_debug("play_object... %s",objectid);
1503         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb, &c);
1504         g_free(objectid);
1505
1506         if (wait_for_callback(&c, wait_tout_val)) {
1507                 if (c.error)
1508                         fail(callback_err_msg, "playing an object", c.err_code,
1509                              c.err_msg);
1510         } else {
1511                 fail(no_callback_msg);
1512         }
1513
1514         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
1515                 fail(state_err_msg, "mafw_renderer_play_object", "Transitioning",
1516                      s.state);
1517         }
1518
1519         /* Check that renderer is playing an object */
1520         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1521                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
1522                      s.state);
1523         }
1524
1525         play_mode =  mafw_gst_renderer_get_playback_mode(renderer);
1526         fail_if(play_mode != MAFW_GST_RENDERER_MODE_STANDALONE,
1527                 "Incorrect value of playback_mode: %s", modes[play_mode]);
1528
1529         /* Wait EOS_TIMEOUT to ensure that the play_object has finished */
1530         wait_until_timeout_finishes(EOS_TIMEOUT);
1531
1532         /* Check that after playing the object, renderer returns to the playlist
1533          playback */
1534         play_mode =  mafw_gst_renderer_get_playback_mode(renderer);
1535         fail_if(play_mode != MAFW_GST_RENDERER_MODE_PLAYLIST,
1536                 "Incorrect value of playback_mode: %s", modes[play_mode]);
1537         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1538                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
1539                      s.state);
1540         }
1541
1542         /* --- Play object --- */
1543
1544         reset_callback_info(&c);
1545
1546         objectid = get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
1547         g_debug("play_object... %s", objectid);
1548         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb, &c);
1549         g_free(objectid);
1550
1551         if (wait_for_callback(&c, wait_tout_val)) {
1552                 if (c.error)
1553                         fail(callback_err_msg, "playing an object", c.err_code,
1554                              c.err_msg);
1555         } else {
1556                 fail(no_callback_msg);
1557         }
1558
1559         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
1560                 fail(state_err_msg, "mafw_renderer_play_object", "Transitioning",
1561                      s.state);
1562         }
1563
1564         /* Check that renderer is playing an object */
1565         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1566                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
1567                      s.state);
1568         }
1569         play_mode =  mafw_gst_renderer_get_playback_mode(renderer);
1570         fail_if(play_mode != MAFW_GST_RENDERER_MODE_STANDALONE,
1571                 "Incorrect value of playback_mode: %s", modes[play_mode]);
1572
1573
1574         /* --- Move to next when renderer is playing an object --- */
1575
1576         reset_callback_info(&c);
1577
1578         g_debug("next...");
1579         mafw_renderer_next(g_gst_renderer, playback_cb, &c);
1580
1581         if (wait_for_callback(&c, wait_tout_val)) {
1582                 if (c.error)
1583                         fail(callback_err_msg, "moving to next", c.err_code,
1584                              c.err_msg);
1585         } else {
1586                 fail(no_callback_msg);
1587         }
1588
1589         /* Check that "next" function finishes the object playback and returns
1590            to the playlist playback */
1591         play_mode =  mafw_gst_renderer_get_playback_mode(renderer);
1592         fail_if(play_mode != MAFW_GST_RENDERER_MODE_PLAYLIST,
1593                 "Incorrect value of playback_mode: %s", modes[play_mode]);
1594
1595         /* Check that renderer is still in Playing state */
1596         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1597                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
1598                      s.state);
1599         }
1600
1601         /* --- Stop --- */
1602
1603         reset_callback_info(&c);
1604
1605         g_debug("stop...");
1606         mafw_renderer_stop(g_gst_renderer, playback_cb, &c);
1607
1608         if (wait_for_callback(&c, wait_tout_val)) {
1609                 if (c.error)
1610                         fail(callback_err_msg, "stopping", c.err_code,
1611                              c.err_msg);
1612         } else {
1613                 fail(no_callback_msg);
1614         }
1615
1616         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
1617                 fail(state_err_msg,"mafw_renderer_stop", "Stopped", s.state);
1618         }
1619
1620         /* --- Play object --- */
1621
1622         reset_callback_info(&c);
1623
1624         objectid = get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
1625         g_debug("play_object... %s", objectid);
1626         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb, &c);
1627
1628         if (wait_for_callback(&c, wait_tout_val)) {
1629                 if (c.error)
1630                         fail(callback_err_msg, "playing an object", c.err_code,
1631                              c.err_msg);
1632         } else {
1633                 fail(no_callback_msg);
1634         }
1635
1636         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
1637                 fail(state_err_msg, "mafw_renderer_play_object", "Transitioning",
1638                      s.state);
1639         }
1640
1641         /* Check that renderer is playing an object */
1642         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1643                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
1644                      s.state);
1645         }
1646         play_mode =  mafw_gst_renderer_get_playback_mode(renderer);
1647         fail_if(play_mode != MAFW_GST_RENDERER_MODE_STANDALONE,
1648                 "Incorrect value of playback_mode: %s", modes[play_mode]);
1649
1650         /* Wait EOS_TIMEOUT to ensure that object playback finishes */
1651         wait_until_timeout_finishes(EOS_TIMEOUT);
1652
1653         /* Check if renderer is in playlist mode and the renderer state is the state before
1654            playing the object */
1655         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
1656                 fail(state_err_msg,"mafw_renderer_stop", "Stopped", s.state);
1657         }
1658         play_mode =  mafw_gst_renderer_get_playback_mode(renderer);
1659         fail_if(play_mode != MAFW_GST_RENDERER_MODE_PLAYLIST,
1660                 "Incorrect value of playback_mode: %s", modes[play_mode]);
1661
1662         g_free(objectid);
1663 }
1664 END_TEST
1665
1666 #define MOCK_SOURCE(o)                                                  \
1667         (G_TYPE_CHECK_INSTANCE_CAST((o),                                \
1668                                     mock_source_get_type(),             \
1669                                     MockSource))
1670
1671 typedef struct {
1672         MafwSourceClass parent;
1673 } MockSourceClass;
1674
1675 typedef struct {
1676         MafwSource parent;
1677
1678
1679 } MockSource;
1680
1681 GType mock_source_get_type(void);
1682 GObject* mock_source_new(void);
1683
1684 G_DEFINE_TYPE(MockSource, mock_source, MAFW_TYPE_SOURCE);
1685
1686 static GHashTable *get_md_ht;           /* Metadata hash-table for the metadata result */
1687 static GError *get_md_err;              /* Error value for the metadata result */
1688 static gboolean set_mdata_called;       /* Whether set_metadata was called or not */
1689 static gboolean get_mdata_called;       /* Whether get_metadata was called or not */
1690 static gint reference_pcount;           /* Reference playcount, what should come in set_metadata */
1691 static gboolean set_for_playcount;      /* TRUE, when the set_metadata is called to modify the playcount */
1692 static gboolean set_for_lastplayed;     /* TRUE, when the set_metadata is called to modify the last-played */
1693
1694 static void get_metadata(MafwSource *self,
1695                              const gchar *object_id,
1696                              const gchar *const *metadata,
1697                              MafwSourceMetadataResultCb callback,
1698                              gpointer user_data)
1699 {
1700         get_mdata_called = TRUE;
1701         fail_if(strcmp(object_id, "mocksource::test"));
1702         callback(self, object_id, get_md_ht, user_data, get_md_err);
1703 }
1704
1705 static void set_metadata(MafwSource *self, const gchar *object_id,
1706                              GHashTable *metadata,
1707                              MafwSourceMetadataSetCb callback,
1708                              gpointer user_data)
1709 {
1710         GValue *curval;
1711         gint htsize = 0;
1712
1713         if (set_for_playcount)
1714                 htsize++;
1715         if (set_for_lastplayed)
1716                 htsize++;
1717         fail_if(strcmp(object_id, "mocksource::test"));
1718         fail_if(!metadata);
1719         fail_if(g_hash_table_size(metadata) != htsize, "Hash table size: %d vs %d", g_hash_table_size(metadata), htsize);
1720         if (set_for_playcount)
1721         {
1722                 curval = mafw_metadata_first(metadata,
1723                                 MAFW_METADATA_KEY_PLAY_COUNT);
1724                 fail_if(!curval);
1725                 fail_if(g_value_get_int(curval) != reference_pcount);
1726         }
1727         if (set_for_lastplayed)
1728         {
1729                 curval = mafw_metadata_first(metadata,
1730                                 MAFW_METADATA_KEY_LAST_PLAYED);
1731                 fail_if(!curval);
1732                 fail_if(!G_VALUE_HOLDS(curval, G_TYPE_LONG));
1733         }
1734         set_mdata_called = TRUE;
1735 }
1736
1737 static void mock_source_class_init(MockSourceClass *klass)
1738 {
1739         MafwSourceClass *sclass = MAFW_SOURCE_CLASS(klass);
1740
1741         sclass->get_metadata = get_metadata;
1742         sclass->set_metadata = set_metadata;
1743
1744 }
1745
1746 static void mock_source_init(MockSource *source)
1747 {
1748         /* NOP */
1749 }
1750
1751 GObject* mock_source_new(void)
1752 {
1753         GObject* object;
1754         object = g_object_new(mock_source_get_type(),
1755                               "plugin", "mockland",
1756                               "uuid", "mocksource",
1757                               "name", "mocksource",
1758                               NULL);
1759         return object;
1760 }
1761
1762
1763 START_TEST(test_update_stats)
1764 {
1765         MafwGstRenderer *renderer = NULL;
1766         MafwSource *src;
1767         MafwRegistry *registry;
1768
1769         registry = MAFW_REGISTRY(mafw_registry_get_instance());
1770         fail_if(registry == NULL,
1771                 "Error: cannot get MAFW registry");
1772
1773
1774         renderer = MAFW_GST_RENDERER(g_gst_renderer);
1775         src = MAFW_SOURCE(mock_source_new());
1776
1777         mafw_registry_add_extension(registry, MAFW_EXTENSION(src));
1778
1779         /* Error on get_mdata_cb*/
1780         set_for_playcount = FALSE;
1781         set_for_lastplayed = FALSE;
1782         get_md_err = NULL;
1783         g_set_error(&get_md_err, MAFW_SOURCE_ERROR,
1784                     MAFW_SOURCE_ERROR_INVALID_OBJECT_ID,
1785                     "Wrong object id mocksource::test");
1786         renderer->media->object_id = g_strdup("mocksource::test");
1787         mafw_gst_renderer_update_stats(renderer);
1788         g_error_free(get_md_err);
1789         fail_if(set_mdata_called);
1790         fail_if(!get_mdata_called);
1791
1792         /* get_mdata ok, but HashTable is NULL */
1793         reference_pcount = 1;
1794         get_mdata_called = FALSE;
1795         set_for_lastplayed = TRUE;
1796         set_for_playcount = TRUE;
1797         get_md_err = NULL;
1798         mafw_gst_renderer_update_stats(renderer);
1799         fail_if(!set_mdata_called);
1800         fail_if(!get_mdata_called);
1801
1802         /* get_mdata ok, but HashTable is empty */
1803         get_mdata_called = FALSE;
1804         set_mdata_called = FALSE;
1805         set_for_lastplayed = TRUE;
1806         set_for_playcount = TRUE;
1807         get_md_ht = mafw_metadata_new();
1808         mafw_gst_renderer_update_stats(renderer);
1809         fail_if(!set_mdata_called);
1810         fail_if(!get_mdata_called);
1811
1812         /* get_mdata ok, but HashTable has valid value */
1813         get_mdata_called = FALSE;
1814         set_mdata_called = FALSE;
1815         set_for_lastplayed = TRUE;
1816         set_for_playcount = TRUE;
1817         mafw_metadata_add_int(get_md_ht,
1818                                                 MAFW_METADATA_KEY_PLAY_COUNT,
1819                                                 1);
1820         reference_pcount = 2;
1821         mafw_gst_renderer_update_stats(renderer);
1822         fail_if(!set_mdata_called);
1823         fail_if(!get_mdata_called);
1824 }
1825 END_TEST
1826
1827 START_TEST(test_play_state)
1828 {
1829         MafwPlaylist *playlist = NULL;
1830         gint i = 0;
1831         RendererInfo s = {0, };;
1832         CallbackInfo c = {0, };;
1833         gchar *objectid = NULL;
1834
1835         /* Initialize callback info */
1836         c.err_msg = NULL;
1837         c.error_signal_expected = FALSE;
1838         c.error_signal_received = NULL;
1839         c.property_expected = NULL;
1840         c.property_received = NULL;
1841
1842         /* Connect to renderer signals */
1843         g_signal_connect(g_gst_renderer, "error",
1844                          G_CALLBACK(error_cb),
1845                          &c);
1846
1847         g_signal_connect(g_gst_renderer, "state-changed",
1848                          G_CALLBACK(state_changed_cb),
1849                          &s);
1850         g_signal_connect(g_gst_renderer, "media-changed",
1851                          G_CALLBACK(media_changed_cb),
1852                          &s);
1853         g_signal_connect(g_gst_renderer, "playlist-changed",
1854                          G_CALLBACK(playlist_changed_cb),
1855                          NULL);
1856
1857         /* --- Get initial status --- */
1858
1859         reset_callback_info(&c);
1860
1861         g_debug("get status...");
1862         mafw_renderer_get_status(g_gst_renderer, status_cb, &s);
1863
1864         /* --- Play object --- */
1865
1866         reset_callback_info(&c);
1867
1868         objectid = get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
1869         g_debug("play_object... %s", objectid);
1870         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb,
1871                                    &c);
1872
1873         if (wait_for_callback(&c, wait_tout_val)) {
1874                 if (c.error)
1875                         fail(callback_err_msg, "playing an object", c.err_code,
1876                              c.err_msg);
1877         } else {
1878                 fail(no_callback_msg);
1879         }
1880
1881         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
1882                 fail(state_err_msg, "mafw_renderer_play_object",
1883                      "Transitioning", s.state);
1884         }
1885
1886         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1887                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
1888                      s.state);
1889         }
1890
1891         if (wait_for_state(&s, Stopped, 3000) == FALSE) {
1892                 fail(state_err_msg, "mafw_renderer_play_object", "Stop",
1893                      s.state);
1894         }
1895
1896         g_free(objectid);
1897
1898
1899         /* --- Create and assign a playlist --- */
1900
1901         g_debug("assign playlist...");
1902         playlist = MAFW_PLAYLIST(mafw_mock_playlist_new());
1903         for (i=0; i<10; i++) {
1904                 gchar *cur_item_oid =
1905                         get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
1906                 mafw_playlist_insert_item(
1907                         playlist, i, cur_item_oid, NULL);
1908                 g_free(cur_item_oid);
1909         }
1910         mafw_playlist_set_repeat(playlist, FALSE);
1911
1912         media_changed_called = FALSE;
1913         if (!mafw_renderer_assign_playlist(g_gst_renderer, playlist,
1914                                             NULL))
1915         {
1916                 fail("Assign playlist failed");
1917         }
1918
1919         wait_for_state(&s, Stopped, wait_tout_val);
1920
1921         /* --- Play --- */
1922
1923         reset_callback_info(&c);
1924
1925         g_debug("play...");
1926         mafw_renderer_play(g_gst_renderer, playback_cb, &c);
1927
1928         if (wait_for_callback(&c, wait_tout_val)) {
1929                 if (c.error)
1930                         fail("Play after assigning playlist failed");
1931         } else {
1932                 fail(no_callback_msg);
1933         }
1934
1935         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
1936                 fail(state_err_msg, "mafw_renderer_play",
1937                      "Transitioning", s.state);
1938         }
1939
1940         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1941                 fail(state_err_msg, "mafw_renderer_play", "Playing",
1942                      s.state);
1943         }
1944
1945         /* --- Prev --- */
1946
1947         reset_callback_info(&c);
1948
1949         g_debug("move to prev...");
1950         mafw_renderer_previous(g_gst_renderer, playback_cb, &c);
1951
1952         if (wait_for_callback(&c, wait_tout_val)) {
1953                 if (c.error)
1954                         fail(callback_err_msg, "moving to prev", c.err_code,
1955                              c.err_msg);
1956         } else {
1957                 fail(no_callback_msg);
1958         }
1959
1960         fail_if(s.index != 9, index_err_msg, s.index, 9);
1961
1962         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
1963                 fail(state_err_msg, "mafw_renderer_prev",
1964                      "Transitioning", s.state);
1965         }
1966
1967         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1968                 fail(state_err_msg, "mafw_renderer_prev", "Playing",
1969                      s.state);
1970         }
1971
1972         /* Removing last element */
1973
1974         g_debug("removing last element...");
1975         fail_if(mafw_playlist_get_size(playlist, NULL) != 10,
1976                 "Playlist should have 10 elements");
1977         mafw_playlist_remove_item(playlist, 9, NULL);
1978         fail_if(mafw_playlist_get_size(playlist, NULL) != 9,
1979                 "Playlist should have 9 elements");
1980         fail_if(s.index != 8, index_err_msg, s.index, 8);
1981
1982         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
1983                 fail(state_err_msg, "mafw_playlist_remove_element",
1984                      "Transitioning", s.state);
1985         }
1986
1987         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
1988                 fail(state_err_msg, "mafw_playlist_remove_element", "Playing",
1989                      s.state);
1990         }
1991
1992         /* --- Next --- */
1993
1994         reset_callback_info(&c);
1995
1996         g_debug("move to next...");
1997         mafw_renderer_next(g_gst_renderer, playback_cb, &c);
1998
1999         if (wait_for_callback(&c, wait_tout_val)) {
2000                 if (c.error)
2001                         fail(callback_err_msg, "moving to next", c.err_code,
2002                              c.err_msg);
2003         } else {
2004                 fail(no_callback_msg);
2005         }
2006
2007         fail_if(s.index != 0, index_err_msg, s.index, 0);
2008
2009         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2010                 fail(state_err_msg, "mafw_renderer_next",
2011                      "Transitioning", s.state);
2012         }
2013
2014         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
2015                 fail(state_err_msg, "mafw_renderer_next", "Playing",
2016                      s.state);
2017         }
2018
2019         /* --- Go to index --- */
2020
2021         reset_callback_info(&c);
2022
2023         g_debug("goto index 8...");
2024         mafw_renderer_goto_index(g_gst_renderer, 8, playback_cb, &c);
2025
2026         if (wait_for_callback(&c, wait_tout_val)) {
2027                 if (c.error)
2028                         fail(callback_err_msg, "going to index 8", c.err_code,
2029                              c.err_msg);
2030         } else {
2031                 fail(no_callback_msg);
2032         }
2033
2034         fail_if(s.index != 8, index_err_msg, s.index, 8);
2035
2036         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2037                 fail(state_err_msg, "mafw_renderer_goto_index",
2038                      "Transitioning", s.state);
2039         }
2040
2041         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
2042                 fail(state_err_msg, "mafw_renderer_goto_index", "Playing",
2043                      s.state);
2044         }
2045
2046         /* --- Seeking --- */
2047
2048         reset_callback_info(&c);
2049
2050         g_debug("seeking...");
2051         mafw_renderer_set_position(g_gst_renderer, SeekAbsolute, 1,
2052                                     seek_cb, &c);
2053
2054         if (wait_for_callback(&c, wait_tout_val)) {
2055                 if (c.error)
2056                         fail(callback_err_msg, "seeking failed", c.err_code,
2057                              c.err_msg);
2058                 if (c.seek_position != 1) {
2059                         fail("seeking failed");
2060                 }
2061         } else {
2062                 fail(no_callback_msg);
2063         }
2064
2065         /* --- Waiting EOS --- */
2066
2067         if (wait_for_state(&s, Stopped, 2000) == FALSE) {
2068                 fail(state_err_msg, "EOS", "Stop",
2069                      s.state);
2070         }
2071 }
2072 END_TEST
2073
2074 START_TEST(test_pause_state)
2075 {
2076         MafwPlaylist *playlist = NULL;
2077         gint i = 0;
2078         RendererInfo s = {0, };;
2079         CallbackInfo c = {0, };;
2080         gchar *objectid = NULL;
2081
2082         /* Initialize callback info */
2083         c.err_msg = NULL;
2084         c.error_signal_expected = FALSE;
2085         c.error_signal_received = NULL;
2086         c.property_expected = NULL;
2087         c.property_received = NULL;
2088
2089         /* Connect to renderer signals */
2090         g_signal_connect(g_gst_renderer, "error",
2091                          G_CALLBACK(error_cb),
2092                          &c);
2093
2094         g_signal_connect(g_gst_renderer, "state-changed",
2095                          G_CALLBACK(state_changed_cb),
2096                          &s);
2097         g_signal_connect(g_gst_renderer, "media-changed",
2098                          G_CALLBACK(media_changed_cb),
2099                          &s);
2100         g_signal_connect(g_gst_renderer, "playlist-changed",
2101                          G_CALLBACK(playlist_changed_cb),
2102                          NULL);
2103
2104         /* --- Get initial status --- */
2105
2106         reset_callback_info(&c);
2107
2108         g_debug("get status...");
2109         mafw_renderer_get_status(g_gst_renderer, status_cb, &s);
2110
2111         /* --- Create and assign a playlist --- */
2112
2113         g_debug("assign playlist...");
2114         playlist = MAFW_PLAYLIST(mafw_mock_playlist_new());
2115         for (i=0; i<10; i++) {
2116                 gchar *cur_item_oid =
2117                         get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
2118                 mafw_playlist_insert_item(
2119                         playlist, i, cur_item_oid, NULL);
2120                 g_free(cur_item_oid);
2121         }
2122         mafw_playlist_set_repeat(playlist, FALSE);
2123
2124         media_changed_called = FALSE;
2125         if (!mafw_renderer_assign_playlist(g_gst_renderer, playlist,
2126                                             NULL))
2127         {
2128                 fail("Assign playlist failed");
2129         }
2130
2131         wait_for_state(&s, Stopped, wait_tout_val);
2132
2133         /* --- Play --- */
2134
2135         reset_callback_info(&c);
2136
2137         g_debug("play...");
2138         mafw_renderer_play(g_gst_renderer, playback_cb, &c);
2139
2140         if (wait_for_callback(&c, wait_tout_val)) {
2141                 if (c.error)
2142                         fail("Play failed");
2143         } else {
2144                 fail(no_callback_msg);
2145         }
2146
2147         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2148                 fail(state_err_msg, "mafw_renderer_play",
2149                      "Transitioning", s.state);
2150         }
2151
2152         /* Testing pause in transitioning */
2153
2154         reset_callback_info(&c);
2155
2156         g_debug("pause...");
2157         mafw_renderer_pause(g_gst_renderer, playback_cb, &c);
2158
2159         if (wait_for_callback(&c, wait_tout_val)) {
2160                 if (c.error)
2161                         fail(callback_err_msg, "pausing", c.err_code,
2162                              c.err_msg);
2163         } else {
2164                 fail(no_callback_msg);
2165         }
2166
2167         /* Testing resume in transitioning */
2168
2169         reset_callback_info(&c);
2170
2171         g_debug("resume...");
2172         mafw_renderer_resume(g_gst_renderer, playback_cb, &c);
2173
2174         if (wait_for_callback(&c, wait_tout_val)) {
2175                 if (c.error)
2176                         fail(callback_err_msg, "resuming", c.err_code,
2177                              c.err_msg);
2178         } else {
2179                 fail(no_callback_msg);
2180         }
2181
2182         reset_callback_info(&c);
2183
2184         /* Testing resume without having paused in transitioning */
2185
2186         reset_callback_info(&c);
2187
2188         g_debug("resume...");
2189         mafw_renderer_resume(g_gst_renderer, playback_cb, &c);
2190
2191         if (wait_for_callback(&c, wait_tout_val)) {
2192                 if (!c.error)
2193                         fail(callback_no_err_msg, "resuming", c.err_code,
2194                              c.err_msg);
2195         } else {
2196                 fail(no_callback_msg);
2197         }
2198
2199         reset_callback_info(&c);
2200
2201         g_debug("pause...");
2202         mafw_renderer_pause(g_gst_renderer, playback_cb, &c);
2203
2204         if (wait_for_callback(&c, wait_tout_val)) {
2205                 if (c.error)
2206                         fail(callback_err_msg, "pausing", c.err_code,
2207                              c.err_msg);
2208         } else {
2209                 fail(no_callback_msg);
2210         }
2211
2212         if (wait_for_state(&s, Paused, wait_tout_val) == FALSE) {
2213                 fail(state_err_msg, "mafw_renderer_pause", "Paused",
2214                      s.state);
2215         }
2216
2217         /* --- Play object in pause --- */
2218
2219         reset_callback_info(&c);
2220
2221         objectid = get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
2222         g_debug("play_object... %s", objectid);
2223         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb,
2224                                    &c);
2225
2226         if (wait_for_callback(&c, wait_tout_val)) {
2227                 if (c.error)
2228                         fail(callback_err_msg, "playing an object", c.err_code,
2229                              c.err_msg);
2230         } else {
2231                 fail(no_callback_msg);
2232         }
2233
2234         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2235                 fail(state_err_msg, "mafw_renderer_play_object",
2236                      "Transitioning", s.state);
2237         }
2238
2239         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
2240                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
2241                      s.state);
2242         }
2243
2244         reset_callback_info(&c);
2245
2246         g_debug("pause...");
2247         mafw_renderer_pause(g_gst_renderer, playback_cb, &c);
2248
2249         if (wait_for_callback(&c, wait_tout_val)) {
2250                 if (c.error)
2251                         fail(callback_err_msg, "pausing", c.err_code,
2252                              c.err_msg);
2253         } else {
2254                 fail(no_callback_msg);
2255         }
2256
2257         if (wait_for_state(&s, Paused, wait_tout_val) == FALSE) {
2258                 fail(state_err_msg, "mafw_renderer_pause", "Paused",
2259                      s.state);
2260         }
2261
2262         g_free(objectid);
2263
2264         /* --- Play --- */
2265
2266         reset_callback_info(&c);
2267
2268         g_debug("play...");
2269         mafw_renderer_play(g_gst_renderer, playback_cb, &c);
2270
2271         if (wait_for_callback(&c, wait_tout_val)) {
2272                 if (c.error)
2273                         fail("Play failed");
2274         } else {
2275                 fail(no_callback_msg);
2276         }
2277
2278         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2279                 fail(state_err_msg, "mafw_renderer_play",
2280                      "Transitioning", s.state);
2281         }
2282
2283         reset_callback_info(&c);
2284
2285         g_debug("pause...");
2286         mafw_renderer_pause(g_gst_renderer, playback_cb, &c);
2287
2288         if (wait_for_callback(&c, wait_tout_val)) {
2289                 if (c.error)
2290                         fail(callback_err_msg, "pausing", c.err_code,
2291                              c.err_msg);
2292         } else {
2293                 fail(no_callback_msg);
2294         }
2295
2296         if (wait_for_state(&s, Paused, wait_tout_val) == FALSE) {
2297                 fail(state_err_msg, "mafw_renderer_pause", "Paused",
2298                      s.state);
2299         }
2300
2301         /* --- Prev --- */
2302
2303         reset_callback_info(&c);
2304
2305         g_debug("move to prev...");
2306         mafw_renderer_previous(g_gst_renderer, playback_cb, &c);
2307
2308         if (wait_for_callback(&c, wait_tout_val)) {
2309                 if (c.error)
2310                         fail(callback_err_msg, "moving to prev", c.err_code,
2311                              c.err_msg);
2312         } else {
2313                 fail(no_callback_msg);
2314         }
2315
2316         /* Check if the playlist index is correct */
2317         fail_if(s.index != 9, index_err_msg, s.index, 9);
2318
2319         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2320                 fail(state_err_msg, "mafw_renderer_prev",
2321                      "Transitioning", s.state);
2322         }
2323
2324         reset_callback_info(&c);
2325
2326         g_debug("pause...");
2327         mafw_renderer_pause(g_gst_renderer, playback_cb, &c);
2328
2329         if (wait_for_callback(&c, wait_tout_val)) {
2330                 if (c.error)
2331                         fail(callback_err_msg, "pausing", c.err_code,
2332                              c.err_msg);
2333         } else {
2334                 fail(no_callback_msg);
2335         }
2336
2337         if (wait_for_state(&s, Paused, wait_tout_val) == FALSE) {
2338                 fail(state_err_msg, "mafw_renderer_prev", "Playing",
2339                      s.state);
2340         }
2341
2342         /* Removing last element */
2343
2344         g_debug("removing last element...");
2345         fail_if(mafw_playlist_get_size(playlist, NULL) != 10,
2346                 "Playlist should have 10 elements");
2347         mafw_playlist_remove_item(playlist, 9, NULL);
2348         fail_if(mafw_playlist_get_size(playlist, NULL) != 9,
2349                 "Playlist should have 9 elements");
2350         fail_if(s.index != 8, index_err_msg, s.index, 8);
2351
2352         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2353                 fail(state_err_msg, "mafw_playlist_remove_item",
2354                      "Transitioning", s.state);
2355         }
2356
2357         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
2358                 fail(state_err_msg, "mafw_playlist_remove_item", "Playing",
2359                      s.state);
2360         }
2361
2362         reset_callback_info(&c);
2363
2364         g_debug("pause...");
2365         mafw_renderer_pause(g_gst_renderer, playback_cb, &c);
2366
2367         if (wait_for_callback(&c, wait_tout_val)) {
2368                 if (c.error)
2369                         fail(callback_err_msg, "pausing", c.err_code,
2370                              c.err_msg);
2371         } else {
2372                 fail(no_callback_msg);
2373         }
2374
2375         if (wait_for_state(&s, Paused, wait_tout_val) == FALSE) {
2376                 fail(state_err_msg, "mafw_playlist_remove_item", "Playing",
2377                      s.state);
2378         }
2379
2380         /* --- Next --- */
2381
2382         reset_callback_info(&c);
2383
2384         g_debug("move to next...");
2385         mafw_renderer_next(g_gst_renderer, playback_cb, &c);
2386
2387         if (wait_for_callback(&c, wait_tout_val)) {
2388                 if (c.error)
2389                         fail(callback_err_msg, "moving to next", c.err_code,
2390                              c.err_msg);
2391         } else {
2392                 fail(no_callback_msg);
2393         }
2394
2395         /* Check if the playlist index is correct */
2396         fail_if(s.index != 0, index_err_msg, s.index, 0);
2397
2398         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2399                 fail(state_err_msg, "mafw_renderer_next",
2400                      "Transitioning", s.state);
2401         }
2402
2403         reset_callback_info(&c);
2404
2405         g_debug("pause...");
2406         mafw_renderer_pause(g_gst_renderer, playback_cb, &c);
2407
2408         if (wait_for_callback(&c, wait_tout_val)) {
2409                 if (c.error)
2410                         fail(callback_err_msg, "pausing", c.err_code,
2411                              c.err_msg);
2412         } else {
2413                 fail(no_callback_msg);
2414         }
2415
2416         if (wait_for_state(&s, Paused, wait_tout_val) == FALSE) {
2417                 fail(state_err_msg, "mafw_renderer_next", "Playing",
2418                      s.state);
2419         }
2420
2421         /* --- Go to index --- */
2422
2423         reset_callback_info(&c);
2424
2425         g_debug("goto index 8...");
2426         mafw_renderer_goto_index(g_gst_renderer, 8, playback_cb, &c);
2427
2428         if (wait_for_callback(&c, wait_tout_val)) {
2429                 if (c.error)
2430                         fail(callback_err_msg, "going to index 8", c.err_code,
2431                              c.err_msg);
2432         } else {
2433                 fail(no_callback_msg);
2434         }
2435
2436         /* Check if the playlist index is correct */
2437         fail_if(s.index != 8, index_err_msg, s.index, 8);
2438
2439         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2440                 fail(state_err_msg, "mafw_renderer_goto_index",
2441                      "Transitioning", s.state);
2442         }
2443
2444         reset_callback_info(&c);
2445
2446         g_debug("pause...");
2447         mafw_renderer_pause(g_gst_renderer, playback_cb, &c);
2448
2449         if (wait_for_callback(&c, wait_tout_val)) {
2450                 if (c.error)
2451                         fail(callback_err_msg, "pausing", c.err_code,
2452                              c.err_msg);
2453         } else {
2454                 fail(no_callback_msg);
2455         }
2456
2457         if (wait_for_state(&s, Paused, wait_tout_val) == FALSE) {
2458                 fail(state_err_msg, "mafw_renderer_goto_index", "Playing",
2459                      s.state);
2460         }
2461
2462         /* --- Seeking --- */
2463
2464         reset_callback_info(&c);
2465
2466         mafw_renderer_set_position(g_gst_renderer, SeekAbsolute, 1,
2467                                     seek_cb, &c);
2468
2469         if (wait_for_callback(&c, wait_tout_val)) {
2470                 if (c.error)
2471                         fail(callback_err_msg, "seeking", c.err_code,
2472                              c.err_msg);
2473                 if (c.seek_position != 1) {
2474                         fail("seeking failed");
2475                 }
2476         } else {
2477                 fail(no_callback_msg);
2478         }
2479
2480         /* --- Stop --- */
2481
2482         reset_callback_info(&c);
2483
2484         g_debug("stop...");
2485         mafw_renderer_stop(g_gst_renderer, playback_cb, &c);
2486
2487         if (wait_for_callback(&c, wait_tout_val)) {
2488                 if (c.error)
2489                         fail(callback_err_msg, "stopping", c.err_code,
2490                              c.err_msg);
2491         } else {
2492                 fail(no_callback_msg);
2493         }
2494
2495         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
2496                 fail(state_err_msg,"mafw_renderer_stop", "Stopped", s.state);
2497         }
2498 }
2499 END_TEST
2500
2501 START_TEST(test_stop_state)
2502 {
2503         MafwPlaylist *playlist = NULL;
2504         gint i = 0;
2505         RendererInfo s = {0, };;
2506         CallbackInfo c = {0, };;
2507
2508         /* Initialize callback info */
2509         c.err_msg = NULL;
2510         c.error_signal_expected = FALSE;
2511         c.error_signal_received = NULL;
2512         c.property_expected = NULL;
2513         c.property_received = NULL;
2514
2515         /* Connect to renderer signals */
2516         g_signal_connect(g_gst_renderer, "error",
2517                          G_CALLBACK(error_cb),
2518                          &c);
2519
2520         g_signal_connect(g_gst_renderer, "state-changed",
2521                          G_CALLBACK(state_changed_cb),
2522                          &s);
2523         g_signal_connect(g_gst_renderer, "media-changed",
2524                          G_CALLBACK(media_changed_cb),
2525                          &s);
2526         g_signal_connect(g_gst_renderer, "playlist-changed",
2527                          G_CALLBACK(playlist_changed_cb),
2528                          NULL);
2529
2530         /* --- Get initial status --- */
2531
2532         reset_callback_info(&c);
2533
2534         g_debug("get status...");
2535         mafw_renderer_get_status(g_gst_renderer, status_cb, &s);
2536
2537         /* --- Prev --- */
2538
2539         reset_callback_info(&c);
2540
2541         g_debug("move to prev...");
2542         mafw_renderer_previous(g_gst_renderer, playback_cb, &c);
2543
2544         if (wait_for_callback(&c, wait_tout_val)) {
2545                 if (!c.error)
2546                         fail(callback_no_err_msg, "moving to prev", c.err_code,
2547                              c.err_msg);
2548         } else {
2549                 fail(no_callback_msg);
2550         }
2551
2552         /* --- Next --- */
2553
2554         reset_callback_info(&c);
2555
2556         g_debug("move to next...");
2557         mafw_renderer_next(g_gst_renderer, playback_cb, &c);
2558
2559         if (wait_for_callback(&c, wait_tout_val)) {
2560                 if (!c.error)
2561                         fail(callback_no_err_msg, "moving to next", c.err_code,
2562                              c.err_msg);
2563         } else {
2564                 fail(no_callback_msg);
2565         }
2566
2567         /* --- Go to index --- */
2568
2569         reset_callback_info(&c);
2570
2571         g_debug("goto index 8...");
2572         mafw_renderer_goto_index(g_gst_renderer, 8, playback_cb, &c);
2573
2574         if (wait_for_callback(&c, wait_tout_val)) {
2575                 if (!c.error)
2576                         fail(callback_no_err_msg, "going to index 8",
2577                              c.err_code, c.err_msg);
2578         } else {
2579                 fail(no_callback_msg);
2580         }
2581
2582         /* --- Create and assign a playlist --- */
2583
2584         g_debug("assign playlist...");
2585         playlist = MAFW_PLAYLIST(mafw_mock_playlist_new());
2586         for (i=0; i<10; i++) {
2587                 gchar *cur_item_oid =
2588                         get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
2589                 mafw_playlist_insert_item(
2590                         playlist, i, cur_item_oid, NULL);
2591                 g_free(cur_item_oid);
2592         }
2593         mafw_playlist_set_repeat(playlist, FALSE);
2594
2595         media_changed_called = FALSE;
2596         if (!mafw_renderer_assign_playlist(g_gst_renderer, playlist,
2597                                             NULL))
2598         {
2599                 fail("Assign playlist failed");
2600         }
2601
2602         wait_for_state(&s, Stopped, wait_tout_val);
2603
2604         /* Removing last element */
2605
2606         g_debug("removing last element...");
2607         fail_if(mafw_playlist_get_size(playlist, NULL) != 10,
2608                 "Playlist should have 10 elements");
2609         mafw_playlist_remove_item(playlist, 9, NULL);
2610         fail_if(mafw_playlist_get_size(playlist, NULL) != 9,
2611                 "Playlist should have 9 elements");
2612
2613         /* --- Go to index --- */
2614
2615         reset_callback_info(&c);
2616
2617         g_debug("goto index 9...");
2618         mafw_renderer_goto_index(g_gst_renderer, 9, playback_cb, &c);
2619
2620         if (wait_for_callback(&c, wait_tout_val)) {
2621                 if (!c.error)
2622                         fail(callback_no_err_msg, "going to index 9",
2623                              c.err_code, c.err_msg);
2624         } else {
2625                 fail(no_callback_msg);
2626         }
2627         reset_callback_info(&c);
2628 }
2629 END_TEST
2630
2631 START_TEST(test_transitioning_state)
2632 {
2633         MafwPlaylist *playlist = NULL;
2634         gint i = 0;
2635         RendererInfo s = {0, };;
2636         CallbackInfo c = {0, };;
2637         gchar *objectid = NULL;
2638
2639         /* Initialize callback info */
2640         c.err_msg = NULL;
2641         c.error_signal_expected = FALSE;
2642         c.error_signal_received = NULL;
2643         c.property_expected = NULL;
2644         c.property_received = NULL;
2645
2646         /* Connect to renderer signals */
2647         g_signal_connect(g_gst_renderer, "error",
2648                          G_CALLBACK(error_cb),
2649                          &c);
2650
2651         g_signal_connect(g_gst_renderer, "state-changed",
2652                          G_CALLBACK(state_changed_cb),
2653                          &s);
2654         g_signal_connect(g_gst_renderer, "media-changed",
2655                          G_CALLBACK(media_changed_cb),
2656                          &s);
2657         g_signal_connect(g_gst_renderer, "playlist-changed",
2658                          G_CALLBACK(playlist_changed_cb),
2659                          NULL);
2660
2661         /* --- Get initial status --- */
2662
2663         reset_callback_info(&c);
2664
2665         g_debug("get status...");
2666         mafw_renderer_get_status(g_gst_renderer, status_cb, &s);
2667
2668         /* --- Create and assign a playlist --- */
2669
2670         g_debug("assign playlist...");
2671         playlist = MAFW_PLAYLIST(mafw_mock_playlist_new());
2672         for (i=0; i<10; i++) {
2673                 gchar *cur_item_oid =
2674                         get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
2675                 mafw_playlist_insert_item(
2676                         playlist, i, cur_item_oid, NULL);
2677                 g_free(cur_item_oid);
2678         }
2679         mafw_playlist_set_repeat(playlist, FALSE);
2680
2681         media_changed_called = FALSE;
2682         if (!mafw_renderer_assign_playlist(g_gst_renderer, playlist,
2683                                             NULL))
2684         {
2685                 fail("Assign playlist failed");
2686         }
2687
2688         wait_for_state(&s, Stopped, wait_tout_val);
2689
2690         /* --- Play --- */
2691
2692         reset_callback_info(&c);
2693
2694         g_debug("play...");
2695         mafw_renderer_play(g_gst_renderer, playback_cb, &c);
2696
2697         if (wait_for_callback(&c, wait_tout_val)) {
2698                 if (c.error)
2699                         fail("Play after assigning playlist failed");
2700         } else {
2701                 fail(no_callback_msg);
2702         }
2703
2704         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2705                 fail(state_err_msg, "mafw_renderer_play",
2706                      "Transitioning", s.state);
2707         }
2708
2709         /* --- Play object --- */
2710
2711         reset_callback_info(&c);
2712
2713         objectid = get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
2714         g_debug("play_object... %s", objectid);
2715         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb,
2716                                    &c);
2717
2718         if (wait_for_callback(&c, wait_tout_val)) {
2719                 if (c.error)
2720                         fail(callback_err_msg, "playing an object", c.err_code,
2721                              c.err_msg);
2722         } else {
2723                 fail(no_callback_msg);
2724         }
2725
2726         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2727                 fail(state_err_msg, "mafw_renderer_play_object",
2728                      "Transitioning", s.state);
2729         }
2730
2731         g_free(objectid);
2732
2733
2734         /* --- Prev --- */
2735
2736         reset_callback_info(&c);
2737
2738         g_debug("move to prev...");
2739         mafw_renderer_previous(g_gst_renderer, playback_cb, &c);
2740
2741         if (wait_for_callback(&c, wait_tout_val)) {
2742                 if (c.error)
2743                         fail(callback_err_msg, "moving to prev", c.err_code,
2744                              c.err_msg);
2745         } else {
2746                 fail(no_callback_msg);
2747         }
2748
2749         fail_if(s.index != 9, index_err_msg, s.index, 9);
2750
2751         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2752                 fail(state_err_msg, "mafw_renderer_prev",
2753                      "Transitioning", s.state);
2754         }
2755
2756         /* Removing last element */
2757
2758         g_debug("removing last element...");
2759         fail_if(mafw_playlist_get_size(playlist, NULL) != 10,
2760                 "Playlist should have 10 elements");
2761         mafw_playlist_remove_item(playlist, 9, NULL);
2762         fail_if(mafw_playlist_get_size(playlist, NULL) != 9,
2763                 "Playlist should have 9 elements");
2764         fail_if(s.index != 8, index_err_msg, s.index, 8);
2765
2766         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2767                 fail(state_err_msg, "mafw_playlist_remove_element",
2768                      "Transitioning", s.state);
2769         }
2770
2771         /* --- Next --- */
2772
2773         reset_callback_info(&c);
2774
2775         g_debug("move to next...");
2776         mafw_renderer_next(g_gst_renderer, playback_cb, &c);
2777
2778         if (wait_for_callback(&c, wait_tout_val)) {
2779                 if (c.error)
2780                         fail(callback_err_msg, "moving to next", c.err_code,
2781                              c.err_msg);
2782         } else {
2783                 fail(no_callback_msg);
2784         }
2785
2786         fail_if(s.index != 0, index_err_msg, s.index, 0);
2787
2788         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2789                 fail(state_err_msg, "mafw_renderer_next",
2790                      "Transitioning", s.state);
2791         }
2792
2793         /* --- Go to index --- */
2794
2795         reset_callback_info(&c);
2796
2797         g_debug("goto index 8...");
2798         mafw_renderer_goto_index(g_gst_renderer, 8, playback_cb, &c);
2799
2800         if (wait_for_callback(&c, wait_tout_val)) {
2801                 if (c.error)
2802                         fail(callback_err_msg, "going to index 8", c.err_code,
2803                              c.err_msg);
2804         } else {
2805                 fail(no_callback_msg);
2806         }
2807
2808         fail_if(s.index != 8, index_err_msg, s.index, 8);
2809
2810         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2811                 fail(state_err_msg, "mafw_renderer_goto_index",
2812                      "Transitioning", s.state);
2813         }
2814 }
2815 END_TEST
2816
2817 START_TEST(test_state_class)
2818 {
2819         MafwPlaylist *playlist = NULL;
2820         gint i = 0;
2821         RendererInfo s = {0, };;
2822         CallbackInfo c = {0, };;
2823         gchar *objectid = NULL;
2824
2825         /* Initialize callback info */
2826         c.err_msg = NULL;
2827         c.error_signal_expected = FALSE;
2828         c.error_signal_received = NULL;
2829         c.property_expected = NULL;
2830         c.property_received = NULL;
2831
2832         /* Connect to renderer signals */
2833         g_signal_connect(g_gst_renderer, "error",
2834                          G_CALLBACK(error_cb),
2835                          &c);
2836
2837         g_signal_connect(g_gst_renderer, "state-changed",
2838                          G_CALLBACK(state_changed_cb),
2839                          &s);
2840         g_signal_connect(g_gst_renderer, "media-changed",
2841                          G_CALLBACK(media_changed_cb),
2842                          &s);
2843         g_signal_connect(g_gst_renderer, "playlist-changed",
2844                          G_CALLBACK(playlist_changed_cb),
2845                          NULL);
2846
2847         /* --- Get initial status --- */
2848
2849         reset_callback_info(&c);
2850
2851         g_debug("get status...");
2852         mafw_renderer_get_status(g_gst_renderer, status_cb, &s);
2853
2854         /* --- Play object --- */
2855
2856         reset_callback_info(&c);
2857
2858         objectid = get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
2859         g_debug("play_object... %s", objectid);
2860         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb,
2861                                    &c);
2862
2863         if (wait_for_callback(&c, wait_tout_val)) {
2864                 if (c.error)
2865                         fail(callback_err_msg, "playing an object", c.err_code,
2866                              c.err_msg);
2867         } else {
2868                 fail(no_callback_msg);
2869         }
2870
2871         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2872                 fail(state_err_msg, "mafw_renderer_play_object",
2873                      "Transitioning", s.state);
2874         }
2875
2876         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
2877                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
2878                      s.state);
2879         }
2880
2881         /* --- Prev --- */
2882
2883         reset_callback_info(&c);
2884
2885         g_debug("move to prev...");
2886         mafw_renderer_previous(g_gst_renderer, playback_cb, &c);
2887
2888         if (wait_for_callback(&c, wait_tout_val)) {
2889                 if (!c.error)
2890                         fail(callback_no_err_msg, "moving to prev", c.err_code,
2891                              c.err_msg);
2892         } else {
2893                 fail(no_callback_msg);
2894         }
2895
2896         /* --- Play object --- */
2897
2898         reset_callback_info(&c);
2899
2900         g_debug("play_object... %s", objectid);
2901         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb,
2902                                    &c);
2903
2904         if (wait_for_callback(&c, wait_tout_val)) {
2905                 if (c.error)
2906                         fail(callback_err_msg, "playing an object", c.err_code,
2907                              c.err_msg);
2908         } else {
2909                 fail(no_callback_msg);
2910         }
2911
2912         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2913                 fail(state_err_msg, "mafw_renderer_play_object",
2914                      "Transitioning", s.state);
2915         }
2916
2917         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
2918                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
2919                      s.state);
2920         }
2921
2922         /* --- Next --- */
2923
2924         reset_callback_info(&c);
2925
2926         g_debug("move to next...");
2927         mafw_renderer_next(g_gst_renderer, playback_cb, &c);
2928
2929         if (wait_for_callback(&c, wait_tout_val)) {
2930                 if (!c.error)
2931                         fail(callback_no_err_msg, "moving to next", c.err_code,
2932                              c.err_msg);
2933         } else {
2934                 fail(no_callback_msg);
2935         }
2936
2937         /* --- Play object --- */
2938
2939         reset_callback_info(&c);
2940
2941         g_debug("play_object... %s", objectid);
2942         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb,
2943                                    &c);
2944
2945         if (wait_for_callback(&c, wait_tout_val)) {
2946                 if (c.error)
2947                         fail(callback_err_msg, "playing an object", c.err_code,
2948                              c.err_msg);
2949         } else {
2950                 fail(no_callback_msg);
2951         }
2952
2953         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
2954                 fail(state_err_msg, "mafw_renderer_play_object",
2955                      "Transitioning", s.state);
2956         }
2957
2958         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
2959                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
2960                      s.state);
2961         }
2962
2963         /* --- Go to index --- */
2964
2965         reset_callback_info(&c);
2966
2967         g_debug("goto index 8...");
2968         mafw_renderer_goto_index(g_gst_renderer, 8, playback_cb, &c);
2969
2970         if (wait_for_callback(&c, wait_tout_val)) {
2971                 if (!c.error)
2972                         fail(callback_err_msg, "going to index 8", c.err_code,
2973                              c.err_msg);
2974         } else {
2975                 fail(no_callback_msg);
2976         }
2977
2978         /* --- Create and assign a playlist --- */
2979
2980         g_debug("assign playlist...");
2981         playlist = MAFW_PLAYLIST(mafw_mock_playlist_new());
2982         for (i=0; i<10; i++) {
2983                 gchar *cur_item_oid =
2984                         get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
2985                 mafw_playlist_insert_item(
2986                         playlist, i, cur_item_oid, NULL);
2987                 g_free(cur_item_oid);
2988         }
2989         mafw_playlist_set_repeat(playlist, FALSE);
2990
2991         media_changed_called = FALSE;
2992         if (!mafw_renderer_assign_playlist(g_gst_renderer, playlist,
2993                                             NULL))
2994         {
2995                 fail("Assign playlist failed");
2996         }
2997
2998         wait_for_state(&s, Stopped, wait_tout_val);
2999
3000         /* --- Play object --- */
3001
3002         reset_callback_info(&c);
3003
3004         g_debug("play_object... %s", objectid);
3005         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb,
3006                                    &c);
3007
3008         if (wait_for_callback(&c, wait_tout_val)) {
3009                 if (c.error)
3010                         fail(callback_err_msg, "playing an object", c.err_code,
3011                              c.err_msg);
3012         } else {
3013                 fail(no_callback_msg);
3014         }
3015
3016         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
3017                 fail(state_err_msg, "mafw_renderer_play_object",
3018                      "Transitioning", s.state);
3019         }
3020
3021         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
3022                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
3023                      s.state);
3024         }
3025
3026         /* --- Next --- */
3027
3028         reset_callback_info(&c);
3029
3030         g_debug("move to next...");
3031         mafw_renderer_next(g_gst_renderer, playback_cb, &c);
3032
3033         if (wait_for_callback(&c, wait_tout_val)) {
3034                 if (c.error)
3035                         fail(callback_err_msg, "moving to next", c.err_code,
3036                              c.err_msg);
3037         } else {
3038                 fail(no_callback_msg);
3039         }
3040
3041         fail_if(s.index != 1, index_err_msg, s.index, 1);
3042
3043         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
3044                 fail(state_err_msg, "mafw_renderer_next", "Playing",
3045                      s.state);
3046         }
3047
3048         /* --- Play object --- */
3049
3050         reset_callback_info(&c);
3051
3052         g_debug("play_object... %s", objectid);
3053         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb,
3054                                    &c);
3055
3056         if (wait_for_callback(&c, wait_tout_val)) {
3057                 if (c.error)
3058                         fail(callback_err_msg, "playing an object", c.err_code,
3059                              c.err_msg);
3060         } else {
3061                 fail(no_callback_msg);
3062         }
3063
3064         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
3065                 fail(state_err_msg, "mafw_renderer_play_object",
3066                      "Transitioning", s.state);
3067         }
3068
3069         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
3070                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
3071                      s.state);
3072         }
3073
3074         /* --- Go to index --- */
3075
3076         reset_callback_info(&c);
3077
3078         g_debug("goto index 8...");
3079         mafw_renderer_goto_index(g_gst_renderer, 8, playback_cb, &c);
3080
3081         if (wait_for_callback(&c, wait_tout_val)) {
3082                 if (c.error)
3083                         fail(callback_err_msg, "going to index 8", c.err_code,
3084                              c.err_msg);
3085         } else {
3086                 fail(no_callback_msg);
3087         }
3088
3089         fail_if(s.index != 8, index_err_msg, s.index, 8);
3090
3091         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
3092                 fail(state_err_msg, "mafw_renderer_goto_index", "Playing",
3093                      s.state);
3094         }
3095
3096         /* --- Play object --- */
3097
3098         reset_callback_info(&c);
3099
3100         g_debug("play_object... %s", objectid);
3101         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb,
3102                                    &c);
3103
3104         if (wait_for_callback(&c, wait_tout_val)) {
3105                 if (c.error)
3106                         fail(callback_err_msg, "playing an object", c.err_code,
3107                              c.err_msg);
3108         } else {
3109                 fail(no_callback_msg);
3110         }
3111
3112         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
3113                 fail(state_err_msg, "mafw_renderer_play_object",
3114                      "Transitioning", s.state);
3115         }
3116
3117         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
3118                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
3119                      s.state);
3120         }
3121
3122         /* --- Prev --- */
3123
3124         reset_callback_info(&c);
3125
3126         g_debug("move to prev...");
3127         mafw_renderer_previous(g_gst_renderer, playback_cb, &c);
3128
3129         if (wait_for_callback(&c, wait_tout_val)) {
3130                 if (c.error)
3131                         fail(callback_err_msg, "moving to prev", c.err_code,
3132                              c.err_msg);
3133         } else {
3134                 fail(no_callback_msg);
3135         }
3136
3137         fail_if(s.index != 7, index_err_msg, s.index, 7);
3138
3139         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
3140                 fail(state_err_msg, "mafw_renderer_prev", "Playing",
3141                      s.state);
3142         }
3143
3144         /* --- Play --- */
3145
3146         reset_callback_info(&c);
3147
3148         g_debug("play...");
3149         mafw_renderer_play(g_gst_renderer, playback_cb, &c);
3150
3151         if (wait_for_callback(&c, wait_tout_val)) {
3152                 if (c.error)
3153                         fail("Play after assigning playlist failed");
3154         } else {
3155                 fail(no_callback_msg);
3156         }
3157
3158         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
3159                 fail(state_err_msg, "mafw_renderer_play",
3160                      "Transitioning", s.state);
3161         }
3162
3163         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
3164                 fail(state_err_msg, "mafw_renderer_play", "Playing",
3165                      s.state);
3166         }
3167
3168         /* --- Prev --- */
3169
3170         reset_callback_info(&c);
3171
3172         g_debug("move to prev...");
3173         mafw_renderer_previous(g_gst_renderer, playback_cb, &c);
3174
3175         if (wait_for_callback(&c, wait_tout_val)) {
3176                 if (c.error)
3177                         fail(callback_err_msg, "moving to prev", c.err_code,
3178                              c.err_msg);
3179         } else {
3180                 fail(no_callback_msg);
3181         }
3182
3183         fail_if(s.index != 6, index_err_msg, s.index, 6);
3184
3185         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
3186                 fail(state_err_msg, "mafw_renderer_prev",
3187                      "Transitioning", s.state);
3188         }
3189
3190         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
3191                 fail(state_err_msg, "mafw_renderer_prev",
3192                      "Transitioning", s.state);
3193         }
3194
3195         /* --- Seeking --- */
3196
3197         reset_callback_info(&c);
3198
3199         g_debug("seeking...");
3200         mafw_renderer_set_position(g_gst_renderer, SeekRelative, 1,
3201                                     seek_cb, &c);
3202
3203         if (wait_for_callback(&c, wait_tout_val)) {
3204                 if (c.error)
3205                         fail(callback_err_msg, "seeking failed", c.err_code,
3206                              c.err_msg);
3207                 if (c.seek_position != 1) {
3208                         fail("seeking failed");
3209                 }
3210         } else {
3211                 fail(no_callback_msg);
3212         }
3213
3214         /* --- Seeking --- */
3215
3216         reset_callback_info(&c);
3217
3218         g_debug("seeking...");
3219         mafw_renderer_set_position(g_gst_renderer, SeekAbsolute, -1,
3220                                     seek_cb, &c);
3221
3222         if (wait_for_callback(&c, wait_tout_val)) {
3223                 if (c.error)
3224                         fail(callback_err_msg, "seeking failed", c.err_code,
3225                              c.err_msg);
3226                 if (c.seek_position != -1) {
3227                         fail("seeking failed");
3228                 }
3229         } else {
3230                 fail(no_callback_msg);
3231         }
3232
3233         /* --- Seeking --- */
3234
3235         reset_callback_info(&c);
3236
3237         g_debug("seeking...");
3238         mafw_renderer_set_position(g_gst_renderer, SeekAbsolute, 1,
3239                                     seek_cb, &c);
3240
3241         if (wait_for_callback(&c, wait_tout_val)) {
3242                 if (c.error)
3243                         fail(callback_err_msg, "seeking failed", c.err_code,
3244                              c.err_msg);
3245                 if (c.seek_position != 1) {
3246                         fail("seeking failed");
3247                 }
3248         } else {
3249                 fail(no_callback_msg);
3250         }
3251 }
3252 END_TEST
3253
3254 START_TEST(test_playlist_iterator)
3255 {
3256         MafwPlaylist *playlist = NULL;
3257         gint i = 0;
3258         CallbackInfo c = {0, };;
3259         MafwPlaylistIterator *iterator = NULL;
3260         GError *error = NULL;
3261         gint size;
3262         gint index;
3263
3264         /* Initialize callback info */
3265         c.err_msg = NULL;
3266         c.error = FALSE;
3267         reset_callback_info(&c);
3268
3269         /* --- Create and assign a playlist --- */
3270
3271         g_debug("assign playlist...");
3272         playlist = MAFW_PLAYLIST(mafw_mock_playlist_new());
3273
3274         iterator = mafw_playlist_iterator_new();
3275         mafw_playlist_iterator_initialize(iterator, playlist, &error);
3276         if (error != NULL) {
3277                 fail("Error found: %s, %d, %s",
3278                      g_quark_to_string(error->domain),
3279                      error->code, error->message);
3280         }
3281
3282         for (i = 0; i < 3; i++) {
3283                 gchar *cur_item_oid = NULL;
3284                 cur_item_oid =
3285                         get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
3286                 mafw_playlist_insert_item(playlist, 0, cur_item_oid, NULL);
3287                 g_free(cur_item_oid);
3288         }
3289
3290         size = mafw_playlist_iterator_get_size(iterator, NULL);
3291         fail_if(size != 3, "Playlist should have 3 elements and it has %d",
3292                 size);
3293         index = mafw_playlist_iterator_get_current_index(iterator);
3294         fail_if(index != 2, "Index should be 2 and it is %d", index);
3295
3296         mafw_playlist_move_item(playlist, 1, 2, NULL);
3297         index = mafw_playlist_iterator_get_current_index(iterator);
3298         fail_if(index != 1, "Index should be 1 and it is %d", index);
3299
3300         mafw_playlist_move_item(playlist, 2, 1, NULL);
3301         index = mafw_playlist_iterator_get_current_index(iterator);
3302         fail_if(index != 2, "Index should be 2 and it is %d", index);
3303
3304         mafw_playlist_move_item(playlist, 2, 1, NULL);
3305         index = mafw_playlist_iterator_get_current_index(iterator);
3306         fail_if(index != 1, "Index should be 1 and it is %d", index);
3307
3308         mafw_playlist_remove_item(playlist, 0, &error);
3309         if (error != NULL) {
3310                 fail("Error found: %s, %d, %s",
3311                      g_quark_to_string(error->domain),
3312                      error->code, error->message);
3313         }
3314
3315         size = mafw_playlist_iterator_get_size(iterator, NULL);
3316         fail_if(size != 2, "Playlist should have 2 elements and it has %d",
3317                 size);
3318         index = mafw_playlist_iterator_get_current_index(iterator);
3319         fail_if(index != 0, "Index should be 0 and it is %d", index);
3320
3321         mafw_playlist_iterator_reset(iterator, NULL);
3322         index = mafw_playlist_iterator_get_current_index(iterator);
3323         fail_if(index != 0, "Index should be 0 and it is %d", index);
3324
3325         mafw_playlist_remove_item(playlist, 0, &error);
3326         if (error != NULL) {
3327                 fail("Error found: %s, %d, %s",
3328                      g_quark_to_string(error->domain),
3329                      error->code, error->message);
3330         }
3331
3332         size = mafw_playlist_iterator_get_size(iterator, NULL);
3333         fail_if(size != 1, "Playlist should have 1 elements and it has %d",
3334                 size);
3335         index = mafw_playlist_iterator_get_current_index(iterator);
3336         fail_if(index != 0, "Index should be 0 and it is %d", index);
3337
3338         mafw_playlist_remove_item(playlist, 0, &error);
3339         if (error != NULL) {
3340                 fail("Error found: %s, %d, %s",
3341                      g_quark_to_string(error->domain),
3342                      error->code, error->message);
3343         }
3344
3345         size = mafw_playlist_iterator_get_size(iterator, NULL);
3346         fail_if(size != 0, "Playlist should have 0 elements and it has %d",
3347                 size);
3348         index = mafw_playlist_iterator_get_current_index(iterator);
3349         fail_if(index != -1, "Index should be -1 and it is %d", index);
3350
3351         g_object_unref(iterator);
3352 }
3353 END_TEST
3354
3355 START_TEST(test_video)
3356 {
3357         RendererInfo s = {0, };;
3358         CallbackInfo c = {0, };;
3359         MetadataChangedInfo m;
3360         gchar *objectid = NULL;
3361         GstBus *bus = NULL;
3362         GstStructure *structure = NULL;
3363         GstMessage *message = NULL;
3364
3365         /* Initialize callback info */
3366         c.err_msg = NULL;
3367         c.error_signal_expected = FALSE;
3368         c.error_signal_received = NULL;
3369         m.expected_key = NULL;
3370         m.value = NULL;
3371         c.property_expected = NULL;
3372         c.property_received = NULL;
3373
3374         /* Connect to renderer signals */
3375         g_signal_connect(g_gst_renderer, "error",
3376                          G_CALLBACK(error_cb),
3377                          &c);
3378
3379         g_signal_connect(g_gst_renderer, "state-changed",
3380                          G_CALLBACK(state_changed_cb),
3381                          &s);
3382         g_signal_connect(g_gst_renderer, "media-changed",
3383                          G_CALLBACK(media_changed_cb),
3384                          &s);
3385         g_signal_connect(g_gst_renderer, "playlist-changed",
3386                          G_CALLBACK(playlist_changed_cb),
3387                          NULL);
3388         g_signal_connect(g_gst_renderer, "metadata-changed",
3389                          G_CALLBACK(metadata_changed_cb),
3390                          &m);
3391
3392 #ifdef HAVE_GDKPIXBUF
3393         mafw_extension_set_property_boolean(
3394                 MAFW_EXTENSION(g_gst_renderer),
3395                 MAFW_PROPERTY_GST_RENDERER_CURRENT_FRAME_ON_PAUSE,
3396                 TRUE);
3397 #endif
3398
3399         /* --- Get initial status --- */
3400
3401         reset_callback_info(&c);
3402
3403         g_debug("get status...");
3404         mafw_renderer_get_status(g_gst_renderer, status_cb, &s);
3405
3406         /* --- Play object --- */
3407
3408         reset_callback_info(&c);
3409
3410         objectid = get_sample_clip_objectid(SAMPLE_VIDEO_CLIP);
3411         g_debug("play_object... %s", objectid);
3412         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb,
3413                                    &c);
3414
3415         if (wait_for_callback(&c, wait_tout_val)) {
3416                 if (c.error)
3417                         fail(callback_err_msg, "playing an object", c.err_code,
3418                              c.err_msg);
3419         } else {
3420                 fail(no_callback_msg);
3421         }
3422
3423         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
3424                 fail(state_err_msg, "mafw_renderer_play_object",
3425                      "Transitioning", s.state);
3426         }
3427
3428         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
3429                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
3430                      s.state);
3431         }
3432
3433         MAFW_GST_RENDERER(g_gst_renderer)->worker->xid = 0x1;
3434         bus = MAFW_GST_RENDERER(g_gst_renderer)->worker->bus;
3435         fail_if(bus == NULL, "No GstBus");
3436
3437         structure = gst_structure_new("prepare-xwindow-id", "width",
3438                                       G_TYPE_INT, 64, "height", G_TYPE_INT, 32,
3439                                       NULL);
3440         message = gst_message_new_element(NULL, structure);
3441         gst_bus_post(bus, message);
3442
3443         /* --- Pause --- */
3444
3445         reset_callback_info(&c);
3446
3447         m.expected_key = MAFW_METADATA_KEY_PAUSED_THUMBNAIL_URI;
3448
3449         g_debug("pause...");
3450         mafw_renderer_pause(g_gst_renderer, playback_cb, &c);
3451
3452         if (wait_for_callback(&c, wait_tout_val)) {
3453                 if (c.error)
3454                         fail(callback_err_msg, "pausing", c.err_code,
3455                              c.err_msg);
3456         } else {
3457                 fail(no_callback_msg);
3458         }
3459
3460         if (wait_for_state(&s, Paused, wait_tout_val) == FALSE) {
3461                 fail(state_err_msg, "mafw_renderer_prev", "Playing",
3462                      s.state);
3463         }
3464
3465         if (wait_for_metadata(&m, wait_tout_val) == FALSE) {
3466                 fail("Expected " MAFW_METADATA_KEY_PAUSED_THUMBNAIL_URI
3467                      ", but not received");
3468         }
3469
3470         fail_if(m.value == NULL, "Metadata "
3471                 MAFW_METADATA_KEY_PAUSED_THUMBNAIL_URI " not received");
3472
3473         g_value_unset(m.value);
3474         g_free(m.value);
3475         m.value = NULL;
3476         m.expected_key = NULL;
3477
3478         /* --- Resume --- */
3479
3480         reset_callback_info(&c);
3481
3482         g_debug("resume...");
3483         mafw_renderer_resume(g_gst_renderer, playback_cb, &c);
3484
3485         if (wait_for_callback(&c, wait_tout_val)) {
3486                 if (c.error)
3487                         fail(callback_err_msg, "resuming", c.err_code,
3488                              c.err_msg);
3489         } else {
3490                 fail(no_callback_msg);
3491         }
3492
3493         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
3494                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
3495                      s.state);
3496         }
3497
3498         /* --- EOS --- */
3499
3500         if (wait_for_state(&s, Stopped, 3000) == FALSE) {
3501                 fail(state_err_msg, "mafw_renderer_play_object", "Stop",
3502                      s.state);
3503         }
3504
3505         g_free(objectid);
3506 }
3507 END_TEST
3508
3509 START_TEST(test_media_art)
3510 {
3511         RendererInfo s = {0, };;
3512         CallbackInfo c = {0, };;
3513         MetadataChangedInfo m;
3514         gchar *objectid = NULL;
3515         GstBus *bus = NULL;
3516         GstMessage *message = NULL;
3517         GstTagList *list = NULL;
3518         GstBuffer *buffer = NULL;
3519         guchar *image = NULL;
3520         gchar *image_path = NULL;
3521         gsize image_length;
3522         GstCaps *caps = NULL;
3523
3524         /* Initialize callback info */
3525         c.err_msg = NULL;
3526         c.error_signal_expected = FALSE;
3527         m.expected_key = NULL;
3528         m.value = NULL;
3529         c.property_expected = NULL;
3530         c.property_received = NULL;
3531
3532         /* Connect to renderer signals */
3533         g_signal_connect(g_gst_renderer, "error",
3534                          G_CALLBACK(error_cb),
3535                          &c);
3536
3537         g_signal_connect(g_gst_renderer, "state-changed",
3538                          G_CALLBACK(state_changed_cb),
3539                          &s);
3540         g_signal_connect(g_gst_renderer, "media-changed",
3541                          G_CALLBACK(media_changed_cb),
3542                          &s);
3543         g_signal_connect(g_gst_renderer, "playlist-changed",
3544                          G_CALLBACK(playlist_changed_cb),
3545                          NULL);
3546         g_signal_connect(g_gst_renderer, "metadata-changed",
3547                          G_CALLBACK(metadata_changed_cb),
3548                          &m);
3549
3550         /* --- Get initial status --- */
3551
3552         reset_callback_info(&c);
3553
3554         g_debug("get status...");
3555         mafw_renderer_get_status(g_gst_renderer, status_cb, &s);
3556
3557         /* --- Play object --- */
3558
3559         reset_callback_info(&c);
3560
3561         objectid = get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
3562         g_debug("play_object... %s", objectid);
3563         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb,
3564                                    &c);
3565
3566         if (wait_for_callback(&c, wait_tout_val)) {
3567                 if (c.error)
3568                         fail(callback_err_msg, "playing an object", c.err_code,
3569                              c.err_msg);
3570         } else {
3571                 fail(no_callback_msg);
3572         }
3573
3574         /* --- Pause --- */
3575
3576         reset_callback_info(&c);
3577
3578         g_debug("pause...");
3579         mafw_renderer_pause(g_gst_renderer, playback_cb, &c);
3580
3581         if (wait_for_callback(&c, wait_tout_val)) {
3582                 if (c.error)
3583                         fail(callback_err_msg, "pausing", c.err_code,
3584                              c.err_msg);
3585         } else {
3586                 fail(no_callback_msg);
3587         }
3588
3589         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
3590                 fail(state_err_msg, "mafw_renderer_play_object",
3591                      "Transitioning", s.state);
3592         }
3593
3594         if (wait_for_state(&s, Paused, wait_tout_val) == FALSE) {
3595                 fail(state_err_msg, "mafw_renderer_prev", "Playing",
3596                      s.state);
3597         }
3598
3599         /* Emit image */
3600
3601         bus = MAFW_GST_RENDERER(g_gst_renderer)->worker->bus;
3602         fail_if(bus == NULL, "No GstBus");
3603
3604         m.expected_key = MAFW_METADATA_KEY_RENDERER_ART_URI;
3605
3606         image_path = get_sample_clip_path(SAMPLE_IMAGE);
3607         fail_if(!g_file_get_contents(image_path + 7, (gchar **) &image,
3608                                      &image_length, NULL),
3609                 "Could not load test image");
3610         g_free(image_path);
3611
3612         buffer = gst_buffer_new();
3613         gst_buffer_set_data(buffer, image, image_length);
3614         caps = gst_caps_new_simple("image/png", "image-type",
3615                                    GST_TYPE_TAG_IMAGE_TYPE,
3616                                    GST_TAG_IMAGE_TYPE_FRONT_COVER, NULL);
3617         gst_buffer_set_caps(buffer, caps);
3618         gst_caps_unref(caps);
3619
3620         list = gst_tag_list_new();
3621         gst_tag_list_add(list, GST_TAG_MERGE_APPEND, GST_TAG_IMAGE, buffer,
3622                          NULL);
3623
3624         message = gst_message_new_tag(NULL, list);
3625         gst_bus_post(bus, message);
3626
3627         /* --- Resume --- */
3628
3629         reset_callback_info(&c);
3630
3631         g_debug("resume...");
3632         mafw_renderer_resume(g_gst_renderer, playback_cb, &c);
3633
3634         if (wait_for_callback(&c, wait_tout_val)) {
3635                 if (c.error)
3636                         fail(callback_err_msg, "resuming", c.err_code,
3637                              c.err_msg);
3638         } else {
3639                 fail(no_callback_msg);
3640         }
3641
3642         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
3643                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
3644                      s.state);
3645         }
3646
3647         if (wait_for_metadata(&m, wait_tout_val) == FALSE) {
3648                 fail("Expected " MAFW_METADATA_KEY_RENDERER_ART_URI
3649                      ", but not received");
3650         }
3651
3652         fail_if(m.value == NULL, "Metadata "
3653                 MAFW_METADATA_KEY_RENDERER_ART_URI " not received");
3654
3655         g_value_unset(m.value);
3656         g_free(m.value);
3657         m.value = NULL;
3658         m.expected_key = NULL;
3659
3660         /* --- EOS --- */
3661
3662         if (wait_for_state(&s, Stopped, 3000) == FALSE) {
3663                 fail(state_err_msg, "mafw_renderer_play_object", "Stop",
3664                      s.state);
3665         }
3666
3667         g_free(objectid);
3668 }
3669 END_TEST
3670
3671 START_TEST(test_properties_management)
3672 {
3673         RendererInfo s;
3674         CallbackInfo c = {0, };;
3675         PropertyChangedInfo p;
3676
3677         /* Initialize callback info */
3678         c.err_msg = NULL;
3679         c.error_signal_expected = FALSE;
3680         c.error_signal_received = NULL;
3681         c.property_expected = NULL;
3682         c.property_received = NULL;
3683         p.expected = NULL;
3684         p.received = NULL;
3685
3686         /* Connect to renderer signals */
3687         g_signal_connect(g_gst_renderer, "state-changed",
3688                          G_CALLBACK(state_changed_cb),
3689                          &s);
3690         g_signal_connect(g_gst_renderer, "property-changed",
3691                          G_CALLBACK(property_changed_cb),
3692                          &p);
3693
3694         /* Wait for the volume manager to be initialized */
3695
3696         /* Volume */
3697
3698         p.expected = MAFW_PROPERTY_RENDERER_VOLUME;
3699
3700         if (!wait_for_property(&p, wait_tout_val)) {
3701                 fail("No property %s received", p.expected);
3702         }
3703
3704         fail_if(p.received == NULL, "No property %s received",
3705                 p.expected);
3706         fail_if(p.received != NULL &&
3707                 g_value_get_uint(p.received) != 48,
3708                 "Property with value %d and %d expected",
3709                 g_value_get_uint(p.received), 48);
3710
3711         if (p.received != NULL) {
3712                 g_value_unset(p.received);
3713                 g_free(p.received);
3714                 p.received = NULL;
3715         }
3716         p.expected = NULL;
3717
3718         /* --- mute --- */
3719
3720         reset_callback_info(&c);
3721
3722         c.property_expected = MAFW_PROPERTY_RENDERER_MUTE;
3723
3724         mafw_extension_set_property_boolean(MAFW_EXTENSION(g_gst_renderer),
3725                                             c.property_expected, TRUE);
3726
3727         p.expected = MAFW_PROPERTY_RENDERER_MUTE;
3728
3729 #ifdef MAFW_GST_RENDERER_ENABLE_MUTE
3730         if (!wait_for_property(&p, wait_tout_val)) {
3731                 fail("No property %s received", p.expected);
3732         }
3733
3734         fail_if(p.received == NULL, "No property %s received",
3735                 p.expected);
3736         fail_if(p.received != NULL &&
3737                 g_value_get_boolean(p.received) != TRUE,
3738                 "Property with value %d and %d expected",
3739                 g_value_get_boolean(p.received), TRUE);
3740 #else
3741         if (wait_for_property(&p, wait_tout_val)) {
3742                 fail("Property %s received and it should not have been",
3743                      p.expected);
3744         }
3745
3746         fail_if(p.received != NULL,
3747                 "Property %s received and it should not have been",
3748                 p.expected);
3749 #endif
3750
3751         if (p.received != NULL) {
3752                 g_value_unset(p.received);
3753                 g_free(p.received);
3754                 p.received = NULL;
3755         }
3756         p.expected = NULL;
3757
3758         mafw_extension_get_property(MAFW_EXTENSION(g_gst_renderer),
3759                                     c.property_expected, get_property_cb, &c);
3760
3761         if (wait_for_callback(&c, wait_tout_val)) {
3762                 if (c.error)
3763                         fail(callback_err_msg, "get_property", c.err_code,
3764                              c.err_msg);
3765         } else {
3766                 fail(no_callback_msg);
3767         }
3768
3769         fail_if(c.property_received == NULL,
3770                 "No property %s received and expected", c.property_expected);
3771 #ifdef MAFW_GST_RENDERER_ENABLE_MUTE
3772         fail_if(c.property_received != NULL &&
3773                 g_value_get_boolean(c.property_received) != TRUE,
3774                 "Property with value %d and %d expected",
3775                 g_value_get_boolean(c.property_received), TRUE);
3776 #else
3777         fail_if(c.property_received != NULL &&
3778                 g_value_get_boolean(c.property_received) != FALSE,
3779                 "Property with value %d and %d expected",
3780                 g_value_get_boolean(c.property_received), FALSE);
3781 #endif
3782
3783         /* --- xid --- */
3784
3785         reset_callback_info(&c);
3786
3787         c.property_expected = MAFW_PROPERTY_RENDERER_XID;
3788
3789         mafw_extension_set_property_uint(MAFW_EXTENSION(g_gst_renderer),
3790                                          c.property_expected, 50);
3791
3792         mafw_extension_get_property(MAFW_EXTENSION(g_gst_renderer),
3793                                     c.property_expected, get_property_cb, &c);
3794
3795         if (wait_for_callback(&c, wait_tout_val)) {
3796                 if (c.error)
3797                         fail(callback_err_msg, "get_property", c.err_code,
3798                              c.err_msg);
3799         } else {
3800                 fail(no_callback_msg);
3801         }
3802
3803         fail_if(c.property_received == NULL,
3804                 "No property %s received and expected", c.property_expected);
3805         fail_if(c.property_received != NULL &&
3806                 g_value_get_uint(c.property_received) != 50,
3807                 "Property with value %d and %d expected",
3808                 g_value_get_uint(c.property_received), 50);
3809
3810         /* --- error policy --- */
3811
3812         reset_callback_info(&c);
3813
3814         c.property_expected = MAFW_PROPERTY_RENDERER_ERROR_POLICY;
3815
3816         mafw_extension_set_property_uint(MAFW_EXTENSION(g_gst_renderer),
3817                                          c.property_expected, 1);
3818
3819         mafw_extension_get_property(MAFW_EXTENSION(g_gst_renderer),
3820                                     c.property_expected, get_property_cb, &c);
3821
3822         if (wait_for_callback(&c, wait_tout_val)) {
3823                 if (c.error)
3824                         fail(callback_err_msg, "get_property", c.err_code,
3825                              c.err_msg);
3826         } else {
3827                 fail(no_callback_msg);
3828         }
3829
3830         fail_if(c.property_received == NULL,
3831                 "No property %s received and expected", c.property_expected);
3832         fail_if(c.property_received != NULL &&
3833                 g_value_get_uint(c.property_received) != 1,
3834                 "Property with value %d and %d expected",
3835                 g_value_get_uint(c.property_received), 1);
3836
3837         /* --- autopaint --- */
3838
3839         reset_callback_info(&c);
3840
3841         c.property_expected = MAFW_PROPERTY_RENDERER_AUTOPAINT;
3842
3843         mafw_extension_set_property_boolean(MAFW_EXTENSION(g_gst_renderer),
3844                                             c.property_expected, TRUE);
3845
3846         mafw_extension_get_property(MAFW_EXTENSION(g_gst_renderer),
3847                                     c.property_expected, get_property_cb, &c);
3848
3849         if (wait_for_callback(&c, wait_tout_val)) {
3850                 if (c.error)
3851                         fail(callback_err_msg, "get_property", c.err_code,
3852                              c.err_msg);
3853         } else {
3854                 fail(no_callback_msg);
3855         }
3856
3857         fail_if(c.property_received == NULL,
3858                 "No property %s received and expected", c.property_expected);
3859         fail_if(c.property_received != NULL &&
3860                 g_value_get_boolean(c.property_received) != TRUE,
3861                 "Property with value %d and %d expected",
3862                 g_value_get_boolean(c.property_received), TRUE);
3863
3864         /* --- colorkey --- */
3865
3866         reset_callback_info(&c);
3867
3868         c.property_expected = MAFW_PROPERTY_RENDERER_COLORKEY;
3869
3870         mafw_extension_get_property(MAFW_EXTENSION(g_gst_renderer),
3871                                     c.property_expected, get_property_cb, &c);
3872
3873         if (wait_for_callback(&c, wait_tout_val)) {
3874                 if (c.error)
3875                         fail(callback_err_msg, "get_property", c.err_code,
3876                              c.err_msg);
3877         } else {
3878                 fail(no_callback_msg);
3879         }
3880
3881         fail_if(c.property_received == NULL,
3882                 "No property %s received and expected", c.property_expected);
3883         fail_if(c.property_received != NULL &&
3884                 g_value_get_int(c.property_received) != -1,
3885                 "Property with value %d and %d expected",
3886                 g_value_get_int(c.property_received), -1);
3887
3888         /* --- current frame on pause --- */
3889
3890         reset_callback_info(&c);
3891
3892         c.property_expected = MAFW_PROPERTY_GST_RENDERER_CURRENT_FRAME_ON_PAUSE;
3893
3894         mafw_extension_set_property_boolean(MAFW_EXTENSION(g_gst_renderer),
3895                                             c.property_expected, TRUE);
3896
3897         mafw_extension_get_property(MAFW_EXTENSION(g_gst_renderer),
3898                                     c.property_expected, get_property_cb, &c);
3899
3900         if (wait_for_callback(&c, wait_tout_val)) {
3901                 if (c.error)
3902                         fail(callback_err_msg, "get_property", c.err_code,
3903                              c.err_msg);
3904         } else {
3905                 fail(no_callback_msg);
3906         }
3907
3908         fail_if(c.property_received == NULL,
3909                 "No property %s received and expected", c.property_expected);
3910         fail_if(c.property_received != NULL &&
3911                 g_value_get_boolean(c.property_received) != TRUE,
3912                 "Property with value %d and %d expected",
3913                 g_value_get_boolean(c.property_received), TRUE);
3914
3915         /* --- volume --- */
3916
3917         p.expected = MAFW_PROPERTY_RENDERER_VOLUME;
3918
3919         mafw_extension_set_property_uint(MAFW_EXTENSION(g_gst_renderer),
3920                                          p.expected, 50);
3921
3922         if (!wait_for_property(&p, wait_tout_val)) {
3923                 fail("No property %s received", p.expected);
3924         }
3925
3926         fail_if(p.received == NULL, "No property %s received",
3927                 p.expected);
3928         fail_if(p.received != NULL &&
3929                 g_value_get_uint(p.received) != 50,
3930                 "Property with value %d and %d expected",
3931                 g_value_get_uint(p.received), 50);
3932
3933         if (p.received != NULL) {
3934                 g_value_unset(p.received);
3935                 g_free(p.received);
3936                 p.received = NULL;
3937         }
3938         p.expected = NULL;
3939
3940         c.property_expected = MAFW_PROPERTY_RENDERER_VOLUME;
3941
3942         mafw_extension_get_property(MAFW_EXTENSION(g_gst_renderer),
3943                                     c.property_expected, get_property_cb, &c);
3944
3945         if (wait_for_callback(&c, wait_tout_val)) {
3946                 if (c.error)
3947                         fail(callback_err_msg, "get_property", c.err_code,
3948                              c.err_msg);
3949         } else {
3950                 fail(no_callback_msg);
3951         }
3952
3953         fail_if(c.property_received == NULL,
3954                 "No property %s received and expected", c.property_expected);
3955         fail_if(c.property_received != NULL &&
3956                 g_value_get_uint(c.property_received) != 50,
3957                 "Property with value %d and %d expected",
3958                 g_value_get_uint(c.property_received), 50);
3959
3960 #ifndef MAFW_GST_RENDERER_DISABLE_PULSE_VOLUME
3961         /* Test reconnection to pulse */
3962
3963         pa_context_disconnect(pa_context_get_instance());
3964
3965         /* Wait for the volume manager to be reinitialized */
3966
3967         /* Volume */
3968
3969         p.expected = MAFW_PROPERTY_RENDERER_VOLUME;
3970
3971         if (!wait_for_property(&p, wait_tout_val)) {
3972                 fail("No property %s received", p.expected);
3973         }
3974
3975         fail_if(p.received == NULL, "No property %s received",
3976                 p.expected);
3977         fail_if(p.received != NULL &&
3978                 g_value_get_uint(p.received) != 48,
3979                 "Property with value %d and %d expected",
3980                 g_value_get_uint(p.received), 48);
3981
3982         if (p.received != NULL) {
3983                 g_value_unset(p.received);
3984                 g_free(p.received);
3985                 p.received = NULL;
3986         }
3987         p.expected = NULL;
3988
3989         reset_callback_info(&c);
3990 #endif
3991 }
3992 END_TEST
3993
3994 START_TEST(test_buffering)
3995 {
3996         RendererInfo s;
3997         CallbackInfo c;
3998         BufferingInfo b;
3999         GstBus *bus = NULL;
4000         GstMessage *message = NULL;
4001
4002         /* Initialize callback info */
4003         c.err_msg = NULL;
4004         c.error_signal_expected = FALSE;
4005         c.error_signal_received = NULL;
4006         c.property_expected = NULL;
4007         c.property_received = NULL;
4008         b.requested = FALSE;
4009         b.received = FALSE;
4010         b.value = 0.0;
4011
4012         /* Connect to renderer signals */
4013         g_signal_connect(g_gst_renderer, "error",
4014                          G_CALLBACK(error_cb),
4015                          &c);
4016         g_signal_connect(g_gst_renderer, "state-changed",
4017                          G_CALLBACK(state_changed_cb),
4018                          &s);
4019         g_signal_connect(g_gst_renderer, "buffering-info",
4020                          G_CALLBACK(buffering_info_cb),
4021                          &b);
4022
4023         /* --- Get initial status --- */
4024
4025         reset_callback_info(&c);
4026
4027         g_debug("get status...");
4028         mafw_renderer_get_status(g_gst_renderer, status_cb, &s);
4029
4030         /* --- Play object --- */
4031
4032         reset_callback_info(&c);
4033
4034         gchar *objectid = get_sample_clip_objectid(SAMPLE_AUDIO_CLIP);
4035         g_debug("play_object... %s", objectid);
4036         mafw_renderer_play_object(g_gst_renderer, objectid, playback_cb, &c);
4037
4038         if (wait_for_callback(&c, wait_tout_val)) {
4039                 if (c.error)
4040                         fail(callback_err_msg, "playing an object", c.err_code,
4041                              c.err_msg);
4042         } else {
4043                 fail(no_callback_msg);
4044         }
4045
4046         if (wait_for_state(&s, Transitioning, wait_tout_val) == FALSE) {
4047                 fail(state_err_msg, "mafw_renderer_play_object",
4048                      "Transitioning", s.state);
4049         }
4050
4051         if (wait_for_state(&s, Playing, wait_tout_val) == FALSE) {
4052                 fail(state_err_msg, "mafw_renderer_play_object", "Playing",
4053                      s.state);
4054         }
4055
4056         g_free(objectid);
4057
4058         /* --- Buffering info --- */
4059
4060         b.requested = TRUE;
4061
4062         bus = MAFW_GST_RENDERER(g_gst_renderer)->worker->bus;
4063         fail_if(bus == NULL, "No GstBus");
4064
4065         message = gst_message_new_buffering(NULL, 50);
4066         gst_bus_post(bus, message);
4067
4068         if (wait_for_buffering(&b, wait_tout_val) == FALSE) {
4069                 fail("Expected buffering message but not received");
4070         }
4071
4072         fail_if(b.value != 0.5, "Expected buffering 0.50 and received %1.2f",
4073                 b.value);
4074
4075         b.requested = FALSE;
4076         b.received = FALSE;
4077         b.value = 0;
4078
4079         /* --- Buffering info --- */
4080
4081         b.requested = TRUE;
4082
4083         message = gst_message_new_buffering(NULL, 100);
4084         gst_bus_post(bus, message);
4085
4086         if (wait_for_buffering(&b, wait_tout_val) == FALSE) {
4087                 fail("Expected buffering message but not received");
4088         }
4089
4090         fail_if(b.value != 1.0, "Expected buffering 1.00 and received %1.2f",
4091                 b.value);
4092
4093         b.requested = FALSE;
4094         b.received = FALSE;
4095         b.value = 0;
4096
4097         /* --- Stop --- */
4098
4099         reset_callback_info(&c);
4100
4101         g_debug("stop...");
4102         mafw_renderer_stop(g_gst_renderer, playback_cb, &c);
4103
4104         if (wait_for_callback(&c, wait_tout_val)) {
4105                 if (c.error)
4106                         fail(callback_err_msg, "stopping", c.err_code,
4107                              c.err_msg);
4108         } else {
4109                 fail(no_callback_msg);
4110         }
4111
4112         if (wait_for_state(&s, Stopped, wait_tout_val) == FALSE) {
4113                 fail(state_err_msg,"mafw_renderer_stop", "Stopped", s.state);
4114         }
4115 }
4116 END_TEST
4117
4118 /*----------------------------------------------------------------------------
4119   Suit creation
4120   ----------------------------------------------------------------------------*/
4121
4122 SRunner * configure_tests(void)
4123 {
4124         SRunner *sr = NULL;
4125         Suite *s = NULL;
4126         const gchar *tout = g_getenv("WAIT_TIMEOUT");
4127
4128         if (!tout)
4129                 wait_tout_val = DEFAULT_WAIT_TOUT;
4130         else
4131         {
4132                 wait_tout_val = (gint)strtol(tout, NULL, 0);
4133                 if (wait_tout_val<=0)
4134                         wait_tout_val = DEFAULT_WAIT_TOUT;
4135         }
4136
4137         checkmore_wants_dbus();
4138         mafw_log_init(":error");
4139         /* Create the suite */
4140         s = suite_create("MafwGstRenderer");
4141
4142         /* Create test cases */
4143         TCase *tc1 = tcase_create("Playback");
4144
4145         /* Create unit tests for test case "Playback" */
4146         tcase_add_checked_fixture(tc1, fx_setup_dummy_gst_renderer,
4147                                   fx_teardown_dummy_gst_renderer);
4148 if (1)  tcase_add_test(tc1, test_basic_playback);
4149 if (1)  tcase_add_test(tc1, test_playlist_playback);
4150 if (1)  tcase_add_test(tc1, test_repeat_mode_playback);
4151 if (1)  tcase_add_test(tc1, test_gst_renderer_mode);
4152 if (1)  tcase_add_test(tc1, test_update_stats);
4153 if (1)  tcase_add_test(tc1, test_play_state);
4154 if (1)  tcase_add_test(tc1, test_pause_state);
4155 if (1)  tcase_add_test(tc1, test_stop_state);
4156 if (1)  tcase_add_test(tc1, test_transitioning_state);
4157 if (1)  tcase_add_test(tc1, test_state_class);
4158 if (1)  tcase_add_test(tc1, test_playlist_iterator);
4159 if (1)  tcase_add_test(tc1, test_video);
4160 if (1)  tcase_add_test(tc1, test_media_art);
4161 if (1)  tcase_add_test(tc1, test_properties_management);
4162 if (1)  tcase_add_test(tc1, test_buffering);
4163
4164         tcase_set_timeout(tc1, 0);
4165
4166         suite_add_tcase(s, tc1);
4167
4168         /* Create srunner object with the test suite */
4169         sr = srunner_create(s);
4170
4171         return sr;
4172 }
4173
4174 /* vi: set noexpandtab ts=8 sw=8 cino=t0,(0: */