00001
00025 #include "rtcom-eventlogger/eventlogger.h"
00026
00027 #include <glib.h>
00028 #include <glib/gstdio.h>
00029
00030 #include <check.h>
00031
00032 #include <sqlite3.h>
00033
00034 #include <stdlib.h>
00035 #include <string.h>
00036 #include <sys/types.h>
00037 #include <sys/stat.h>
00038 #include <fcntl.h>
00039 #include <unistd.h>
00040
00041 #include "canned-data.h"
00042 #include "fail.h"
00043
00044 #define SERVICE "RTCOM_EL_SERVICE_TEST"
00045 #define EVENT_TYPE "RTCOM_EL_EVENTTYPE_TEST_ET1"
00046 #define FLAGS 0
00047 #define BYTES_SENT 10
00048 #define BYTES_RECEIVED 9
00049 #define REMOTE_EBOOK_UID "ebook-uid-1"
00050 #define LOCAL_UID "ext-salvatore.iovene@nokia.com"
00051 #define LOCAL_NAME "Salvatore Iovene"
00052
00053
00054 #define REMOTE_UID "1@foo.org"
00055 #define REMOTE_NAME "1,2"
00056
00057 #define CHANNEL "chavo"
00058 #define FREE_TEXT "Test free_text"
00059
00060 #define HEADER_KEY "Foo"
00061 #define HEADER_VAL "Bar"
00062
00063 #define ATTACH_DESC "Foo attachment."
00064
00065 #define REMOTE_EBOOK_UID_2 "ebook-uid-2"
00066 #define REMOTE_UID_2 "ext-salvatore.iovene-2@nokia.com"
00067 #define REMOTE_NAME_2 "Salvatore Iovene 2"
00068
00069 #define REMOTE_EBOOK_UID_3 "ebook-uid-3"
00070 #define REMOTE_UID_3 "ext-salvatore.iovene-3@nokia.com"
00071 #define REMOTE_NAME_3 "Salvatore Iovene 3"
00072
00073 #define DROP_CORE_TABLES \
00074 "DROP TABLE Attachments;\n" \
00075 "DROP TABLE Events;\n" \
00076 "DROP TABLE EventTypes;\n" \
00077 "DROP TABLE Flags;\n" \
00078 "DROP TABLE GroupCache;\n" \
00079 "DROP TABLE Headers;\n" \
00080 "DROP TABLE Plugins;\n" \
00081 "DROP TABLE Remotes;\n" \
00082 "DROP TABLE Services;\n" \
00083
00084 static RTComEl *el = NULL;
00085
00086 static void
00087 el_exec (const gchar *sql)
00088 {
00089 sqlite3 *db;
00090
00091 g_assert (el != NULL);
00092
00093 g_object_get (el,
00094 "db", &db,
00095 NULL);
00096
00097 fail_unless (sqlite3_exec (db, sql, NULL, NULL, NULL)
00098 == SQLITE_OK);
00099 }
00100
00101
00102 static RTComElEvent *
00103 event_new_lite (void)
00104 {
00105 RTComElEvent *ev;
00106
00107 ev = rtcom_el_event_new();
00108 g_return_val_if_fail (ev != NULL, NULL);
00109
00110 RTCOM_EL_EVENT_SET_FIELD(ev, service, g_strdup (SERVICE));
00111 RTCOM_EL_EVENT_SET_FIELD(ev, event_type, g_strdup (EVENT_TYPE));
00112 RTCOM_EL_EVENT_SET_FIELD(ev, local_uid, g_strdup (LOCAL_UID));
00113 RTCOM_EL_EVENT_SET_FIELD(ev, start_time, time(NULL));
00114
00115 return ev;
00116 }
00117
00118 static RTComElEvent *
00119 event_new_full (time_t t)
00120 {
00121 RTComElEvent *ev;
00122
00123 ev = rtcom_el_event_new();
00124 g_return_val_if_fail (ev != NULL, NULL);
00125
00126
00127
00128
00129
00130
00131
00132 RTCOM_EL_EVENT_SET_FIELD(ev, service, g_strdup (SERVICE));
00133 RTCOM_EL_EVENT_SET_FIELD(ev, event_type, g_strdup (EVENT_TYPE));
00134 RTCOM_EL_EVENT_SET_FIELD(ev, start_time, t);
00135 RTCOM_EL_EVENT_SET_FIELD(ev, end_time, t);
00136 RTCOM_EL_EVENT_SET_FIELD(ev, flags, FLAGS);
00137 RTCOM_EL_EVENT_SET_FIELD(ev, bytes_sent, BYTES_SENT);
00138 RTCOM_EL_EVENT_SET_FIELD(ev, bytes_received, BYTES_RECEIVED);
00139 RTCOM_EL_EVENT_SET_FIELD(ev, local_uid, g_strdup (LOCAL_UID));
00140 RTCOM_EL_EVENT_SET_FIELD(ev, local_name, g_strdup (LOCAL_NAME));
00141 RTCOM_EL_EVENT_SET_FIELD(ev, remote_uid, g_strdup (REMOTE_UID));
00142 RTCOM_EL_EVENT_SET_FIELD(ev, remote_name, g_strdup (REMOTE_NAME));
00143 RTCOM_EL_EVENT_SET_FIELD(ev, channel, g_strdup (CHANNEL));
00144 RTCOM_EL_EVENT_SET_FIELD(ev, free_text, g_strdup (FREE_TEXT));
00145
00146 return ev;
00147 }
00148
00149 static void
00150 core_setup (void)
00151 {
00152 g_type_init ();
00153
00154
00155 el = rtcom_el_new ();
00156 g_assert (el != NULL);
00157 el_exec (DROP_CORE_TABLES);
00158 g_object_unref (el);
00159
00160
00161 el = rtcom_el_new ();
00162 g_assert (el != NULL);
00163
00164
00165
00166 add_canned_events (el);
00167 }
00168
00169 static void
00170 core_teardown (void)
00171 {
00172
00173 g_assert (el != NULL);
00174 g_object_unref (el);
00175 el = NULL;
00176 }
00177
00178 static gint
00179 iter_count_results (RTComElIter *it)
00180 {
00181 gint i = 1;
00182
00183 if (it == NULL)
00184 {
00185 return 0;
00186 }
00187
00188 if (!rtcom_el_iter_first (it))
00189 {
00190 return 0;
00191 }
00192
00193 while (rtcom_el_iter_next (it))
00194 {
00195 i += 1;
00196 }
00197
00198 return i;
00199 }
00200
00201 START_TEST(test_add_event)
00202 {
00203 RTComElQuery * query = NULL;
00204 RTComElEvent * ev = NULL;
00205 gint event_id = -1;
00206 RTComElIter * it = NULL;
00207 GValueArray * values = NULL;
00208 time_t t = 0;
00209
00210 t = time (NULL);
00211
00212 ev = event_new_full (t);
00213 if(!ev)
00214 {
00215 fail("Failed to create event.");
00216 }
00217
00218 event_id = rtcom_el_add_event(el, ev, NULL);
00219 fail_if (event_id < 0, "Failed to add event");
00220
00221 query = rtcom_el_query_new(el);
00222
00223
00224 {
00225 RTComEl *q_el = NULL;
00226 gboolean q_is_caching = 0xDEADBEEF;
00227 gint q_limit = -42;
00228 gint q_offset = -42;
00229 gint q_group_by = -42;
00230
00231 g_object_get (query,
00232 "el", &q_el,
00233 "is-caching", &q_is_caching,
00234 "limit", &q_limit,
00235 "offset", &q_offset,
00236 "group-by", &q_group_by,
00237 NULL);
00238
00239 fail_unless (q_el == el);
00240 fail_unless (q_is_caching == FALSE);
00241 fail_unless (q_limit == -1);
00242 fail_unless (q_offset == 0);
00243 fail_unless (q_group_by == RTCOM_EL_QUERY_GROUP_BY_NONE);
00244 }
00245
00246 if(!rtcom_el_query_prepare(
00247 query,
00248 "id", event_id, RTCOM_EL_OP_EQUAL,
00249 NULL))
00250 {
00251 fail("Failed to prepare the query.");
00252 }
00253
00254 it = rtcom_el_get_events(el, query);
00255 g_object_unref(query);
00256
00257 fail_unless(it != NULL, "Failed to get iterator");
00258
00259 rtcom_fail_unless_strcmp(rtcom_el_iter_get_service(it), ==,
00260 SERVICE);
00261 rtcom_fail_unless_strcmp(rtcom_el_iter_get_event_type(it), ==,
00262 EVENT_TYPE);
00263
00264
00265 {
00266 gpointer el_db = NULL;
00267 RTComEl *it_el = NULL;
00268 gpointer it_query = NULL;
00269 gpointer it_db = NULL;
00270 gpointer it_stmt = NULL;
00271 gchar *it_sql = NULL;
00272 GHashTable *it_plugins = NULL;
00273 gboolean it_atomic = 0xDEADBEEF;
00274
00275 g_object_get (el,
00276 "db", &el_db,
00277 NULL);
00278
00279 g_object_get (it,
00280 "el", &it_el,
00281 "query", &it_query,
00282 "sqlite3-database", &it_db,
00283 "sqlite3-statement", &it_stmt,
00284 "sql", &it_sql,
00285 "plugins-table", &it_plugins,
00286 "atomic", &it_atomic,
00287 NULL);
00288
00289 fail_unless (it_el == el);
00290 fail_unless (it_query != NULL);
00291 fail_unless (it_db != NULL);
00292 fail_unless (it_db == el_db);
00293 fail_unless (it_stmt != NULL);
00294 fail_unless (it_sql != NULL);
00295 fail_unless (it_plugins != NULL);
00296 fail_unless (it_atomic == TRUE || it_atomic == FALSE);
00297
00298 g_free (it_sql);
00299 }
00300
00301 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
00302
00303 values = rtcom_el_iter_get_valuearray(
00304 it,
00305 "start-time",
00306 "end-time",
00307 "flags",
00308 "bytes-sent",
00309 "bytes-received",
00310 "local-uid",
00311 "local-name",
00312 "remote-uid",
00313 "remote-name",
00314 "channel",
00315 "free-text",
00316 NULL);
00317
00318 if(!values)
00319 {
00320 fail("Failed to get values.");
00321 }
00322
00323 rtcom_fail_unless_intcmp(t, ==,
00324 g_value_get_int(g_value_array_get_nth(values, 0)));
00325 rtcom_fail_unless_intcmp(t, ==,
00326 g_value_get_int(g_value_array_get_nth(values, 1)));
00327
00328 rtcom_fail_unless_intcmp(FLAGS, ==,
00329 g_value_get_int(g_value_array_get_nth(values, 2)));
00330
00331 rtcom_fail_unless_intcmp(BYTES_SENT, ==,
00332 g_value_get_int(g_value_array_get_nth(values, 3)));
00333 rtcom_fail_unless_intcmp(BYTES_RECEIVED, ==,
00334 g_value_get_int(g_value_array_get_nth(values, 4)));
00335 rtcom_fail_unless_strcmp(LOCAL_UID, ==,
00336 g_value_get_string(g_value_array_get_nth(values, 5)));
00337 rtcom_fail_unless_strcmp(LOCAL_NAME, ==,
00338 g_value_get_string(g_value_array_get_nth(values, 6)));
00339 rtcom_fail_unless_strcmp(REMOTE_UID, ==,
00340 g_value_get_string(g_value_array_get_nth(values, 7)));
00341 rtcom_fail_unless_strcmp(REMOTE_NAME, ==,
00342 g_value_get_string(g_value_array_get_nth(values, 8)));
00343 rtcom_fail_unless_strcmp(CHANNEL, ==,
00344 g_value_get_string(g_value_array_get_nth(values, 9)));
00345 rtcom_fail_unless_strcmp(FREE_TEXT, ==,
00346 g_value_get_string(g_value_array_get_nth(values, 10)));
00347
00348 fail_if(rtcom_el_iter_next(it), "Iterator should only return one row");
00349
00350 fail_unless(rtcom_el_iter_refresh(it),
00351 "Refreshing should work and return one row");
00352 fail_if(rtcom_el_iter_next(it), "Iterator should only return one row");
00353
00354 g_value_array_free(values);
00355 g_object_unref(it);
00356 rtcom_el_event_free_contents (ev);
00357 rtcom_el_event_free (ev);
00358 }
00359 END_TEST
00360
00361 START_TEST(test_add_full)
00362 {
00363 const time_t time = 1000000;
00364 RTComElEvent *ev;
00365 RTComElQuery *query;
00366 RTComElIter *it;
00367 RTComElAttachIter *att_it;
00368 RTComElAttachment *att;
00369 GValueArray *values;
00370 GHashTable *headers;
00371 GList *attachments = NULL;
00372 gint fd;
00373 gint event_id;
00374 gchar *path1;
00375 gchar *path2;
00376 gchar *contents;
00377 gsize length;
00378
00379 headers = g_hash_table_new_full (g_str_hash, g_str_equal,
00380 g_free, g_free);
00381 g_hash_table_insert (headers, g_strdup (HEADER_KEY),
00382 g_strdup ("add_full"));
00383
00384 fd = g_file_open_tmp ("attachment1.XXXXXX", &path1, NULL);
00385 fail_unless (fd >= 0);
00386 fail_unless (path1 != NULL);
00387 close (fd);
00388 fail_unless (g_file_set_contents (path1, "some text\n", -1, NULL));
00389
00390 fd = g_file_open_tmp ("attachment2.XXXXXX", &path2, NULL);
00391 fail_unless (fd >= 0);
00392 fail_unless (path2 != NULL);
00393 close (fd);
00394 fail_unless (g_file_set_contents (path2, "other text\n", -1, NULL));
00395
00396 attachments = g_list_prepend (attachments,
00397 rtcom_el_attachment_new (path1, "some file"));
00398 attachments = g_list_prepend (attachments,
00399 rtcom_el_attachment_new (path2, NULL));
00400
00401 ev = event_new_full (time);
00402 fail_unless (ev != NULL, "Failed to create event.");
00403
00404 event_id = rtcom_el_add_event_full (el, ev,
00405 headers, attachments, NULL);
00406
00407 fail_if (event_id < 0, "Failed to add event");
00408
00409 g_unlink (path1);
00410 g_unlink (path2);
00411 g_hash_table_destroy (headers);
00412 headers = NULL;
00413 g_list_foreach (attachments, (GFunc) rtcom_el_free_attachment, NULL);
00414 g_list_free (attachments);
00415 attachments = NULL;
00416
00417
00418
00419 query = rtcom_el_query_new(el);
00420 fail_unless (rtcom_el_query_prepare (query,
00421 "id", event_id, RTCOM_EL_OP_EQUAL,
00422 NULL));
00423
00424 it = rtcom_el_get_events(el, query);
00425 g_object_unref(query);
00426
00427 fail_unless (it != NULL, "Failed to get iterator");
00428 fail_unless (rtcom_el_iter_first(it), "Failed to start iterator");
00429
00430 values = rtcom_el_iter_get_valuearray(it, HEADER_KEY, NULL);
00431 rtcom_fail_unless_strcmp ("add_full", ==,
00432 g_value_get_string (g_value_array_get_nth (values, 0)));
00433 g_value_array_free(values);
00434
00435 att_it = rtcom_el_iter_get_attachments(it);
00436 fail_unless (att_it != NULL, "Failed to get attachment iterator");
00437
00438 g_object_unref (it);
00439
00440 fail_unless (rtcom_el_attach_iter_first(att_it),
00441 "Failed to start attachment iterator");
00442
00443 att = rtcom_el_attach_iter_get (att_it);
00444 fail_if (att == NULL, "failed to get attachment data");
00445
00446 fail_unless (event_id == att->event_id,
00447 "attachment event ID doesn't match");
00448 rtcom_fail_unless_strcmp (g_basename (path2), ==,
00449 g_basename (att->path));
00450 rtcom_fail_unless_strcmp (NULL, ==, att->desc);
00451 fail_unless (g_file_get_contents (att->path, &contents, &length, NULL));
00452 rtcom_fail_unless_uintcmp (length, ==, strlen ("other text\n"));
00453 rtcom_fail_unless_strcmp (contents, ==, "other text\n");
00454 g_free (contents);
00455 rtcom_el_free_attachment (att);
00456
00457 fail_unless (rtcom_el_attach_iter_next (att_it),
00458 "Failed to advance attachment iterator");
00459
00460 att = rtcom_el_attach_iter_get (att_it);
00461 fail_if (att == NULL, "failed to get attachment data");
00462
00463 fail_unless (event_id == att->event_id,
00464 "attachment event ID doesn't match");
00465 rtcom_fail_unless_strcmp (g_basename (path1), ==,
00466 g_basename (att->path));
00467 rtcom_fail_unless_strcmp ("some file", ==, att->desc);
00468 fail_unless (g_file_get_contents (att->path, &contents, &length, NULL));
00469 rtcom_fail_unless_uintcmp (length, ==, strlen ("some text\n"));
00470 rtcom_fail_unless_strcmp (contents, ==, "some text\n");
00471 g_free (contents);
00472 rtcom_el_free_attachment (att);
00473
00474 fail_if (rtcom_el_attach_iter_next (att_it));
00475
00476 g_object_unref (att_it);
00477
00478 g_free (path1);
00479 g_free (path2);
00480
00481 rtcom_el_event_free_contents (ev);
00482 rtcom_el_event_free (ev);
00483 }
00484 END_TEST
00485
00486 START_TEST(test_header)
00487 {
00488 RTComElQuery * query = NULL;
00489 RTComElEvent * ev = NULL;
00490 gint event_id = -1;
00491 gint header_id = -1;
00492 RTComElIter * it = NULL;
00493 GValueArray * values = NULL;
00494 GHashTable *headers;
00495
00496 ev = event_new_lite ();
00497 if(!ev)
00498 {
00499 fail("Failed to create event.");
00500 }
00501
00502 event_id = rtcom_el_add_event(el, ev, NULL);
00503 fail_if (event_id < 0, "Failed to add event");
00504
00505 header_id = rtcom_el_add_header(
00506 el, event_id,
00507 HEADER_KEY,
00508 HEADER_VAL,
00509 NULL);
00510 fail_if (header_id < 0, "Failed to add header");
00511
00512 query = rtcom_el_query_new(el);
00513 if(!rtcom_el_query_prepare(
00514 query,
00515 "id", event_id, RTCOM_EL_OP_EQUAL,
00516 NULL))
00517 {
00518 fail("Failed to prepare the query.");
00519 }
00520
00521 it = rtcom_el_get_events(el, query);
00522 g_object_unref(query);
00523
00524 fail_unless(it != NULL, "Failed to get iterator");
00525 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
00526
00527 values = rtcom_el_iter_get_valuearray(it, HEADER_KEY, NULL);
00528 fail_if (values == NULL, "Failed to get values");
00529
00530 rtcom_fail_unless_strcmp(HEADER_VAL, ==,
00531 g_value_get_string(g_value_array_get_nth(values, 0)));
00532
00533 fail_unless(rtcom_el_iter_refresh(it),
00534 "Refreshing should work and return one row");
00535 fail_if(rtcom_el_iter_next(it), "Iterator should only return one row");
00536
00537 g_value_array_free(values);
00538 g_object_unref(it);
00539 rtcom_el_event_free_contents (ev);
00540 rtcom_el_event_free (ev);
00541
00542 headers = rtcom_el_fetch_event_headers (el, event_id);
00543
00544 fail_unless (headers != NULL);
00545 rtcom_fail_unless_intcmp (g_hash_table_size (headers), ==, 1);
00546 rtcom_fail_unless_strcmp (g_hash_table_lookup (headers, HEADER_KEY),
00547 ==, HEADER_VAL);
00548
00549 g_hash_table_destroy (headers);
00550 }
00551 END_TEST
00552
00553 START_TEST(test_attach)
00554 {
00555 RTComElQuery * query = NULL;
00556 RTComElEvent * ev = NULL;
00557 gint event_id = -1;
00558 gint attachment_id = -1;
00559 RTComElIter * it = NULL;
00560 RTComElAttachIter * att_it = NULL;
00561 RTComElAttachment *att = NULL;
00562 gchar *contents;
00563 gsize length;
00564 GError *error = NULL;
00565 gchar *attach_path;
00566 gint fd;
00567
00568 ev = event_new_lite ();
00569 fail_if (ev == NULL, "Failed to create event");
00570
00571 event_id = rtcom_el_add_event(el, ev, NULL);
00572 fail_if (event_id < 0, "Failed to add event");
00573
00574 attachment_id = rtcom_el_add_attachment(
00575 el, event_id,
00576 "/nonexistent", ATTACH_DESC,
00577 &error);
00578 fail_if (attachment_id != -1, "Should have failed to add nonexistent "
00579 "attachment");
00580 rtcom_fail_unless_uintcmp (error->domain, ==, RTCOM_EL_ERROR);
00581 rtcom_fail_unless_intcmp (error->code, ==, RTCOM_EL_INTERNAL_ERROR);
00582 g_clear_error (&error);
00583
00584 query = rtcom_el_query_new(el);
00585 if(!rtcom_el_query_prepare(
00586 query,
00587 "id", event_id, RTCOM_EL_OP_EQUAL,
00588 NULL))
00589 {
00590 fail("Failed to prepare the query.");
00591 }
00592
00593 it = rtcom_el_get_events(el, query);
00594 g_object_unref(query);
00595
00596 att_it = rtcom_el_iter_get_attachments(it);
00597 fail_unless (att_it == NULL, "Should start with no attachments");
00598
00599 g_object_unref(it);
00600
00601 fd = g_file_open_tmp ("attachment.XXXXXX", &attach_path, NULL);
00602 fail_unless (fd >= 0);
00603 fail_unless (attach_path != NULL);
00604 close (fd);
00605 fail_unless (g_file_set_contents (attach_path, "lalala", 6, NULL));
00606
00607 attachment_id = rtcom_el_add_attachment(
00608 el, event_id,
00609 attach_path, ATTACH_DESC,
00610 NULL);
00611 fail_if (attachment_id < 0, "Failed to add attachment");
00612
00613 g_unlink (attach_path);
00614
00615 query = rtcom_el_query_new(el);
00616 if(!rtcom_el_query_prepare(
00617 query,
00618 "id", event_id, RTCOM_EL_OP_EQUAL,
00619 NULL))
00620 {
00621 fail("Failed to prepare the query.");
00622 }
00623
00624 it = rtcom_el_get_events(el, query);
00625 g_object_unref(query);
00626
00627 fail_unless (it != NULL, "Failed to get iterator");
00628 fail_unless (rtcom_el_iter_first(it), "Failed to start iterator");
00629
00630 att_it = rtcom_el_iter_get_attachments(it);
00631 fail_unless (att_it != NULL, "Failed to get attachment iterator");
00632
00633
00634 {
00635 gpointer el_db;
00636 gpointer ai_db;
00637 gpointer ai_stmt;
00638
00639 g_object_get (el,
00640 "db", &el_db,
00641 NULL);
00642
00643 g_object_get (att_it,
00644 "sqlite3-database", &ai_db,
00645 "sqlite3-statement", &ai_stmt,
00646 NULL);
00647
00648 fail_unless (ai_db != NULL);
00649 fail_unless (ai_db == el_db);
00650 fail_unless (ai_stmt != NULL);
00651 }
00652
00653 fail_unless (rtcom_el_attach_iter_first(att_it),
00654 "Failed to start attachment iterator");
00655
00656 att = rtcom_el_attach_iter_get (att_it);
00657 fail_if (att == NULL, "failed to get attachment data");
00658
00659 fail_unless (event_id == att->event_id,
00660 "attachment event ID doesn't match");
00661 rtcom_fail_unless_strcmp(g_basename(attach_path), ==,
00662 g_basename(att->path));
00663 rtcom_fail_unless_strcmp(ATTACH_DESC, ==, att->desc);
00664 fail_unless (g_file_get_contents (att->path, &contents, &length, NULL));
00665 rtcom_fail_unless_uintcmp (length, ==, 6);
00666 rtcom_fail_unless_strcmp (contents, ==, "lalala");
00667 g_free (contents);
00668
00669 fail_if (rtcom_el_attach_iter_next (att_it));
00670
00671 g_free (attach_path);
00672 rtcom_el_free_attachment (att);
00673 g_object_unref(att_it);
00674 g_object_unref(it);
00675 rtcom_el_event_free_contents (ev);
00676 rtcom_el_event_free (ev);
00677 }
00678 END_TEST
00679
00680 START_TEST(test_read)
00681 {
00682 RTComElQuery * query = NULL;
00683 RTComElEvent * ev = NULL;
00684 gint event_id = -1;
00685 RTComElIter * it = NULL;
00686 GValueArray * values = NULL;
00687 gint i;
00688 gint count;
00689 gint ids[4] = { 0, 0, 0, 0 };
00690
00691 ev = event_new_full (time (NULL));
00692 if(!ev)
00693 {
00694 fail("Failed to create event.");
00695 }
00696
00697 event_id = rtcom_el_add_event(el, ev, NULL);
00698 fail_if (event_id < 0, "Failed to add event");
00699
00700
00701
00702 rtcom_el_set_read_event(el, event_id, TRUE, NULL);
00703
00704 query = rtcom_el_query_new(el);
00705 rtcom_el_query_set_limit(query, 5);
00706 if(!rtcom_el_query_prepare(
00707 query,
00708 "is-read", TRUE, RTCOM_EL_OP_EQUAL,
00709 NULL))
00710 {
00711 fail("Failed to prepare the query.");
00712 }
00713
00714 it = rtcom_el_get_events(el, query);
00715 g_object_unref(query);
00716
00717 fail_unless(it != NULL, "Failed to get iterator");
00718 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
00719
00720 values = rtcom_el_iter_get_valuearray(
00721 it,
00722 "is-read",
00723 NULL);
00724
00725 fail_if (values == NULL, "Failed to get values");
00726
00727 fail_unless (g_value_get_boolean(g_value_array_get_nth(values, 0)) == TRUE,
00728 "is-read flag doesn't match");
00729
00730
00731 count = iter_count_results (it);
00732 rtcom_fail_unless_intcmp (count, ==, 1);
00733
00734 g_object_unref(it);
00735
00736
00737
00738 query = rtcom_el_query_new (el);
00739 rtcom_el_query_set_limit (query, 3);
00740 fail_unless (rtcom_el_query_prepare(query,
00741 NULL));
00742 it = rtcom_el_get_events(el, query);
00743 g_object_unref (query);
00744
00745 fail_unless (it != NULL);
00746 fail_unless (rtcom_el_iter_first (it));
00747 i = 0;
00748
00749 for (i = 0; i < 3; i++)
00750 {
00751 if (i > 0)
00752 {
00753 fail_unless (rtcom_el_iter_next (it));
00754 }
00755
00756 fail_unless (rtcom_el_iter_get_int (it, "id", ids + i));
00757 }
00758
00759 fail_if (rtcom_el_iter_next (it), "Iterator should run out after 3");
00760
00761 rtcom_fail_unless_intcmp (ids[0], ==, event_id);
00762
00763 g_object_unref(it);
00764
00765 rtcom_fail_unless_intcmp (rtcom_el_set_read_events (el, ids, TRUE, NULL),
00766 ==, 0);
00767
00768 query = rtcom_el_query_new (el);
00769 fail_unless (rtcom_el_query_prepare(query,
00770 "is-read", TRUE, RTCOM_EL_OP_EQUAL,
00771 NULL));
00772 it = rtcom_el_get_events(el, query);
00773 g_object_unref (query);
00774 count = iter_count_results (it);
00775
00776 rtcom_fail_unless_intcmp (count, ==, 3);
00777 g_object_unref(it);
00778
00779 rtcom_fail_unless_intcmp (rtcom_el_set_read_events (el, ids, FALSE, NULL),
00780 ==, 0);
00781
00782 query = rtcom_el_query_new (el);
00783 fail_unless (rtcom_el_query_prepare(query,
00784 "is-read", TRUE, RTCOM_EL_OP_EQUAL,
00785 NULL));
00786 it = rtcom_el_get_events(el, query);
00787 g_object_unref (query);
00788 fail_unless (it == NULL, "all read flags should have been unset");
00789
00790 g_value_array_free(values);
00791 rtcom_el_event_free_contents (ev);
00792 rtcom_el_event_free (ev);
00793 }
00794 END_TEST
00795
00796 START_TEST(test_flags)
00797 {
00798 RTComElQuery * query = NULL;
00799 RTComElEvent * ev = NULL;
00800 gint event_id = -1;
00801 RTComElIter * it = NULL;
00802 GValueArray * values = NULL;
00803 gint test_flag1 = 0;
00804 gint flags = 0;
00805
00806 ev = event_new_full (time (NULL));
00807 if(!ev)
00808 {
00809 fail("Failed to create event.");
00810 }
00811
00812 event_id = rtcom_el_add_event(el, ev, NULL);
00813 fail_if (event_id < 0, "Failed to add event");
00814
00815 rtcom_el_set_event_flag(el, event_id, "RTCOM_EL_FLAG_TEST_FLAG1", NULL);
00816
00817 query = rtcom_el_query_new(el);
00818 rtcom_el_query_set_limit(query, 5);
00819 if(!rtcom_el_query_prepare(
00820 query,
00821 "id", event_id, RTCOM_EL_OP_EQUAL,
00822 NULL))
00823 {
00824 fail("Failed to prepare the query.");
00825 }
00826
00827 it = rtcom_el_get_events(el, query);
00828 g_object_unref(query);
00829
00830 fail_unless(it != NULL, "Failed to get iterator");
00831 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
00832
00833 values = rtcom_el_iter_get_valuearray(
00834 it,
00835 "flags",
00836 NULL);
00837
00838 fail_if (values == NULL, "Failed to get values");
00839
00840 test_flag1 = rtcom_el_get_flag_value(el, "RTCOM_EL_FLAG_TEST_FLAG1");
00841 flags = g_value_get_int(g_value_array_get_nth(values, 0));
00842
00843 fail_if ((flags & test_flag1) == 0, "flags don't match");
00844
00845 g_value_array_free(values);
00846 g_object_unref(it);
00847 rtcom_el_event_free_contents (ev);
00848 rtcom_el_event_free (ev);
00849 }
00850 END_TEST
00851
00852
00853 START_TEST(test_get)
00854 {
00855 RTComElQuery * query = NULL;
00856 RTComElEvent * ev = NULL;
00857 RTComElEvent *result = NULL;
00858 gint event_id = -1;
00859 RTComElIter * it = NULL;
00860
00861 ev = event_new_full (time (NULL));
00862 if(!ev)
00863 {
00864 fail("Failed to create event.");
00865 }
00866
00867 event_id = rtcom_el_add_event(el, ev, NULL);
00868 fail_if (event_id < 0, "Fail to add event");
00869
00870 query = rtcom_el_query_new(el);
00871 if(!rtcom_el_query_prepare(
00872 query,
00873 "id", event_id, RTCOM_EL_OP_EQUAL,
00874 NULL))
00875 {
00876 fail("Failed to prepare the query.");
00877 }
00878
00879 it = rtcom_el_get_events(el, query);
00880 g_object_unref(query);
00881
00882 fail_unless(it != NULL, "Failed to get iterator");
00883 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
00884
00885 result = rtcom_el_event_new ();
00886 fail_unless (result != NULL, "failed to create result event");
00887
00888 fail_unless (rtcom_el_iter_get (it, result),
00889 "Failed to get event from iterator");
00890
00891 fail_unless (rtcom_el_event_equals (ev, result),
00892 "Retrieved event doesn't match created one");
00893
00894 g_object_unref(it);
00895 rtcom_el_event_free_contents (result);
00896 rtcom_el_event_free (result);
00897 rtcom_el_event_free_contents (ev);
00898 rtcom_el_event_free (ev);
00899 }
00900 END_TEST
00901
00902 START_TEST(test_unique_remotes)
00903 {
00904 RTComElEvent * ev = NULL;
00905 gint event_id = -1;
00906 GList * remote_ebook_uids = NULL;
00907 GList * remote_uids = NULL;
00908 GList * remote_names = NULL;
00909 GList *iter = NULL;
00910
00911 ev = event_new_full (time (NULL));
00912 if(!ev)
00913 {
00914 fail("Failed to create event.");
00915 }
00916
00917 RTCOM_EL_EVENT_SET_FIELD(ev, remote_ebook_uid, g_strdup (REMOTE_EBOOK_UID));
00918
00919 event_id = rtcom_el_add_event(el, ev, NULL);
00920 fail_if (event_id < 0, "Fail to add event");
00921
00922
00923 g_free (RTCOM_EL_EVENT_GET_FIELD(ev, remote_ebook_uid));
00924 g_free (RTCOM_EL_EVENT_GET_FIELD(ev, remote_uid));
00925 g_free (RTCOM_EL_EVENT_GET_FIELD(ev, remote_name));
00926 RTCOM_EL_EVENT_SET_FIELD(ev, remote_ebook_uid, g_strdup (REMOTE_EBOOK_UID_2));
00927 RTCOM_EL_EVENT_SET_FIELD(ev, remote_uid, g_strdup (REMOTE_UID_2));
00928 RTCOM_EL_EVENT_SET_FIELD(ev, remote_name, g_strdup (REMOTE_NAME_2));
00929
00930
00931
00932
00933 g_free(RTCOM_EL_EVENT_GET_FIELD(ev, group_uid));
00934 RTCOM_EL_EVENT_UNSET_FIELD(ev, group_uid);
00935
00936 event_id = rtcom_el_add_event(el, ev, NULL);
00937 fail_if (event_id < 0, "Fail to add event");
00938
00939 g_free (RTCOM_EL_EVENT_GET_FIELD(ev, remote_ebook_uid));
00940 g_free (RTCOM_EL_EVENT_GET_FIELD(ev, remote_uid));
00941 g_free (RTCOM_EL_EVENT_GET_FIELD(ev, remote_name));
00942 RTCOM_EL_EVENT_SET_FIELD(ev, remote_ebook_uid, g_strdup (REMOTE_EBOOK_UID_3));
00943 RTCOM_EL_EVENT_SET_FIELD(ev, remote_uid, g_strdup (REMOTE_UID_3));
00944 RTCOM_EL_EVENT_SET_FIELD(ev, remote_name, g_strdup (REMOTE_NAME_3));
00945
00946
00947
00948 g_free(RTCOM_EL_EVENT_GET_FIELD(ev, group_uid));
00949 RTCOM_EL_EVENT_UNSET_FIELD(ev, group_uid);
00950
00951 event_id = rtcom_el_add_event(el, ev, NULL);
00952 fail_if (event_id < 0, "Fail to add event");
00953
00954 remote_ebook_uids = rtcom_el_get_unique_remote_ebook_uids(el);
00955 fail_if (remote_ebook_uids == NULL, "Fail to get unique remote_ebook_uids");
00956
00957 fail_if (g_list_length(remote_ebook_uids) < 2,
00958 "remote_ebook_uids's length doesn't match");
00959
00960 for (iter = remote_ebook_uids; iter != NULL; iter = iter->next)
00961 g_debug("Unique remote_ebook_uid: %s", (const guchar *) iter->data);
00962
00963 remote_uids = rtcom_el_get_unique_remote_uids(el);
00964 fail_if (remote_uids == NULL, "Fail to get unique remote_uids");
00965
00966 fail_if (g_list_length(remote_uids) < 2, "remote_uids's length doesn't match");
00967
00968 for (iter = remote_uids; iter != NULL; iter = iter->next)
00969 g_debug("Unique remote_uid: %s", (const guchar *) iter->data);
00970
00971 remote_names = rtcom_el_get_unique_remote_names(el);
00972 fail_if (remote_names == NULL, "Fail to get unique remote_names");
00973
00974 fail_if (g_list_length(remote_names) < 2,
00975 "remote_names's length doesn't match");
00976
00977 for (iter = remote_names; iter != NULL; iter = iter->next)
00978 g_debug("Unique remote_name: %s", (const guchar *) iter->data);
00979
00980 rtcom_el_event_free_contents (ev);
00981 rtcom_el_event_free (ev);
00982 g_list_foreach(remote_ebook_uids, (GFunc) g_free, NULL);
00983 g_list_free(remote_ebook_uids);
00984 g_list_foreach(remote_uids, (GFunc) g_free, NULL);
00985 g_list_free(remote_uids);
00986 g_list_foreach(remote_names, (GFunc) g_free, NULL);
00987 g_list_free(remote_names);
00988 }
00989 END_TEST
00990
00991 START_TEST(test_get_string)
00992 {
00993 RTComElQuery * query = NULL;
00994 RTComElEvent * ev = NULL;
00995 gint event_id = -1;
00996 RTComElIter * it = NULL;
00997 gint header_id;
00998 gchar *bar;
00999
01000 ev = event_new_full (time (NULL));
01001 if(!ev)
01002 {
01003 fail("Failed to create event.");
01004 }
01005
01006 event_id = rtcom_el_add_event(el, ev, NULL);
01007 fail_if (event_id < 0, "Fail to add event");
01008
01009 header_id = rtcom_el_add_header(
01010 el, event_id,
01011 HEADER_KEY,
01012 HEADER_VAL,
01013 NULL);
01014 fail_if (header_id < 0, "Failed to add header");
01015
01016 query = rtcom_el_query_new(el);
01017 if(!rtcom_el_query_prepare(
01018 query,
01019 "id", event_id, RTCOM_EL_OP_EQUAL,
01020 NULL))
01021 {
01022 fail("Failed to prepare the query.");
01023 }
01024
01025 it = rtcom_el_get_events(el, query);
01026 g_object_unref(query);
01027
01028 fail_unless(it != NULL, "Failed to get iterator");
01029 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
01030
01031 bar = GUINT_TO_POINTER (0xDEADBEEF);
01032 fail_if(rtcom_el_iter_dup_string(it, "bytes-sent", &bar),
01033 "Shouldn't be able to get an int value as a string");
01034 fail_unless(bar == GUINT_TO_POINTER (0xDEADBEEF),
01035 "bar should be left untouched in this case");
01036
01037 bar = GUINT_TO_POINTER (0xDEADBEEF);
01038 fail_if(rtcom_el_iter_dup_string(it, "there is no such key", &bar),
01039 "Shouldn't be able to get a missing value as a string");
01040 fail_unless(bar == GUINT_TO_POINTER (0xDEADBEEF),
01041 "bar should be left untouched in this case");
01042
01043 fail_unless(rtcom_el_iter_dup_string(it, HEADER_KEY, &bar));
01044 fail_if(bar == NULL);
01045 fail_if(bar == GUINT_TO_POINTER (0xDEADBEEF));
01046 rtcom_fail_unless_strcmp(bar, ==, HEADER_VAL);
01047
01048 g_free(bar);
01049 g_object_unref(it);
01050 rtcom_el_event_free_contents (ev);
01051 rtcom_el_event_free (ev);
01052 }
01053 END_TEST
01054
01055 START_TEST(test_get_int)
01056 {
01057 RTComElQuery * query = NULL;
01058 RTComElEvent * ev = NULL;
01059 gint event_id = -1;
01060 RTComElIter * it = NULL;
01061 gint retrieved;
01062
01063 ev = event_new_full (time (NULL));
01064 if(!ev)
01065 {
01066 fail("Failed to create event.");
01067 }
01068
01069 event_id = rtcom_el_add_event(el, ev, NULL);
01070 fail_if (event_id < 0, "Fail to add event");
01071
01072 query = rtcom_el_query_new(el);
01073 if(!rtcom_el_query_prepare(
01074 query,
01075 "id", event_id, RTCOM_EL_OP_EQUAL,
01076 NULL))
01077 {
01078 fail("Failed to prepare the query.");
01079 }
01080
01081 it = rtcom_el_get_events(el, query);
01082 g_object_unref(query);
01083
01084 fail_unless(it != NULL, "Failed to get iterator");
01085 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
01086
01087 fail_unless(rtcom_el_iter_get_int(it, "bytes-sent", &retrieved),
01088 "Failed to get bytes-sent");
01089 rtcom_fail_unless_intcmp(retrieved, ==, BYTES_SENT);
01090
01091 retrieved = 12345;
01092 fail_if(rtcom_el_iter_get_int(it, "channel", &retrieved),
01093 "Shouldn't be able to get a string value as an int");
01094 rtcom_fail_unless_intcmp(retrieved, ==, 12345);
01095
01096 retrieved = 12345;
01097 fail_if(rtcom_el_iter_get_int(it, "there is no such key", &retrieved),
01098 "Shouldn't be able to get a missing value as an int");
01099 rtcom_fail_unless_intcmp(retrieved, ==, 12345);
01100
01101 g_object_unref(it);
01102 rtcom_el_event_free_contents (ev);
01103 rtcom_el_event_free (ev);
01104 }
01105 END_TEST
01106
01107 START_TEST(test_ends_with)
01108 {
01109 RTComElQuery * query = NULL;
01110 RTComElIter * it = NULL;
01111 GValueArray * values = NULL;
01112 time_t t = 0;
01113
01114 t = time (NULL);
01115
01116 query = rtcom_el_query_new(el);
01117 if(!rtcom_el_query_prepare(
01118 query,
01119 "remote-name", "ve", RTCOM_EL_OP_STR_ENDS_WITH,
01120 NULL))
01121 {
01122 fail("Failed to prepare the query.");
01123 }
01124
01125 it = rtcom_el_get_events(el, query);
01126 g_object_unref(query);
01127
01128 fail_unless(it != NULL, "Failed to get iterator");
01129 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
01130
01131 values = rtcom_el_iter_get_valuearray(
01132 it,
01133 "free-text",
01134 NULL);
01135
01136 if(!values)
01137 {
01138 fail("Failed to get values.");
01139 }
01140
01141
01142
01143
01144 rtcom_fail_unless_strcmp("I am online", ==,
01145 g_value_get_string(g_value_array_get_nth(values, 0)));
01146
01147 g_value_array_free(values);
01148
01149 fail_unless (rtcom_el_iter_next (it));
01150
01151 values = rtcom_el_iter_get_valuearray(
01152 it,
01153 "free-text",
01154 NULL);
01155
01156 if(!values)
01157 {
01158 fail("Failed to get values.");
01159 }
01160
01161 rtcom_fail_unless_strcmp("Hello from Dave", ==,
01162 g_value_get_string(g_value_array_get_nth(values, 0)));
01163
01164 fail_if (rtcom_el_iter_next (it));
01165
01166 g_value_array_free(values);
01167
01168 g_object_unref(it);
01169 }
01170 END_TEST
01171
01172 START_TEST(test_delete_events)
01173 {
01174 RTComElQuery * query = NULL;
01175 RTComElEvent * ev = NULL;
01176 RTComElIter *it;
01177 gint event_id = -1;
01178 gint count;
01179 gboolean success;
01180
01181
01182 query = rtcom_el_query_new(el);
01183 fail_unless (rtcom_el_query_prepare (query,
01184 NULL));
01185 it = rtcom_el_get_events (el, query);
01186 g_object_unref (query);
01187 fail_unless (it != NULL);
01188 fail_unless (RTCOM_IS_EL_ITER (it));
01189 count = iter_count_results (it);
01190 rtcom_fail_unless_intcmp (count, ==, num_canned_events ());
01191 g_object_unref (it);
01192
01193 ev = event_new_full (time (NULL));
01194 if(!ev)
01195 {
01196 fail("Failed to create event.");
01197 }
01198
01199 event_id = rtcom_el_add_event(el, ev, NULL);
01200 fail_if (event_id < 0, "Failed to add event");
01201
01202 query = rtcom_el_query_new(el);
01203 if(!rtcom_el_query_prepare(
01204 query,
01205 "id", event_id, RTCOM_EL_OP_EQUAL,
01206 NULL))
01207 {
01208 fail("Failed to prepare the query.");
01209 }
01210
01211 success = rtcom_el_delete_events(el, query, NULL);
01212 g_object_unref(query);
01213
01214 fail_unless (success, "Failed to delete stuff");
01215
01216
01217
01218 rtcom_el_event_free_contents (ev);
01219 rtcom_el_event_free (ev);
01220
01221 query = rtcom_el_query_new(el);
01222 fail_unless (rtcom_el_query_prepare (query,
01223 "id", event_id, RTCOM_EL_OP_EQUAL,
01224 NULL));
01225 it = rtcom_el_get_events (el, query);
01226 g_object_unref (query);
01227 fail_unless (it == NULL);
01228 count = iter_count_results (it);
01229 rtcom_fail_unless_intcmp (count, ==, 0);
01230
01231 query = rtcom_el_query_new(el);
01232 fail_unless (rtcom_el_query_prepare (query,
01233 NULL));
01234 it = rtcom_el_get_events (el, query);
01235 g_object_unref (query);
01236 fail_unless (it != NULL);
01237 fail_unless (RTCOM_IS_EL_ITER (it));
01238 count = iter_count_results (it);
01239 rtcom_fail_unless_intcmp (count, ==, num_canned_events ());
01240 g_object_unref (it);
01241 }
01242 END_TEST
01243
01244 START_TEST(test_in_strv)
01245 {
01246 RTComElQuery * query = NULL;
01247 RTComElIter * it = NULL;
01248 GValueArray * values = NULL;
01249 time_t t = 0;
01250 const gchar * const interesting_people[] = { "Chris", "Dave", NULL };
01251
01252 t = time (NULL);
01253
01254 query = rtcom_el_query_new(el);
01255 if(!rtcom_el_query_prepare(
01256 query,
01257 "remote-name", &interesting_people, RTCOM_EL_OP_IN_STRV,
01258 NULL))
01259 {
01260 fail("Failed to prepare the query.");
01261 }
01262
01263 it = rtcom_el_get_events(el, query);
01264 g_object_unref(query);
01265
01266 fail_unless(it != NULL, "Failed to get iterator");
01267 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
01268
01269 values = rtcom_el_iter_get_valuearray(
01270 it,
01271 "free-text",
01272 NULL);
01273
01274 if(!values)
01275 {
01276 fail("Failed to get values.");
01277 }
01278
01279
01280
01281
01282
01283 rtcom_fail_unless_strcmp("Hello from Dave", ==,
01284 g_value_get_string(g_value_array_get_nth(values, 0)));
01285
01286 g_value_array_free(values);
01287
01288 fail_unless (rtcom_el_iter_next (it));
01289
01290 values = rtcom_el_iter_get_valuearray(
01291 it,
01292 "free-text",
01293 NULL);
01294
01295 if(!values)
01296 {
01297 fail("Failed to get values.");
01298 }
01299
01300 rtcom_fail_unless_strcmp("Hello from Chris", ==,
01301 g_value_get_string(g_value_array_get_nth(values, 0)));
01302
01303 fail_if (rtcom_el_iter_next (it));
01304
01305 g_value_array_free(values);
01306 g_object_unref(it);
01307 }
01308 END_TEST
01309
01310 START_TEST(test_delete_event)
01311 {
01312 RTComElQuery * query = NULL;
01313 RTComElEvent * ev = NULL;
01314 RTComElIter *it;
01315 gint event_id = -1;
01316 gint count;
01317 gint ret;
01318
01319
01320 query = rtcom_el_query_new(el);
01321 fail_unless (rtcom_el_query_prepare (query,
01322 NULL));
01323 it = rtcom_el_get_events (el, query);
01324 g_object_unref (query);
01325 fail_unless (it != NULL);
01326 fail_unless (RTCOM_IS_EL_ITER (it));
01327 count = iter_count_results (it);
01328 rtcom_fail_unless_intcmp (count, ==, num_canned_events ());
01329 g_object_unref (it);
01330
01331 ev = event_new_full (time (NULL));
01332 if(!ev)
01333 {
01334 fail("Failed to create event.");
01335 }
01336
01337 event_id = rtcom_el_add_event(el, ev, NULL);
01338 fail_if (event_id < 0, "Failed to add event");
01339
01340 ret = rtcom_el_delete_event(el, event_id, NULL);
01341 rtcom_fail_unless_intcmp (ret, ==, 0);
01342
01343
01344
01345 rtcom_el_event_free_contents (ev);
01346 rtcom_el_event_free (ev);
01347
01348 query = rtcom_el_query_new(el);
01349 fail_unless (rtcom_el_query_prepare (query,
01350 "id", event_id, RTCOM_EL_OP_EQUAL,
01351 NULL));
01352 it = rtcom_el_get_events (el, query);
01353 g_object_unref (query);
01354 fail_unless (it == NULL);
01355 count = iter_count_results (it);
01356 rtcom_fail_unless_intcmp (count, ==, 0);
01357
01358 query = rtcom_el_query_new(el);
01359 fail_unless (rtcom_el_query_prepare (query,
01360 NULL));
01361 it = rtcom_el_get_events (el, query);
01362 g_object_unref (query);
01363 fail_unless (it != NULL);
01364 fail_unless (RTCOM_IS_EL_ITER (it));
01365 count = iter_count_results (it);
01366 rtcom_fail_unless_intcmp (count, ==, num_canned_events ());
01367 g_object_unref (it);
01368 }
01369 END_TEST
01370
01371 START_TEST(test_string_equals)
01372 {
01373 RTComElQuery * query = NULL;
01374 RTComElIter * it = NULL;
01375 GValueArray * values = NULL;
01376 time_t t = 0;
01377
01378 t = time (NULL);
01379
01380 query = rtcom_el_query_new(el);
01381 if(!rtcom_el_query_prepare(
01382 query,
01383 "local-uid", "butterfly/msn/alice", RTCOM_EL_OP_NOT_EQUAL,
01384 "remote-name", "Bob", RTCOM_EL_OP_EQUAL,
01385 NULL))
01386 {
01387 fail("Failed to prepare the query.");
01388 }
01389
01390 it = rtcom_el_get_events(el, query);
01391 g_object_unref(query);
01392
01393 fail_unless(it != NULL, "Failed to get iterator");
01394 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
01395
01396 values = rtcom_el_iter_get_valuearray(
01397 it,
01398 "free-text",
01399 NULL);
01400
01401 if(!values)
01402 {
01403 fail("Failed to get values.");
01404 }
01405
01406
01407
01408
01409
01410 rtcom_fail_unless_strcmp("Are you there?", ==,
01411 g_value_get_string(g_value_array_get_nth(values, 0)));
01412
01413 g_value_array_free(values);
01414
01415 fail_unless (rtcom_el_iter_next (it));
01416
01417 values = rtcom_el_iter_get_valuearray(
01418 it,
01419 "free-text",
01420 NULL);
01421
01422 if(!values)
01423 {
01424 fail("Failed to get values.");
01425 }
01426
01427 rtcom_fail_unless_strcmp("Hi Alice", ==,
01428 g_value_get_string(g_value_array_get_nth(values, 0)));
01429
01430 fail_if (rtcom_el_iter_next (it));
01431
01432 g_value_array_free(values);
01433 g_object_unref(it);
01434 }
01435 END_TEST
01436
01437 START_TEST(test_int_ranges)
01438 {
01439 RTComElQuery * query = NULL;
01440 RTComElIter * it = NULL;
01441 GValueArray * values = NULL;
01442 time_t t = 0;
01443
01444 t = time (NULL);
01445
01446 query = rtcom_el_query_new(el);
01447 if(!rtcom_el_query_prepare(
01448 query,
01449 "start-time", 0, RTCOM_EL_OP_GREATER,
01450 "start-time", 4000, RTCOM_EL_OP_LESS_EQUAL,
01451 NULL))
01452 {
01453 fail("Failed to prepare the query.");
01454 }
01455
01456 it = rtcom_el_get_events(el, query);
01457 g_object_unref(query);
01458
01459 fail_unless(it != NULL, "Failed to get iterator");
01460 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
01461
01462 values = rtcom_el_iter_get_valuearray(
01463 it,
01464 "free-text",
01465 NULL);
01466
01467 if(!values)
01468 {
01469 fail("Failed to get values.");
01470 }
01471
01472
01473
01474
01475 rtcom_fail_unless_strcmp("Are you there?", ==,
01476 g_value_get_string(g_value_array_get_nth(values, 0)));
01477
01478 g_value_array_free(values);
01479
01480 fail_unless (rtcom_el_iter_next (it));
01481
01482 values = rtcom_el_iter_get_valuearray(
01483 it,
01484 "free-text",
01485 NULL);
01486
01487 if(!values)
01488 {
01489 fail("Failed to get values.");
01490 }
01491
01492 rtcom_fail_unless_strcmp("Hello from Dave", ==,
01493 g_value_get_string(g_value_array_get_nth(values, 0)));
01494
01495 g_value_array_free(values);
01496
01497 fail_unless (rtcom_el_iter_next (it));
01498
01499 values = rtcom_el_iter_get_valuearray(
01500 it,
01501 "free-text",
01502 NULL);
01503
01504 if(!values)
01505 {
01506 fail("Failed to get values.");
01507 }
01508
01509 rtcom_fail_unless_strcmp("Hello from Chris", ==,
01510 g_value_get_string(g_value_array_get_nth(values, 0)));
01511
01512 g_value_array_free(values);
01513
01514 fail_unless (rtcom_el_iter_next (it));
01515
01516 values = rtcom_el_iter_get_valuearray(
01517 it,
01518 "free-text",
01519 NULL);
01520
01521 if(!values)
01522 {
01523 fail("Failed to get values.");
01524 }
01525
01526 rtcom_fail_unless_strcmp("Hi Alice", ==,
01527 g_value_get_string(g_value_array_get_nth(values, 0)));
01528
01529 fail_if (rtcom_el_iter_next (it));
01530
01531 g_value_array_free(values);
01532 g_object_unref(it);
01533 }
01534 END_TEST
01535
01536 START_TEST(test_group_by_uids)
01537 {
01538 RTComElQuery * query = NULL;
01539 RTComElIter * it = NULL;
01540 gchar *s;
01541
01542 query = rtcom_el_query_new(el);
01543 rtcom_el_query_set_group_by (query, RTCOM_EL_QUERY_GROUP_BY_UIDS);
01544 fail_unless(rtcom_el_query_prepare(query,
01545 "remote-uid", "f", RTCOM_EL_OP_LESS,
01546 NULL));
01547
01548 it = rtcom_el_get_events(el, query);
01549 g_object_unref(query);
01550
01551 fail_unless(it != NULL, "Failed to get iterator");
01552
01553
01554
01555
01556 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
01557 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01558 rtcom_fail_unless_strcmp("bob@example.com", ==, s);
01559 g_free (s);
01560 fail_unless (rtcom_el_iter_dup_string (it, "local-uid", &s));
01561 rtcom_fail_unless_strcmp("butterfly/msn/alice", ==, s);
01562 g_free (s);
01563
01564 fail_unless (rtcom_el_iter_next (it));
01565 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01566 rtcom_fail_unless_strcmp("christine@msn.invalid", ==, s);
01567 g_free (s);
01568
01569 fail_unless (rtcom_el_iter_next (it));
01570 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01571 rtcom_fail_unless_strcmp("eve@example.com", ==, s);
01572 g_free (s);
01573
01574 fail_unless (rtcom_el_iter_next (it));
01575 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01576 rtcom_fail_unless_strcmp("bob@example.com", ==, s);
01577 g_free (s);
01578 fail_unless (rtcom_el_iter_dup_string (it, "free-text", &s));
01579 rtcom_fail_unless_strcmp("Are you there?", ==, s);
01580 g_free (s);
01581
01582 fail_unless (rtcom_el_iter_next (it));
01583 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01584 rtcom_fail_unless_strcmp("dave@example.com", ==, s);
01585 g_free (s);
01586
01587 fail_unless (rtcom_el_iter_next (it));
01588 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01589 rtcom_fail_unless_strcmp("chris@example.com", ==, s);
01590 g_free (s);
01591
01592
01593
01594 fail_if (rtcom_el_iter_next (it), "Iterator should have expired");
01595
01596 g_object_unref(it);
01597 }
01598 END_TEST
01599
01600 START_TEST(test_group_by_metacontacts)
01601 {
01602 RTComElQuery * query = NULL;
01603 RTComElIter * it = NULL;
01604 gchar *s;
01605
01606 query = rtcom_el_query_new(el);
01607 rtcom_el_query_set_group_by (query, RTCOM_EL_QUERY_GROUP_BY_CONTACT);
01608 fail_unless(rtcom_el_query_prepare(query,
01609 "remote-uid", "f", RTCOM_EL_OP_LESS,
01610 NULL));
01611
01612 it = rtcom_el_get_events(el, query);
01613 g_object_unref(query);
01614
01615 fail_unless(it != NULL, "Failed to get iterator");
01616
01617
01618
01619
01620 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
01621 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01622 rtcom_fail_unless_strcmp("bob@example.com", ==, s);
01623 g_free (s);
01624 fail_unless (rtcom_el_iter_dup_string (it, "local-uid", &s));
01625 rtcom_fail_unless_strcmp("butterfly/msn/alice", ==, s);
01626 g_free (s);
01627
01628 fail_unless (rtcom_el_iter_next (it));
01629 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01630 rtcom_fail_unless_strcmp("christine@msn.invalid", ==, s);
01631 g_free (s);
01632
01633 fail_unless (rtcom_el_iter_next (it));
01634 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01635 rtcom_fail_unless_strcmp("eve@example.com", ==, s);
01636 g_free (s);
01637
01638
01639
01640
01641
01642
01643
01644
01645 fail_unless (rtcom_el_iter_next (it));
01646 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01647 rtcom_fail_unless_strcmp("bob@example.com", ==, s);
01648 g_free (s);
01649 fail_unless (rtcom_el_iter_dup_string (it, "local-uid", &s));
01650 rtcom_fail_unless_strcmp("gabble/jabber/alice", ==, s);
01651 g_free (s);
01652
01653 fail_unless (rtcom_el_iter_next (it));
01654 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01655 rtcom_fail_unless_strcmp("dave@example.com", ==, s);
01656 g_free (s);
01657
01658
01659
01660
01661
01662
01663
01664 fail_if (rtcom_el_iter_next (it), "Iterator should have expired");
01665
01666 g_object_unref(it);
01667 }
01668 END_TEST
01669
01670 START_TEST(test_group_by_group)
01671 {
01672 RTComElQuery * query = NULL;
01673 RTComElIter * it = NULL;
01674 gchar *s;
01675
01676 query = rtcom_el_query_new(el);
01677 rtcom_el_query_set_group_by (query, RTCOM_EL_QUERY_GROUP_BY_GROUP);
01678 fail_unless(rtcom_el_query_prepare(query,
01679
01680 "remote-uid", "b", RTCOM_EL_OP_GREATER_EQUAL,
01681 "remote-uid", "g", RTCOM_EL_OP_LESS,
01682 NULL));
01683
01684 it = rtcom_el_get_events(el, query);
01685 g_object_unref(query);
01686
01687 fail_unless(it != NULL, "Failed to get iterator");
01688
01689
01690
01691
01692 fail_unless(rtcom_el_iter_first(it), "Failed to start iterator");
01693 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01694 rtcom_fail_unless_strcmp("bob@example.com", ==, s);
01695 g_free (s);
01696 fail_unless (rtcom_el_iter_dup_string (it, "local-uid", &s));
01697 rtcom_fail_unless_strcmp("butterfly/msn/alice", ==, s);
01698 g_free (s);
01699 fail_unless (rtcom_el_iter_dup_string (it, "group-uid", &s));
01700 rtcom_fail_unless_strcmp("group(bob)", ==, s);
01701 g_free (s);
01702
01703 fail_unless (rtcom_el_iter_next (it));
01704 fail_unless (rtcom_el_iter_dup_string (it, "remote-uid", &s));
01705 rtcom_fail_unless_strcmp("frank@msn.invalid", ==, s);
01706 g_free (s);
01707 fail_unless (rtcom_el_iter_dup_string (it, "local-uid", &s));
01708 rtcom_fail_unless_strcmp("butterfly/msn/alice", ==, s);
01709 g_free (s);
01710 fail_unless (rtcom_el_iter_dup_string (it, "group-uid", &s));
01711 rtcom_fail_unless_strcmp("group(chris+frank)", ==, s);
01712 g_free (s);
01713
01714
01715
01716
01717
01718 fail_if (rtcom_el_iter_next (it), "Iterator should have expired");
01719
01720 g_object_unref(it);
01721 }
01722 END_TEST
01723
01724 START_TEST(test_update_remote_contact)
01725 {
01726 RTComElQuery *query_by_abook;
01727 RTComElQuery *query_by_name;
01728 RTComElIter *it;
01729 gint count;
01730
01731
01732 fail_unless (rtcom_eventlogger_update_remote_contact (el,
01733 "gabble/jabber/alice", "bob@example.com",
01734 "abook-bob", "Robert", NULL));
01735
01736 query_by_abook = rtcom_el_query_new(el);
01737 fail_unless(rtcom_el_query_prepare(query_by_abook,
01738 "remote-ebook-uid", "abook-bob", RTCOM_EL_OP_EQUAL,
01739 NULL));
01740
01741
01742 it = rtcom_el_get_events (el, query_by_abook);
01743 fail_unless (it != NULL, "Failed to get iterator");
01744 count = iter_count_results (it);
01745 rtcom_fail_unless_intcmp (count, ==, 2);
01746
01747
01748 fail_unless (rtcom_eventlogger_update_remote_contact (el,
01749 "butterfly/msn/alice", "bob@example.com",
01750 "abook-bob", "Robert", NULL));
01751
01752
01753 fail_unless (rtcom_el_iter_refresh (it));
01754 count = iter_count_results (it);
01755 rtcom_fail_unless_intcmp (count, ==, 3);
01756
01757 g_object_unref (it);
01758
01759
01760 query_by_name = rtcom_el_query_new(el);
01761 fail_unless(rtcom_el_query_prepare(query_by_name,
01762 "remote-name", "Robert", RTCOM_EL_OP_EQUAL,
01763 NULL));
01764
01765 it = rtcom_el_get_events (el, query_by_name);
01766 fail_unless (it != NULL, "Failed to get iterator");
01767 count = iter_count_results (it);
01768 rtcom_fail_unless_intcmp (count, ==, 3);
01769
01770
01771 fail_unless (rtcom_eventlogger_update_remote_contact (el,
01772 "gabble/jabber/alice", "bob@example.com",
01773 NULL, "Robert", NULL));
01774 fail_unless (rtcom_eventlogger_update_remote_contact (el,
01775 "butterfly/msn/alice", "bob@example.com",
01776 NULL, "Robert", NULL));
01777 fail_unless (rtcom_el_iter_refresh (it));
01778 count = iter_count_results (it);
01779 rtcom_fail_unless_intcmp (count, ==, 3);
01780
01781 g_object_unref (it);
01782
01783 g_object_unref (query_by_abook);
01784 g_object_unref (query_by_name);
01785 }
01786 END_TEST
01787
01788 Suite *
01789 el_suite(void)
01790 {
01791 Suite * s = suite_create ("rtcom-eventlogger");
01792
01793
01794 TCase * tc_core = tcase_create("Core");
01795 tcase_add_checked_fixture(tc_core, core_setup, core_teardown);
01796 tcase_add_test(tc_core, test_add_event);
01797 tcase_add_test(tc_core, test_add_full);
01798 tcase_add_test(tc_core, test_header);
01799 tcase_add_test(tc_core, test_attach);
01800 tcase_add_test(tc_core, test_read);
01801 tcase_add_test(tc_core, test_flags);
01802 tcase_add_test(tc_core, test_get);
01803 tcase_add_test(tc_core, test_unique_remotes);
01804 tcase_add_test(tc_core, test_get_int);
01805 tcase_add_test(tc_core, test_get_string);
01806 tcase_add_test(tc_core, test_ends_with);
01807 tcase_add_test(tc_core, test_delete_events);
01808 tcase_add_test(tc_core, test_delete_event);
01809 tcase_add_test(tc_core, test_in_strv);
01810 tcase_add_test(tc_core, test_string_equals);
01811 tcase_add_test(tc_core, test_int_ranges);
01812 tcase_add_test(tc_core, test_group_by_uids);
01813 tcase_add_test(tc_core, test_group_by_metacontacts);
01814 tcase_add_test(tc_core, test_group_by_group);
01815 tcase_add_test(tc_core, test_update_remote_contact);
01816
01817 suite_add_tcase(s, tc_core);
01818
01819 return s;
01820 }
01821
01822 int main(void)
01823 {
01824 int number_failed;
01825 Suite * s = el_suite();
01826 SRunner * sr = srunner_create(s);
01827
01828 srunner_set_xml(sr, "/tmp/result.xml");
01829 srunner_run_all(sr, CK_NORMAL);
01830 number_failed = srunner_ntests_failed(sr);
01831 srunner_free (sr);
01832
01833 return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
01834 }
01835
01836
01837