test/testapp-mail.c

   1 /*
   2 *  email-service
   3 *
   4 * Copyright(c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5 *
   6 * Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>
   7 *
   8 * Licensed under the Apache License, Version 2.0(the "License");
   9 * you may not use this file except in compliance with the License.
  10 * You may obtain a copy of the License at
  11 *
  12 * http://www.apache.org/licenses/LICENSE-2.0
  13 *
  14 * Unless required by applicable law or agreed to in writing, software
  15 * distributed under the License is distributed on an "AS IS" BASIS,
  16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 * See the License for the specific language governing permissions and
  18 * limitations under the License.
  19 *
  20 */
  21
  22
  23
  24 /* common header */
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <sys/stat.h>
  29 #include <wait.h>
  30
  31 /* open header */
  32 #include <glib.h>
  33 #include <time.h>
  34
  35 #include "email-api-account.h"
  36 #include "email-api-network.h"
  37 #include "email-api-mail.h"
  38 #include "email-api-mailbox.h"
  39 #include "email-api-etc.h"
  40 #include "email-api-smime.h"
  41
  42 /* internal header */
  43 #include "testapp-utility.h"
  44 #include "testapp-mail.h"
  45 #include "email-core-utils.h"
  46 #include "email-core-mime.h"
  47
  48 #define MAIL_TEMP_BODY "/tmp/utf8"
  49 #define HTML_TEMP_BODY "/tmp/utf8.htm"
  50
  51 /*
  52 static void testapp_test_print_sorting_menu()
  53 {
  54         testapp_print("   EMAIL_SORT_DATETIME_HIGH = 0\n");
  55         testapp_print("   EMAIL_SORT_DATETIME_LOW = 1\n");
  56         testapp_print("   EMAIL_SORT_SENDER_HIGH = 2\n");
  57         testapp_print("   EMAIL_SORT_SENDER_LOW = 3\n");
  58         testapp_print("   EMAIL_SORT_RCPT_HIGH = 4\n");
  59         testapp_print("   EMAIL_SORT_RCPT_LOW = 5\n");
  60         testapp_print("   EMAIL_SORT_SUBJECT_HIGH = 6\n");
  61         testapp_print("   EMAIL_SORT_SUBJECT_LOW = 7\n");
  62         testapp_print("   EMAIL_SORT_PRIORITY_HIGH = 8\n");
  63         testapp_print("   EMAIL_SORT_PRIORITY_LOW = 9\n");
  64         testapp_print("   EMAIL_SORT_ATTACHMENT_HIGH = 10\n");
  65         testapp_print("   EMAIL_SORT_ATTACHMENT_LOW = 11\n");
  66         testapp_print("   EMAIL_SORT_FAVORITE_HIGH = 12\n");
  67         testapp_print("   EMAIL_SORT_FAVORITE_LOW = 13\n");
  68 }
  69
  70 static void testapp_test_print_mail_list_item(email_mail_list_item_t *mail_list_item, int count)
  71 {
  72         int i;
  73
  74         testapp_print("\n>>>>> Print mail list items: count[%d]\n", count);
  75         for (i=0; i< count; i++) {
  76                 testapp_print("\n[%d]\n", i);
  77                 testapp_print(" >>> Mailbox Name [ %s ] \n", mail_list_item[i].mailbox_name);
  78                 testapp_print(" >>> Mail ID [ %d ] \n", mail_list_item[i].mail_id);
  79                 testapp_print(" >>> Account ID [ %d ] \n", mail_list_item[i].account_id);
  80                 if (mail_list_item[i].from!= NULL) {
  81                         testapp_print(" >>> From [ %s ] \n", mail_list_item[i].from);
  82                 }
  83                 if (mail_list_item[i].from_email_address != NULL) {
  84                         testapp_print(" >>> from_email_address [ %s ] \n", mail_list_item[i].from_email_address);
  85                 }
  86                 if (mail_list_item[i].recipients!= NULL) {
  87                         testapp_print(" >>> recipients [ %s ] \n", mail_list_item[i].recipients);
  88                 }
  89                 if (mail_list_item[i].subject != NULL) {
  90                         testapp_print(" >>> subject [ %s ] \n", mail_list_item[i].subject);
  91                 }
  92                 testapp_print(" >>> text_download_yn [ %d ] \n", mail_list_item[i].body_download_status);
  93                 testapp_print(" >>> date_time [ %d ] \n", mail_list_item[i].date_time);
  94                 testapp_print(" >>> flags_seen_field [ %d ] \n", mail_list_item[i].flags_seen_field);
  95                 testapp_print(" >>> priority [ %d ] \n", mail_list_item[i].priority);
  96                 testapp_print(" >>> save_status [ %d ] \n", mail_list_item[i].save_status);
  97                 testapp_print(" >>> lock [ %d ] \n", mail_list_item[i].lock_status);
  98                 testapp_print(" >>> report_status [ %d ] \n", mail_list_item[i].report_status);
  99                 testapp_print(" >>> recipients_count [ %d ] \n", mail_list_item[i].recipients_count);
 100                 testapp_print(" >>> attachment_count [ %d ] \n", mail_list_item[i].attachment_count);
 101                 testapp_print(" >>> DRM_status [ %d ] \n", mail_list_item[i].DRM_status);
 102
 103                 if (mail_list_item[i].preview_text != NULL) {
 104                         testapp_print(" >>> preview_text [ %s ] \n", mail_list_item[i].preview_text);
 105                 }
 106
 107                 testapp_print(" >>> thread_id [ %d ] \n", mail_list_item[i].thread_id);
 108                 testapp_print(" >>> thread_item_count [ %d ] \n", mail_list_item[i].thread_item_count);
 109         }
 110 }
 111 */
 112
 113 static gboolean testapp_add_mail_for_sending(int *result_mail_id)
 114 {
 115         int                    i = 0;
 116         int                    account_id = 0;
 117         int                    err = EMAIL_ERROR_NONE;
 118         int                    smime_type = 0;
 119         char                   recipient_address[300] = { 0 , };
 120         char                   from_address[300] = { 0 , };
 121         char                   passpharse[300] = {0, };
 122         const char            *body_file_path = MAIL_TEMP_BODY;
 123
 124         email_account_t       *account_data = NULL;
 125         email_mailbox_t       *mailbox_data = NULL;
 126         email_mail_data_t     *test_mail_data = NULL;
 127         FILE                  *body_file;
 128
 129         testapp_print("\n > Enter account id : ");
 130         if (0 >= scanf("%d", &account_id))
 131                 testapp_print("Invalid input. ");
 132
 133         testapp_print("\n > Enter recipient address : ");
 134         if (0 >= scanf("%s", recipient_address))
 135                 testapp_print("Invalid input. ");
 136
 137         email_get_account(account_id, GET_FULL_DATA_WITHOUT_PASSWORD, &account_data);
 138
 139         email_get_mailbox_by_mailbox_type(account_id, EMAIL_MAILBOX_TYPE_OUTBOX, &mailbox_data);
 140
 141         test_mail_data = malloc(sizeof(email_mail_data_t));
 142         memset(test_mail_data, 0x00, sizeof(email_mail_data_t));
 143
 144         SNPRINTF(from_address, 300, "<%s>", account_data->user_email_address);
 145
 146         test_mail_data->account_id             = account_id;
 147         test_mail_data->save_status            = EMAIL_MAIL_STATUS_SEND_DELAYED;
 148         test_mail_data->body_download_status   = 1;
 149         test_mail_data->flags_seen_field       = 1;
 150         test_mail_data->file_path_plain        = strdup(body_file_path);
 151         test_mail_data->mailbox_id             = mailbox_data->mailbox_id;
 152         test_mail_data->mailbox_type           = mailbox_data->mailbox_type;
 153         test_mail_data->full_address_from      = strdup(from_address);
 154         test_mail_data->full_address_to        = strdup(recipient_address);
 155         test_mail_data->subject                = strdup("Read receipt request from TIZEN");
 156         test_mail_data->remaining_resend_times = 3;
 157         test_mail_data->report_status          = EMAIL_MAIL_REQUEST_DSN | EMAIL_MAIL_REQUEST_MDN;
 158
 159         body_file = fopen(body_file_path, "w");
 160
 161         testapp_print("\n body_file [%p]\n", body_file);
 162
 163         if (body_file == NULL) {
 164                 testapp_print("\n fopen [%s]failed\n", body_file_path);
 165                 return FALSE;
 166         }
 167
 168         for (i = 0; i < 100; i++)
 169                 fprintf(body_file, "Mail sending Test. [%d]\n", i);
 170
 171         fflush(body_file);
 172         fclose(body_file);
 173
 174         testapp_print(" > Select smime? [0: Normal, 1: sign, 2: Encrpyt, 3: sing + encrypt, 4: pgp sign, 5: pgp encrypted, 6: pgp sign + encrypt] : ");
 175         if (0 >= scanf("%d", &smime_type))
 176                 testapp_print("Invalid input. ");
 177         test_mail_data->smime_type = smime_type;
 178
 179         if (smime_type >= EMAIL_PGP_SIGNED) {
 180                 testapp_print(" > passpharse : ");
 181                 if (0 >= scanf("%s", passpharse))
 182                         testapp_print("Invalid input. ");
 183                 test_mail_data->pgp_password = strdup(passpharse);
 184         }
 185
 186         if ((err = email_add_mail(test_mail_data, NULL, 0, NULL, 0)) != EMAIL_ERROR_NONE)
 187                 testapp_print("email_add_mail failed. [%d]\n", err);
 188         else
 189                 testapp_print("email_add_mail success.\n");
 190
 191         testapp_print("saved mail id = [%d]\n", test_mail_data->mail_id);
 192
 193         if (result_mail_id)
 194                 *result_mail_id = test_mail_data->mail_id;
 195
 196         email_free_mail_data(&test_mail_data, 1);
 197         email_free_mailbox(&mailbox_data, 1);
 198         email_free_account(&account_data, 1);
 199
 200         return FALSE;
 201 }
 202
 203 static gboolean testapp_test_add_mail(int *result_mail_id)
 204 {
 205         int                    i = 0;
 206         int                    account_id = 0;
 207         int                    mailbox_id = 0;
 208         int                    from_eas = 0;
 209         int                    attachment_count = 0;
 210         int                    err = EMAIL_ERROR_NONE;
 211         int                    smime_type = 0;
 212         char                   arg[50] = { 0 , };
 213         const char            *body_file_path = MAIL_TEMP_BODY;
 214         email_mailbox_t         *mailbox_data = NULL;
 215         email_mail_data_t       *test_mail_data = NULL;
 216         email_attachment_data_t *attachment_data = NULL;
 217         email_meeting_request_t *meeting_req = NULL;
 218         FILE                  *body_file;
 219
 220         testapp_print("\n > Enter account id : ");
 221         if (0 >= scanf("%d", &account_id))
 222                 testapp_print("Invalid input. ");
 223
 224         memset(arg, 0x00, 50);
 225         testapp_print("\n > Enter mailbox id : ");
 226         if (0 >= scanf("%d", &mailbox_id))
 227                 testapp_print("Invalid input. ");
 228
 229         email_get_mailbox_by_mailbox_id(mailbox_id, &mailbox_data);
 230
 231         test_mail_data = malloc(sizeof(email_mail_data_t));
 232         memset(test_mail_data, 0x00, sizeof(email_mail_data_t));
 233
 234         testapp_print("\n From EAS? [0/1]> ");
 235         if (0 >= scanf("%d", &from_eas))
 236                 testapp_print("Invalid input. ");
 237
 238         test_mail_data->account_id             = account_id;
 239         test_mail_data->save_status            = 1;
 240         test_mail_data->body_download_status   = 1;
 241         test_mail_data->flags_seen_field       = 1;
 242         test_mail_data->file_path_plain        = strdup(body_file_path);
 243         test_mail_data->mailbox_id             = mailbox_id;
 244         test_mail_data->mailbox_type           = mailbox_data->mailbox_type;
 245         test_mail_data->full_address_from      = strdup("<test1@test.com>");
 246         test_mail_data->full_address_to        = strdup("<test2@test.com>");
 247         test_mail_data->full_address_cc        = strdup("<test3@test.com>");
 248         test_mail_data->full_address_bcc       = strdup("<test4@test.com>");
 249         test_mail_data->subject                = strdup("Meeting request mail");
 250         test_mail_data->remaining_resend_times = 3;
 251         test_mail_data->eas_data               = strdup("EAS DATA TEST");
 252         test_mail_data->eas_data_length        = strlen(test_mail_data->eas_data) + 1;
 253
 254         body_file = fopen(body_file_path, "w");
 255
 256         testapp_print("\n body_file [%p]\n", body_file);
 257
 258         if (body_file == NULL) {
 259                 testapp_print("\n fopen [%s]failed\n", body_file_path);
 260                 email_free_mail_data(&test_mail_data, 1);
 261                 email_free_mailbox(&mailbox_data, 1);
 262                 return FALSE;
 263         }
 264 /*
 265         for (i = 0; i < 500; i++)
 266                 fprintf(body_file, "X2 X2 X2 X2 X2 X2 X2");
 267 */
 268         fprintf(body_file, "Hello world");
 269         fflush(body_file);
 270         fclose(body_file);
 271
 272         testapp_print(" > Select smime? [0: Normal, 1: sign, 2: Encrypt, 3: sing + encrypt] : ");
 273         if (0 >= scanf("%d", &smime_type))
 274                 testapp_print("Invalid input. ");
 275         test_mail_data->smime_type = smime_type;
 276
 277         testapp_print(" > How many file attachment? [>=0] : ");
 278         if (0 >= scanf("%d", &attachment_count))
 279                 testapp_print("Invalid input. ");
 280
 281         test_mail_data->attachment_count  = attachment_count;
 282         if (attachment_count > 0)
 283                 attachment_data = calloc(attachment_count, sizeof(email_attachment_data_t));
 284
 285
 286         for (i = 0; i < attachment_count ; i++) {
 287                 memset(arg, 0x00, 50);
 288                 testapp_print("\n > Enter attachment name : ");
 289                 if (0 >= scanf("%s", arg))
 290                         testapp_print("Invalid input. ");
 291
 292                 attachment_data[i].attachment_name  = strdup(arg);
 293
 294                 memset(arg, 0x00, 50);
 295                 testapp_print("\n > Enter attachment absolute path : ");
 296                 if (0 >= scanf("%s", arg))
 297                         testapp_print("Invalid input. ");
 298
 299                 attachment_data[i].attachment_path  = strdup(arg);
 300                 attachment_data[i].save_status      = 1;
 301                 attachment_data[i].mailbox_id       = test_mail_data->mailbox_id;
 302         }
 303
 304         testapp_print("\n > Meeting Request? [0: no, 1: yes(request from server), 2: yes(response from local)]");
 305         if (0 >= scanf("%d", (int *)&(test_mail_data->meeting_request_status)))
 306                 testapp_print("Invalid input. ");
 307
 308         if (test_mail_data->meeting_request_status == 1
 309                 || test_mail_data->meeting_request_status == 2) {
 310                 time_t current_time;
 311                 /*  dummy data for meeting request */
 312                 meeting_req = malloc(sizeof(email_meeting_request_t));
 313                 memset(meeting_req, 0x00, sizeof(email_meeting_request_t));
 314
 315                 meeting_req->meeting_response     = 1;
 316                 current_time = time(NULL);
 317                 gmtime_r(&current_time, &(meeting_req->start_time));
 318                 gmtime_r(&current_time, &(meeting_req->end_time));
 319                 meeting_req->location = strdup("Seoul");
 320                 meeting_req->global_object_id = strdup("abcdef12345");
 321
 322                 meeting_req->time_zone.offset_from_GMT = 9;
 323                 strcpy(meeting_req->time_zone.standard_name, "STANDARD_NAME");
 324                 gmtime_r(&current_time, &(meeting_req->time_zone.standard_time_start_date));
 325                 meeting_req->time_zone.standard_bias = 3;
 326
 327                 strcpy(meeting_req->time_zone.daylight_name, "DAYLIGHT_NAME");
 328                 gmtime_r(&current_time, &(meeting_req->time_zone.daylight_time_start_date));
 329                 meeting_req->time_zone.daylight_bias = 7;
 330
 331         }
 332
 333         if ((err = email_add_mail(test_mail_data, attachment_data, attachment_count, meeting_req, from_eas)) != EMAIL_ERROR_NONE)
 334                 testapp_print("email_add_mail failed. [%d]\n", err);
 335         else
 336                 testapp_print("email_add_mail success.\n");
 337
 338         testapp_print("saved mail id = [%d]\n", test_mail_data->mail_id);
 339         testapp_print("saved mailbox id = [%d]\n", test_mail_data->mailbox_id);
 340
 341         if (result_mail_id)
 342                 *result_mail_id = test_mail_data->mail_id;
 343
 344         if (attachment_data)
 345                 email_free_attachment_data(&attachment_data, attachment_count);
 346
 347         if (meeting_req)
 348                 email_free_meeting_request(&meeting_req, 1);
 349
 350         email_free_mail_data(&test_mail_data, 1);
 351         email_free_mailbox(&mailbox_data, 1);
 352
 353         return FALSE;
 354 }
 355
 356 static gboolean testapp_test_update_mail()
 357 {
 358         int                    mail_id = 0;
 359         int                    err = EMAIL_ERROR_NONE;
 360         int                    test_attachment_data_count = 0;
 361         int                    ret = 0;
 362         char                   arg[50];
 363         email_mail_data_t       *test_mail_data = NULL;
 364         email_attachment_data_t *test_attachment_data_list = NULL;
 365         email_meeting_request_t *meeting_req = NULL;
 366
 367         testapp_print("\n > Enter mail id : ");
 368         if (0 >= scanf("%d", &mail_id))
 369                 testapp_print("Invalid input. ");
 370
 371         email_get_mail_data(mail_id, &test_mail_data);
 372
 373         if (!test_mail_data) {
 374                 testapp_print("email_get_mail_data() failed\n");
 375                 return FALSE;
 376         }
 377
 378         testapp_print("\n > Enter Subject: ");
 379         if (0 >= scanf("%s", arg))
 380                 testapp_print("Invalid input. ");
 381
 382         test_mail_data->subject = strdup(arg);
 383
 384         if (test_mail_data->attachment_count > 0) {
 385                 if ((err = email_get_attachment_data_list(mail_id, &test_attachment_data_list, &test_attachment_data_count)) != EMAIL_ERROR_NONE) {
 386                         testapp_print("email_get_attachment_data_list() failed [%d]\n", err);
 387                         goto FINISH_OFF;
 388                 }
 389         }
 390
 391         if (test_mail_data->meeting_request_status == EMAIL_MAIL_TYPE_MEETING_REQUEST
 392                 || test_mail_data->meeting_request_status == EMAIL_MAIL_TYPE_MEETING_RESPONSE
 393                 || test_mail_data->meeting_request_status == EMAIL_MAIL_TYPE_MEETING_ORIGINATINGREQUEST) {
 394
 395                 if ((err = email_get_meeting_request(mail_id, &meeting_req)) != EMAIL_ERROR_NONE) {
 396                         testapp_print("email_get_meeting_request() failed [%d]\n", err);
 397                         goto FINISH_OFF;
 398                 }
 399
 400                 testapp_print("\n > Enter meeting response: ");
 401                 if (0 >= scanf("%d", (int *)&(meeting_req->meeting_response)))
 402                         testapp_print("Invalid input. ");
 403         }
 404
 405         if ((err = email_update_mail(test_mail_data, test_attachment_data_list, test_attachment_data_count, meeting_req, 0)) != EMAIL_ERROR_NONE)
 406                         testapp_print("email_update_mail failed.[%d]\n", err);
 407                 else
 408                         testapp_print("email_update_mail success\n");
 409
 410         ret = 1;
 411
 412 FINISH_OFF:
 413
 414         if (test_mail_data)
 415                 email_free_mail_data(&test_mail_data, 1);
 416
 417         if (test_attachment_data_list)
 418                 email_free_attachment_data(&test_attachment_data_list, test_attachment_data_count);
 419
 420         if (meeting_req)
 421                 email_free_meeting_request(&meeting_req, 1);
 422
 423         if (!ret)
 424                 return FALSE;
 425
 426         return TRUE;
 427 }
 428
 429 static gboolean testapp_test_get_mails()
 430 {
 431         testapp_print("\n >>> testapp_test_get_mails : Entered \n");
 432         email_mail_data_t *mails = NULL, **mails_pointer = NULL;
 433         int mailbox_id = 0;
 434         int count = 0, i = 0;
 435         int account_id = 0;
 436         int start_index = 0;
 437         int limit_count = 0;
 438         int sorting = 0;
 439         int err_code = EMAIL_ERROR_NONE;
 440         int to_get_count = 0;
 441         int is_for_thread_view = 0;
 442         int list_type;
 443         struct tm *temp_time_info;
 444
 445         testapp_print("\n > Enter Account_id(0 = all accounts) : ");
 446         if (0 >= scanf("%d", &account_id))
 447                 testapp_print("Invalid input. ");
 448         testapp_print("\n > Enter Mailbox id(0 = all mailboxes) :");
 449         if (0 >= scanf("%d", &mailbox_id))
 450                 testapp_print("Invalid input. ");
 451
 452         testapp_print("\n > Enter Sorting : ");
 453         if (0 >= scanf("%d", &sorting))
 454                 testapp_print("Invalid input. ");
 455
 456         testapp_print("\n > Enter Start index(starting at 0): ");
 457         if (0 >= scanf("%d", &start_index))
 458                 testapp_print("Invalid input. ");
 459
 460         testapp_print("\n > Enter max_count : ");
 461         if (0 >= scanf("%d", &limit_count))
 462                 testapp_print("Invalid input. ");
 463
 464         testapp_print("\n > For thread view : ");
 465         if (0 >= scanf("%d", &is_for_thread_view))
 466                 testapp_print("Invalid input. ");
 467
 468         testapp_print("\n > Mail count only(0:list 1:count): ");
 469         if (0 >= scanf("%d", &to_get_count))
 470                 testapp_print("Invalid input. ");
 471
 472         if (to_get_count)
 473                 mails_pointer = NULL;
 474         else
 475                 mails_pointer = &mails;
 476
 477         if (is_for_thread_view == -2)
 478                 list_type = EMAIL_LIST_TYPE_LOCAL;
 479         else if (is_for_thread_view == -1)
 480                 list_type = EMAIL_LIST_TYPE_THREAD;
 481         else
 482                 list_type = EMAIL_LIST_TYPE_NORMAL;
 483
 484         /* Get mail list */
 485         if (mailbox_id == 0) {
 486                 testapp_print("Calling email_get_mails for all mailbox.\n");
 487                 err_code = email_get_mails(account_id, 0, list_type, start_index, limit_count, sorting, mails_pointer, &count);
 488                 if (err_code < 0)
 489                         testapp_print("email_get_mails failed - err[%d]\n", err_code);
 490         } else {
 491                 testapp_print("Calling email_get_mails for %d mailbox_id.\n", mailbox_id);
 492                 err_code = email_get_mails(account_id, mailbox_id, list_type, start_index, limit_count, sorting,  mails_pointer, &count);
 493                 if (err_code < 0)
 494                         testapp_print("email_get_mails failed - err[%d]\n", err_code);
 495         }
 496         testapp_print("email_get_mails >>>>>>count - %d\n", count);
 497
 498         if (mails) {
 499                 for (i = 0; i < count; i++) {
 500                         testapp_print("\n[%d]\n", i);
 501                         testapp_print(" >>> mailbox_id [ %d ] \n", mails[i].mailbox_id);
 502                         testapp_print(" >>> mail_id [ %d ] \n", mails[i].mail_id);
 503                         testapp_print(" >>> account_id [ %d ] \n", mails[i].account_id);
 504                         if (mails[i].full_address_from != NULL)
 505                                 testapp_print(" >>> full_address_from [ %s ] \n", mails[i].full_address_from);
 506                         if (mails[i].full_address_to != NULL)
 507                                 testapp_print(" >>> recipients [ %s ] \n", mails[i].full_address_to);
 508                         if (mails[i].subject != NULL)
 509                                 testapp_print(" >>> subject [ %s ] \n", mails[i].subject);
 510                         testapp_print(" >>> body_download_status [ %d ] \n", mails[i].body_download_status);
 511                         temp_time_info = localtime(&mails[i].date_time);
 512                         testapp_print(" >>> date_time [ %d/%d/%d %d:%d:%d] \n",
 513                                                                         temp_time_info->tm_year + 1900,
 514                                                                         temp_time_info->tm_mon+1,
 515                                                                         temp_time_info->tm_mday,
 516                                                                         temp_time_info->tm_hour,
 517                                                                         temp_time_info->tm_min,
 518                                                                         temp_time_info->tm_sec);
 519                         testapp_print(" >>> flags_seen_field [ %d ] \n", mails[i].flags_seen_field);
 520                         testapp_print(" >>> priority [ %d ] \n", mails[i].priority);
 521                         testapp_print(" >>> save_status [ %d ] \n", mails[i].save_status);
 522                         testapp_print(" >>> lock_status [ %d ] \n", mails[i].lock_status);
 523                         testapp_print(" >>> attachment_count [ %d ] \n", mails[i].attachment_count);
 524                         if (mails[i].preview_text != NULL)
 525                                 testapp_print(" >>> preview_text [ %s ] \n", mails[i].preview_text);
 526                 }
 527                 free(mails);
 528         }
 529
 530         testapp_print(" >>> testapp_test_get_mails : End \n");
 531         return 0;
 532 }
 533
 534 #define TEMP_ARGUMENT_SIZE 4096
 535
 536 static gboolean testapp_test_mail_send(int *result_mail_id)
 537 {
 538         int                    added_mail_id = 0;
 539         int                    err = EMAIL_ERROR_NONE;
 540         int                    handle = 0;
 541         email_mail_data_t     *result_mail_data = NULL;
 542
 543         testapp_add_mail_for_sending(&added_mail_id);
 544
 545         if (added_mail_id) {
 546                 email_get_mail_data(added_mail_id, &result_mail_data);
 547
 548                 testapp_print("Calling email_send_mail...\n");
 549
 550                 if (email_send_mail(added_mail_id, &handle) < 0) {
 551                         testapp_print("Sending failed[%d]\n", err);
 552                 } else {
 553                         testapp_print("Start sending. handle[%d]\n", handle);
 554                 }
 555
 556                 email_free_mail_data(&result_mail_data, 1);
 557         }
 558
 559         if (result_mail_id)
 560                 *result_mail_id = added_mail_id;
 561
 562         return FALSE;
 563 }
 564
 565 static gboolean testapp_test_get_mail_list_ex()
 566 {
 567         email_list_filter_t *filter_list = NULL;
 568         email_list_sorting_rule_t sorting_rule_list[2];
 569         email_mail_list_item_t *result_mail_list = NULL;
 570         int filter_rule_count = 0;
 571         int sorting_rule_count = 2;
 572         int result_mail_count = 0;
 573         int err = EMAIL_ERROR_NONE;
 574         int i = 0;
 575         int sort_order = 0;
 576
 577         filter_rule_count = 3;
 578
 579         filter_list = malloc(sizeof(email_list_filter_t) * filter_rule_count);
 580         memset(filter_list, 0 , sizeof(email_list_filter_t) * filter_rule_count);
 581
 582         filter_list[0].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_RULE;
 583         filter_list[0].list_filter_item.rule.target_attribute              = EMAIL_MAIL_ATTRIBUTE_ACCOUNT_ID;
 584         filter_list[0].list_filter_item.rule.rule_type                     = EMAIL_LIST_FILTER_RULE_EQUAL;
 585         filter_list[0].list_filter_item.rule.key_value.integer_type_value  = 1;
 586         filter_list[0].list_filter_item.rule.case_sensitivity              = false;
 587
 588         filter_list[1].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_OPERATOR;
 589         filter_list[1].list_filter_item.operator_type                      = EMAIL_LIST_FILTER_OPERATOR_AND;
 590
 591         filter_list[2].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_RULE;
 592         filter_list[2].list_filter_item.rule.target_attribute              = EMAIL_MAIL_ATTRIBUTE_MAILBOX_TYPE;
 593         filter_list[2].list_filter_item.rule.rule_type                     = EMAIL_LIST_FILTER_RULE_EQUAL;
 594         filter_list[2].list_filter_item.rule.key_value.integer_type_value  = EMAIL_MAILBOX_TYPE_INBOX;
 595         filter_list[2].list_filter_item.rule.case_sensitivity              = false;
 596
 597         /*filter_list[0].list_filter_item_type                                     = EMAIL_LIST_FILTER_ITEM_RULE_ATTACH;
 598         filter_list[0].list_filter_item.rule_attach.target_attribute             = EMAIL_MAIL_ATTACH_ATTRIBUTE_ATTACHMENT_NAME;
 599         filter_list[0].list_filter_item.rule_attach.rule_type                    = EMAIL_LIST_FILTER_RULE_INCLUDE;
 600         filter_list[0].list_filter_item.rule_attach.key_value.string_type_value  = strdup("test");
 601         filter_list[0].list_filter_item.rule_attach.case_sensitivity             = false;*/
 602
 603         /*
 604         filter_list[0].list_filter_item_type                                  = EMAIL_LIST_FILTER_ITEM_RULE;
 605         filter_list[0].list_filter_item.rule_fts.target_attribute             = EMAIL_MAIL_ATTRIBUTE_ACCOUNT_ID;
 606         filter_list[0].list_filter_item.rule_fts.rule_type                    = EMAIL_LIST_FILTER_RULE_EQUAL;
 607         filter_list[0].list_filter_item.rule_fts.key_value.integer_type_value = 1;
 608
 609         filter_list[1].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_OPERATOR;
 610         filter_list[1].list_filter_item.operator_type                      = EMAIL_LIST_FILTER_OPERATOR_OR;
 611
 612
 613         filter_list[2].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_RULE;
 614         filter_list[2].list_filter_item.rule.target_attribute              = EMAIL_MAIL_ATTRIBUTE_SUBJECT;
 615         filter_list[2].list_filter_item.rule.rule_type                     = EMAIL_LIST_FILTER_RULE_INCLUDE;
 616         filter_list[2].list_filter_item.rule.key_value.string_type_value   = strdup("2013");
 617         filter_list[2].list_filter_item.rule.case_sensitivity              = false;
 618
 619
 620         filter_list[1].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_OPERATOR;
 621         filter_list[1].list_filter_item.operator_type                      = EMAIL_LIST_FILTER_OPERATOR_OR;
 622
 623         filter_list[2].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_RULE;
 624         filter_list[2].list_filter_item.rule.target_attribute              = EMAIL_MAIL_ATTRIBUTE_TO;
 625         filter_list[2].list_filter_item.rule.rule_type                     = EMAIL_LIST_FILTER_RULE_INCLUDE;
 626         filter_list[2].list_filter_item.rule.key_value.string_type_value   = strdup("RE");
 627         filter_list[2].list_filter_item.rule.case_sensitivity              = false;
 628
 629         filter_list[3].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_OPERATOR;
 630         filter_list[3].list_filter_item.operator_type                      = EMAIL_LIST_FILTER_OPERATOR_OR;
 631
 632         filter_list[4].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_RULE;
 633         filter_list[4].list_filter_item.rule.target_attribute              = EMAIL_MAIL_ATTRIBUTE_CC;
 634         filter_list[4].list_filter_item.rule.rule_type                     = EMAIL_LIST_FILTER_RULE_INCLUDE;
 635         filter_list[4].list_filter_item.rule.key_value.string_type_value   = strdup("RE");
 636         filter_list[4].list_filter_item.rule.case_sensitivity              = false;
 637
 638         filter_list[5].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_OPERATOR;
 639         filter_list[5].list_filter_item.operator_type                      = EMAIL_LIST_FILTER_OPERATOR_OR;
 640
 641         filter_list[6].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_RULE;
 642         filter_list[6].list_filter_item.rule.target_attribute              = EMAIL_MAIL_ATTRIBUTE_BCC;
 643         filter_list[6].list_filter_item.rule.rule_type                     = EMAIL_LIST_FILTER_RULE_INCLUDE;
 644         filter_list[6].list_filter_item.rule.key_value.string_type_value   = strdup("RE");
 645         filter_list[6].list_filter_item.rule.case_sensitivity              = false;
 646
 647         filter_list[7].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_OPERATOR;
 648         filter_list[7].list_filter_item.operator_type                      = EMAIL_LIST_FILTER_OPERATOR_OR;
 649
 650         filter_list[8].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_RULE;
 651         filter_list[8].list_filter_item.rule.target_attribute              = EMAIL_MAIL_ATTRIBUTE_FROM;
 652         filter_list[8].list_filter_item.rule.rule_type                     = EMAIL_LIST_FILTER_RULE_INCLUDE;
 653         filter_list[8].list_filter_item.rule.key_value.string_type_value   = strdup("RE");
 654         filter_list[8].list_filter_item.rule.case_sensitivity              = false;
 655         */
 656
 657         /*
 658         filter_list[0].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_RULE;
 659         filter_list[0].list_filter_item.rule.target_attribute              = EMAIL_MAIL_ATTRIBUTE_ACCOUNT_ID;
 660         filter_list[0].list_filter_item.rule.rule_type                     = EMAIL_LIST_FILTER_RULE_EQUAL;
 661         filter_list[0].list_filter_item.rule.key_value.integer_type_value  = 1;
 662
 663         filter_list[1].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_OPERATOR;
 664         filter_list[1].list_filter_item.operator_type                      = EMAIL_LIST_FILTER_OPERATOR_AND;
 665
 666         filter_list[2].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_RULE;
 667         filter_list[2].list_filter_item.rule.target_attribute              = EMAIL_MAIL_ATTRIBUTE_MAILBOX_NAME;
 668         filter_list[2].list_filter_item.rule.rule_type                     = EMAIL_LIST_FILTER_RULE_EQUAL;
 669         filter_list[2].list_filter_item.rule.key_value.string_type_value   = strdup("INBOX");
 670         filter_list[2].list_filter_item.rule.case_sensitivity              = true;
 671         */
 672
 673         memset(sorting_rule_list, 0 , sizeof(email_list_sorting_rule_t) * sorting_rule_count);
 674 /*
 675         sorting_rule_list[0].target_attribute                              = EMAIL_MAIL_ATTRIBUTE_RECIPIENT_ADDRESS;
 676         sorting_rule_list[0].key_value.string_type_value                   = strdup("minsoo.kimn@gmail.com");
 677         sorting_rule_list[0].sort_order                                    = EMAIL_SORT_ORDER_TO_CCBCC;
 678 */
 679         testapp_print("\n Enter the sort_order :");
 680         if (0 >= scanf("%d", &sort_order))
 681                 testapp_print("Invalid input.");
 682
 683         sorting_rule_list[0].target_attribute                              = EMAIL_MAIL_ATTRIBUTE_SUBJECT;
 684         sorting_rule_list[0].sort_order                                    = sort_order;
 685
 686         sorting_rule_list[1].target_attribute                              = EMAIL_MAIL_ATTRIBUTE_DATE_TIME;
 687         sorting_rule_list[1].sort_order                                    = EMAIL_SORT_ORDER_DESCEND;
 688
 689         err = email_get_mail_list_ex(filter_list, filter_rule_count, sorting_rule_list, sorting_rule_count, -1, -1, &result_mail_list, &result_mail_count);
 690
 691         if (err == EMAIL_ERROR_NONE) {
 692                 testapp_print("email_get_mail_list_ex succeed.\n");
 693
 694                 for (i = 0; i < result_mail_count; i++) {
 695                         testapp_print("mail_id [%d], subject [%s], mailbox_type [%d] full_address_from [%s]\n", result_mail_list[i].mail_id, result_mail_list[i].subject, result_mail_list[i].mailbox_type, result_mail_list[i].full_address_from);
 696                 }
 697         } else {
 698                 testapp_print("email_get_mail_list_ex failed.\n");
 699         }
 700
 701         email_free_list_filter(&filter_list, 3);
 702
 703         return FALSE;
 704 }
 705
 706 static gboolean testapp_test_send_cancel()
 707 {
 708         int num = 0;
 709         int Y = 0;
 710         int i = 0;
 711         int j = 0;
 712         int *mailIdList = NULL;
 713         int mail_id = 0;
 714
 715         testapp_print("\n > Enter total Number of mail  want to send: ");
 716         if (0 >= scanf("%d", &num))
 717                 testapp_print("Invalid input. ");
 718         mailIdList = (int *)malloc(sizeof(int)*num);
 719         if (!mailIdList)
 720                 return false ;
 721
 722         for (i = 1; i <= num; i++) {
 723                 testapp_test_mail_send(&mail_id);
 724
 725                 testapp_print("mail_id[%d]", mail_id);
 726
 727                 mailIdList[i] = mail_id;
 728                 testapp_print("mailIdList[%d][%d]", i, mailIdList[i]);
 729
 730                 mail_id = 0;
 731                 testapp_print("\n > Do you want to cancel the send mail job '1' or '0': ");
 732                 if (0 >= scanf("%d", &Y))
 733                         testapp_print("Invalid input. ");
 734                 if (Y == 1) {
 735                         testapp_print("\n >Enter mail-id[1-%d] ", i);
 736                         if (0 >= scanf("%d", &j))
 737                                 testapp_print("Invalid input. ");
 738                         testapp_print("\n mailIdList[%d] ", mailIdList[j]);
 739                         if (email_cancel_sending_mail(mailIdList[j]) < 0)
 740                                 testapp_print("email_cancel_sending_mail failed..!");
 741                         else
 742                                 testapp_print("email_cancel_sending_mail success..!");
 743                 }
 744         }
 745         free(mailIdList);
 746         return FALSE;
 747 }
 748
 749 static gboolean testapp_test_delete()
 750 {
 751         int mail_id = 0, account_id = 0;
 752         int mailbox_id = 0;
 753         int err = EMAIL_ERROR_NONE;
 754         int from_server = 0;
 755
 756         testapp_print("\n > Enter Account_id: ");
 757         if (0 >= scanf("%d", &account_id))
 758                 testapp_print("Invalid input. ");
 759
 760         testapp_print("\n > Enter Mail_id: ");
 761         if (0 >= scanf("%d", &mail_id))
 762                 testapp_print("Invalid input. ");
 763
 764         testapp_print("\n > Enter Mailbox id: ");
 765         if (0 >= scanf("%d", &mailbox_id))
 766                 testapp_print("Invalid input. ");
 767
 768         testapp_print("\n > Enter from_server: ");
 769         if (0 >= scanf("%d", &from_server))
 770                 testapp_print("Invalid input. ");
 771
 772         /* delete message */
 773         if ((err = email_delete_mail(mailbox_id, &mail_id, 1, from_server)) < 0)
 774                 testapp_print("\n email_delete_mail failed[%d]\n", err);
 775         else
 776                 testapp_print("\n email_delete_mail success\n");
 777
 778         return FALSE;
 779 }
 780
 781 static gboolean testapp_test_update_mail_attribute()
 782 {
 783         int  err = EMAIL_ERROR_NONE;
 784         int  i = 0;
 785         int  account_id = 0;
 786         int *mail_id_array = NULL;
 787         int  mail_id_count = 0;
 788         email_mail_attribute_type attribute_type;
 789         email_mail_attribute_value_t attribute_value;
 790
 791         testapp_print("\n > Enter account_id: ");
 792         if (0 >= scanf("%d", &account_id))
 793                 testapp_print("Invalid input. ");
 794
 795         testapp_print("\n > Enter attribute_type: ");
 796         if (0 >= scanf("%d", (int*)&attribute_type))
 797                 testapp_print("Invalid input. ");
 798
 799         testapp_print("\n > Enter integer type value: ");
 800         if (0 >= scanf("%d", (int*)&(attribute_value.integer_type_value)))
 801                 testapp_print("Invalid input. ");
 802
 803         testapp_print("\n > Enter mail_id_count: ");
 804         if (0 >= scanf("%d", &mail_id_count))
 805                 testapp_print("Invalid input. ");
 806
 807         mail_id_count = (mail_id_count < 5000) ? mail_id_count : 5000;
 808
 809         if (mail_id_count > 0) {
 810                 mail_id_array = malloc(sizeof(int) * mail_id_count);
 811         }
 812
 813         for (i = 0; i < mail_id_count; i++) {
 814                 testapp_print("\n > Enter mail id: ");
 815                 if (0 >= scanf("%d", (mail_id_array + i)))
 816                         testapp_print("Invalid input. ");
 817         }
 818
 819         /* delete message */
 820         if ((err = email_update_mail_attribute(account_id, mail_id_array, mail_id_count, attribute_type, attribute_value)) < EMAIL_ERROR_NONE)
 821                 testapp_print("\n email_update_mail_attribute failed[%d]\n", err);
 822         else
 823                 testapp_print("\n email_update_mail_attribute success\n");
 824
 825         if (mail_id_array)
 826                 free(mail_id_array);
 827
 828         return FALSE;
 829 }
 830
 831 static gboolean testapp_test_move()
 832 {
 833         int mail_id[3];
 834         int i = 0;
 835         int mailbox_id = 0;
 836
 837         for (i = 0; i < 3; i++) {
 838                 testapp_print("\n > Enter mail_id: ");
 839                 if (0 >= scanf("%d", &mail_id[i]))
 840                         testapp_print("Invalid input. ");
 841         }
 842
 843         testapp_print("\n > Enter mailbox_id: ");
 844         if (0 >= scanf("%d", &mailbox_id))
 845                 testapp_print("Invalid input. ");
 846
 847         /* move mail */
 848         email_move_mail_to_mailbox(mail_id, 3, mailbox_id);
 849         return FALSE;
 850 }
 851
 852 static gboolean testapp_test_delete_all()
 853 {
 854         int mailbox_id = 0;
 855         int err = EMAIL_ERROR_NONE;
 856
 857         testapp_print("\n > Enter mailbox_id: ");
 858         if (0 >= scanf("%d", &mailbox_id))
 859                 testapp_print("Invalid input. ");
 860
 861         /* delete all message */
 862         if ((err = email_delete_all_mails_in_mailbox(mailbox_id, 0)) < 0)
 863                 testapp_print("email_delete_all_mails_in_mailbox failed [%d]\n", err);
 864         else
 865                 testapp_print("email_delete_all_mails_in_mailbox Success\n");
 866
 867         return FALSE;
 868 }
 869
 870
 871 static gboolean testapp_test_add_attachment()
 872 {
 873         int mail_id = 0;
 874         char arg[100];
 875         email_attachment_data_t attachment;
 876
 877         testapp_print("\n > Enter Mail Id: ");
 878         if (0 >= scanf("%d", &mail_id))
 879                 testapp_print("Invalid input. ");
 880
 881         memset(&attachment, 0x00, sizeof(email_attachment_data_t));
 882         memset(arg, 0x00, 100);
 883         testapp_print("\n > Enter attachment name: ");
 884         if (0 >= scanf("%s", arg))
 885                 testapp_print("Invalid input. ");
 886
 887         attachment.attachment_name = strdup(arg);
 888
 889         memset(arg, 0x00, 100);
 890         testapp_print("\n > Enter attachment absolute path: ");
 891         if (0 >= scanf("%s", arg))
 892                 testapp_print("Invalid input. ");
 893
 894         attachment.save_status = true;
 895         attachment.attachment_path = strdup(arg);
 896         if (email_add_attachment(mail_id, &attachment) < 0)
 897                 testapp_print("email_add_attachment failed\n");
 898         else
 899                 testapp_print("email_add_attachment success\n");
 900
 901
 902         return FALSE;
 903
 904 }
 905
 906 static gboolean testapp_test_set_deleted_flag()
 907 {
 908         int index = 0;
 909         int account_id = 0;
 910         int mail_ids[100] = { 0, };
 911         int temp_mail_id = 0;
 912         int err_code = EMAIL_ERROR_NONE;
 913
 914         testapp_print("\n >>> Input target account id: ");
 915         if (0 >= scanf("%d", &account_id))
 916                 testapp_print("Invalid input. ");
 917
 918         do {
 919                 testapp_print("\n >>> Input target mail id( Input 0 to terminate ) [MAX = 100]: ");
 920                 if (0 >= scanf("%d", &temp_mail_id))
 921                         testapp_print("Invalid input. ");
 922                 mail_ids[index++] = temp_mail_id;
 923         } while (temp_mail_id != 0);
 924
 925         err_code = email_set_flags_field(account_id, mail_ids, index, EMAIL_FLAGS_DELETED_FIELD, 1, true);
 926         testapp_print("email_set_flags_field returns - err[%d]\n", err_code);
 927
 928         return 0;
 929 }
 930
 931 static gboolean testapp_test_expunge_mails_deleted_flagged()
 932 {
 933         int mailbox_id = 0;
 934         int on_server = 0;
 935         int err_code = EMAIL_ERROR_NONE;
 936         int handle = 0;
 937
 938         testapp_print("\n >>> Input target mailbox id: ");
 939         if (0 >= scanf("%d", &mailbox_id))
 940                 testapp_print("Invalid input. ");
 941
 942         testapp_print("\n >>> Expunge on server?: ");
 943         if (0 >= scanf("%d", &on_server))
 944                 testapp_print("Invalid input. ");
 945
 946         err_code = email_expunge_mails_deleted_flagged(mailbox_id, on_server, &handle);
 947
 948         testapp_print("email_expunge_mails_deleted_flagged returns - err[%d]\n", err_code);
 949
 950         return 0;
 951 }
 952
 953 static gboolean testapp_test_send_read_receipt()
 954 {
 955         int read_mail_id = 0;
 956         int receipt_mail_id = 0;
 957         int err_code = EMAIL_ERROR_NONE;
 958         int handle = 0;
 959
 960         testapp_print("\n >>> Input read mail id: ");
 961         if (0 >= scanf("%d", &read_mail_id))
 962                 testapp_print("Invalid input. ");
 963
 964         err_code = email_add_read_receipt(read_mail_id, &receipt_mail_id);
 965
 966         testapp_print("eamil_add_read_receipt returns receipt_mail_id [%d] - err[%d]\n", receipt_mail_id, err_code);
 967         testapp_print("Calling email_send_mail...\n");
 968
 969         if ((err_code = email_send_mail(receipt_mail_id, &handle)) != EMAIL_ERROR_NONE) {
 970                 testapp_print("Sending failed[%d]\n", err_code);
 971         } else {
 972                 testapp_print("Start sending. handle[%d]\n", handle);
 973         }
 974
 975         return 0;
 976 }
 977
 978 static gboolean testapp_test_delete_attachment()
 979 {
 980         int attachment_id = 0;
 981         int err_code = EMAIL_ERROR_NONE;
 982
 983         testapp_print("\n >>> Input attachment id: ");
 984         if (0 >= scanf("%d", &attachment_id))
 985                 testapp_print("Invalid input. ");
 986
 987         if ((err_code = email_delete_attachment(attachment_id)) != EMAIL_ERROR_NONE) {
 988                 testapp_print("email_delete_attachment failed[%d]\n", err_code);
 989         }
 990
 991         return 0;
 992 }
 993
 994 static gboolean testapp_test_get_mail_list()
 995 {
 996         testapp_print("\n >>> testapp_test_get_mail_list : Entered \n");
 997         email_mail_list_item_t *mail_list = NULL, **mail_list_pointer = NULL;
 998         int mailbox_id = 0;
 999         int count = 0, i = 0;
1000         int account_id = 0;
1001         int start_index = 0;
1002         int limit_count = 0;
1003         int sorting = 0;
1004         int err_code = EMAIL_ERROR_NONE;
1005         int to_get_count = 0;
1006         int is_for_thread_view = 0;
1007         int list_type;
1008         struct tm *temp_time_info;
1009
1010         testapp_print("\n > Enter Account_id(0 = all accounts) : ");
1011         if (0 >= scanf("%d", &account_id))
1012                 testapp_print("Invalid input. ");
1013
1014         testapp_print("\n > Enter Mailbox id(0 = all mailboxes) :");
1015         if (0 >= scanf("%d", &mailbox_id))
1016                 testapp_print("Invalid input. ");
1017
1018         testapp_print("\n > Enter Sorting : ");
1019         if (0 >= scanf("%d", &sorting))
1020                 testapp_print("Invalid input. ");
1021
1022         testapp_print("\n > Enter Start index(starting at 0): ");
1023         if (0 >= scanf("%d", &start_index))
1024                 testapp_print("Invalid input. ");
1025
1026         testapp_print("\n > Enter max_count : ");
1027         if (0 >= scanf("%d", &limit_count))
1028                 testapp_print("Invalid input. ");
1029
1030         testapp_print("\n > For thread view : ");
1031         if (0 >= scanf("%d", &is_for_thread_view))
1032                 testapp_print("Invalid input. ");
1033
1034         testapp_print("\n > Count mails?(1: YES):");
1035         if (0 >= scanf("%d", &to_get_count))
1036                 testapp_print("Invalid input. ");
1037
1038         if (to_get_count)
1039                 mail_list_pointer = NULL;
1040         else
1041                 mail_list_pointer = &mail_list;
1042
1043         if (is_for_thread_view == -2) {
1044                 list_type = EMAIL_LIST_TYPE_LOCAL;
1045         } else if (is_for_thread_view == -1)
1046                 list_type = EMAIL_LIST_TYPE_THREAD;
1047         else
1048                 list_type = EMAIL_LIST_TYPE_NORMAL;
1049
1050         /* Get mail list */
1051         if (mailbox_id == 0) {
1052                 testapp_print("Calling email_get_mail_list for all mailbox.\n");
1053                 err_code = email_get_mail_list(account_id, 0, list_type, start_index, limit_count, sorting,  mail_list_pointer, &count);
1054                 if (err_code < 0)
1055                         testapp_print("email_get_mail_list failed - err[%d]\n", err_code);
1056         } else {
1057                 testapp_print("Calling email_get_mail_list for %d mailbox_id.\n", mailbox_id);
1058                 err_code = email_get_mail_list(account_id, mailbox_id, list_type, start_index, limit_count, sorting,  mail_list_pointer, &count);
1059                 if (err_code < 0)
1060                         testapp_print("email_get_mail_list failed - err[%d]\n", err_code);
1061         }
1062         testapp_print("email_get_mail_list >>>>>>count - %d\n", count);
1063
1064         if (mail_list) {
1065                 for (i = 0; i < count; i++) {
1066                         testapp_print("\n[%d]\n", i);
1067                         testapp_print(" >>> mailbox_id [ %d ] \n", mail_list[i].mailbox_id);
1068                         testapp_print(" >>> mailbox_type [ %d ] \n", mail_list[i].mailbox_type);
1069                         testapp_print(" >>> mail_id [ %d ] \n", mail_list[i].mail_id);
1070                         testapp_print(" >>> account_id [ %d ] \n", mail_list[i].account_id);
1071                         if (mail_list[i].full_address_from != NULL)
1072                                 testapp_print(" >>> full_address_from [ %s ] \n", mail_list[i].full_address_from);
1073                         if (mail_list[i].email_address_recipient != NULL)
1074                                 testapp_print(" >>> email_address_recipient [ %s ] \n", mail_list[i].email_address_recipient);
1075                         if (mail_list[i].subject != NULL)
1076                                 testapp_print(" >>> subject [ %s ] \n", mail_list[i].subject);
1077                         testapp_print(" >>> body_download_status [ %d ] \n", mail_list[i].body_download_status);
1078                         temp_time_info = localtime(&mail_list[i].date_time);
1079                         testapp_print(" >>> date_time [ %d/%d/%d %d:%d:%d] \n",
1080                                         temp_time_info->tm_year + 1900,
1081                                         temp_time_info->tm_mon+1,
1082                                         temp_time_info->tm_mday,
1083                                         temp_time_info->tm_hour,
1084                                         temp_time_info->tm_min,
1085                                         temp_time_info->tm_sec);
1086                         testapp_print(" >>> flags_seen_field [ %d ] \n", mail_list[i].flags_seen_field);
1087                         testapp_print(" >>> priority [ %d ] \n", mail_list[i].priority);
1088                         testapp_print(" >>> save_status [ %d ] \n", mail_list[i].save_status);
1089                         testapp_print(" >>> lock_status [ %d ] \n", mail_list[i].lock_status);
1090                         testapp_print(" >>> attachment_count [ %d ] \n", mail_list[i].attachment_count);
1091                         if (!*mail_list[i].preview_text)
1092                                 testapp_print(" >>> preview_text [ %s ] \n", mail_list[i].preview_text);
1093                 }
1094                 free(mail_list);
1095         }
1096
1097         testapp_print("\n >>> email_get_mail_list : End \n");
1098         return 0;
1099 }
1100
1101
1102 static gboolean testapp_test_get_mail_list_for_thread_view()
1103 {
1104         testapp_print(" >>> testapp_test_get_mail_list_for_thread_view : Entered \n");
1105         email_mail_list_item_t *mail_list = NULL;
1106         int count = 0, i = 0;
1107         int account_id = 0;
1108         int mailbox_id = 0;
1109         int err_code = EMAIL_ERROR_NONE;
1110         struct tm *time_info;
1111         char buf[26] = {0};
1112
1113         testapp_print("\nEnter account id\n");
1114         if (0 >= scanf("%d", &account_id))
1115                 testapp_print("Invalid input. ");
1116
1117         testapp_print("\nEnter mailbox id\n");
1118         if (0 >= scanf("%d", &mailbox_id))
1119                 testapp_print("Invalid input. ");
1120
1121         /* Get mail list */
1122         if (email_get_mail_list(account_id, mailbox_id , EMAIL_LIST_TYPE_THREAD, 0, 500, EMAIL_SORT_DATETIME_HIGH, &mail_list, &count) < 0)  {
1123                 testapp_print("email_get_mail_list failed : %d\n", err_code);
1124                 return FALSE;
1125         }
1126         testapp_print("email_get_mail_list >>>>>>count - %d\n", count);
1127         if (mail_list) {
1128                 for (i = 0; i < count; i++) {
1129                         testapp_print(" i [%d]\n", i);
1130                         testapp_print(" >>> mail_id [ %d ] \n", mail_list[i].mail_id);
1131                         testapp_print(" >>> account_id [ %d ] \n", mail_list[i].account_id);
1132                         testapp_print(" >>> mailbox_id [ %d ] \n", mail_list[i].mailbox_id);
1133                         testapp_print(" >>> full_address_from [ %s ] \n", mail_list[i].full_address_from);
1134                         testapp_print(" >>> email_address_recipient [ %s ] \n", mail_list[i].email_address_recipient);
1135                         testapp_print(" >>> subject [ %s ] \n", mail_list[i].subject);
1136                         testapp_print(" >>> body_download_status [ %d ] \n", mail_list[i].body_download_status);
1137                         time_info = localtime(&mail_list[i].date_time);
1138                         testapp_print(" >>> date_time [ %s ] \n", asctime_r(time_info, buf));
1139                         testapp_print(" >>> flags_seen_field [ %d ] \n", mail_list[i].flags_seen_field);
1140                         testapp_print(" >>> priority [ %d ] \n", mail_list[i].priority);
1141                         testapp_print(" >>> save_status [ %d ] \n", mail_list[i].save_status);
1142                         testapp_print(" >>> lock [ %d ] \n", mail_list[i].lock_status);
1143                         testapp_print(" >>> attachment_count [ %d ] \n", mail_list[i].attachment_count);
1144                         testapp_print(" >>> preview_text [ %s ] \n", mail_list[i].preview_text);
1145                         testapp_print(" >>> thread_id [ %d ] \n", mail_list[i].thread_id);
1146                         testapp_print(" >>> thread__item_count [ %d ] \n", mail_list[i].thread_item_count);
1147                 }
1148                 free(mail_list);
1149         }
1150         testapp_print(" >>> testapp_test_get_mail_list_for_thread_view : End \n");
1151         return 0;
1152 }
1153
1154 static gboolean testapp_test_count()
1155 {
1156         int total = 0;
1157         int unseen = 0;
1158         email_list_filter_t *filter_list = NULL;
1159
1160         filter_list = malloc(sizeof(email_list_filter_t) * 3);
1161         memset(filter_list, 0 , sizeof(email_list_filter_t) * 3);
1162
1163         filter_list[0].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_RULE;
1164         filter_list[0].list_filter_item.rule.target_attribute              = EMAIL_MAIL_ATTRIBUTE_SUBJECT;
1165         filter_list[0].list_filter_item.rule.rule_type                     = EMAIL_LIST_FILTER_RULE_INCLUDE;
1166         filter_list[0].list_filter_item.rule.key_value.string_type_value   = strdup("RE");
1167         filter_list[0].list_filter_item.rule.case_sensitivity              = false;
1168
1169         filter_list[1].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_OPERATOR;
1170         filter_list[1].list_filter_item.operator_type                      = EMAIL_LIST_FILTER_OPERATOR_OR;
1171
1172         filter_list[2].list_filter_item_type                               = EMAIL_LIST_FILTER_ITEM_RULE;
1173         filter_list[2].list_filter_item.rule.target_attribute              = EMAIL_MAIL_ATTRIBUTE_TO;
1174         filter_list[2].list_filter_item.rule.rule_type                     = EMAIL_LIST_FILTER_RULE_INCLUDE;
1175         filter_list[2].list_filter_item.rule.key_value.string_type_value   = strdup("RE");
1176         filter_list[2].list_filter_item.rule.case_sensitivity              = false;
1177
1178         if (EMAIL_ERROR_NONE == email_count_mail(filter_list, 3, &total, &unseen))
1179                 printf("\n Total: %d, Unseen: %d \n", total, unseen);
1180         free(filter_list);
1181         return 0;
1182 }
1183
1184 static gboolean testapp_test_move_mails_to_mailbox_of_another_account()
1185 {
1186         int  err = EMAIL_ERROR_NONE;
1187         int  mail_id_count = 0 ;
1188         int *mail_id_array = NULL;
1189         int  source_mailbox_id = 0;
1190         int  target_mailbox_id = 0;
1191         int  task_id = 0;
1192         int  i = 0;
1193
1194         testapp_print("\n > Enter source mailbox id: ");
1195         if (0 >= scanf("%d", &source_mailbox_id))
1196                 testapp_print("Invalid input. ");
1197
1198         testapp_print("\n > Enter target mailbox id: ");
1199         if (0 >= scanf("%d", &target_mailbox_id))
1200                 testapp_print("Invalid input. ");
1201
1202         testapp_print("\n > Enter mail count: ");
1203         if (0 >= scanf("%d", &mail_id_count))
1204                 testapp_print("Invalid input. ");
1205
1206         mail_id_count = (mail_id_count < 5000) ? mail_id_count : 5000;
1207
1208         if (mail_id_count > 0) {
1209                 mail_id_array = malloc(sizeof(int) * mail_id_count);
1210         }
1211
1212         for (i = 0; i < mail_id_count; i++) {
1213                 testapp_print("\n > Enter mail id: ");
1214                 if (0 >= scanf("%d", (mail_id_array + i)))
1215                         testapp_print("Invalid input. ");
1216         }
1217
1218         err = email_move_mails_to_mailbox_of_another_account(source_mailbox_id, mail_id_array, mail_id_count, target_mailbox_id, &task_id);
1219
1220         testapp_print("\nemail_move_mails_to_mailbox_of_another_account returns [%d], tast_id [%d] \n", err, task_id);
1221         return 0;
1222 }
1223
1224 static gboolean copy_file(char *input_source_path, char *input_dest_path)
1225 {
1226         int childExitStatus;
1227         pid_t pid;
1228         if (!input_source_path || !input_dest_path) {
1229                 return FALSE;
1230         }
1231         testapp_print("copy_file started\n");
1232
1233         pid = fork();
1234
1235         if (pid == 0) {
1236                 testapp_print("Copying file [%s] [%s]\n", input_source_path, input_dest_path);
1237                 execl("/bin/cp", "/bin/cp", input_source_path, input_dest_path, (char *)0);
1238         } else {
1239                 testapp_print("Wating child process\n");
1240                 pid_t ws = waitpid(pid, &childExitStatus, WNOHANG);
1241                 if (ws == -1) { /* error - handle as you wish */
1242                         testapp_print("waitpid returns error\n");
1243                 }
1244
1245                 if (WIFEXITED(childExitStatus)) {
1246                         /* exit code in childExitStatus */
1247                         WEXITSTATUS(childExitStatus); /* zero is normal exit */
1248                         testapp_print("WEXITSTATUS\n");
1249                         /* handle non-zero as you wish */
1250                 } else if (WIFSIGNALED(childExitStatus)) { /* killed */
1251                         testapp_print("WIFSIGNALED\n");
1252                 } else if (WIFSTOPPED(childExitStatus)) { /* stopped */
1253                         testapp_print("WIFSTOPPED\n");
1254                 }
1255         }
1256         testapp_print("copy_file finished\n");
1257         return TRUE;
1258 }
1259
1260
1261 static gboolean testapp_test_send_mail_with_downloading_attachment_of_original_mail()
1262 {
1263         int err = EMAIL_ERROR_NONE;
1264         int original_mail_id = 0;
1265         int original_attachment_count = 0;
1266         int i = 0;
1267         int handle = 0;
1268         char *plain_text_path = MAIL_TEMP_BODY;
1269         char *html_file_path = HTML_TEMP_BODY;
1270         char new_subject[4086] = { 0, };
1271 /*      FILE *body_file; */
1272         email_mail_data_t *original_mail_data = NULL;
1273         email_mailbox_t *outbox = NULL;
1274         email_attachment_data_t *original_attachment_array = NULL;
1275
1276         testapp_print("\n > Enter original mail id: ");
1277         if (0 >= scanf("%d", &original_mail_id))
1278                 testapp_print("Invalid input. ");
1279
1280         /* Get original mail */
1281         if ((err = email_get_mail_data(original_mail_id, &original_mail_data)) != EMAIL_ERROR_NONE || !original_mail_data) {
1282                 testapp_print("email_get_mail_data failed [%d]\n", err);
1283                 return FALSE;
1284         }
1285
1286         /* Get attachment of original mail */
1287         if ((err = email_get_attachment_data_list(original_mail_id, &original_attachment_array, &original_attachment_count)) != EMAIL_ERROR_NONE || !original_attachment_array) {
1288                 testapp_print("email_get_attachment_data_list failed [%d]\n", err);
1289                 return FALSE;
1290         }
1291
1292         /* Remove attachment file path */
1293         for (i = 0; i < original_attachment_count; i++) {
1294                 original_attachment_array[i].save_status = 0;
1295                 if (original_attachment_array[i].attachment_path)
1296                         free(original_attachment_array[i].attachment_path);
1297                 original_attachment_array[i].attachment_path = NULL;
1298         }
1299
1300         /* Set reference mail id */
1301         original_mail_data->reference_mail_id = original_mail_data->mail_id;
1302         original_mail_data->body_download_status = 1;
1303
1304         /* Set from address */
1305         if (!original_mail_data->full_address_from) {
1306                 original_mail_data->full_address_from = strdup("<abc@abc.com>");
1307         }
1308
1309         /* Rewrite subject */
1310         if (original_mail_data->subject) {
1311                 snprintf(new_subject, 4086, "Fw:%s", original_mail_data->subject);
1312                 free(original_mail_data->subject);
1313                 original_mail_data->subject = NULL;
1314         } else {
1315                 snprintf(new_subject, 4086, "Forward test");
1316         }
1317
1318         original_mail_data->subject = strdup(new_subject);
1319
1320         /* Set mailbox information */
1321         if ((err = email_get_mailbox_by_mailbox_type(original_mail_data->account_id, EMAIL_MAILBOX_TYPE_OUTBOX, &outbox)) != EMAIL_ERROR_NONE || !outbox) {
1322                 testapp_print("email_get_mailbox_by_mailbox_type failed [%d]\n", err);
1323                 return FALSE;
1324         }
1325         original_mail_data->mailbox_id = outbox->mailbox_id;
1326         original_mail_data->mailbox_type = outbox->mailbox_type;
1327
1328         /* Copy body text */
1329         if (original_mail_data->file_path_html) {
1330                 copy_file(original_mail_data->file_path_html, html_file_path);
1331                 /*execl("/bin/cp", "/bin/cp", original_mail_data->file_path_html, html_file_path,(char *)0); */
1332                 free(original_mail_data->file_path_html);
1333                 original_mail_data->file_path_html = strdup(html_file_path);
1334         }
1335
1336         if (original_mail_data->file_path_plain) {
1337                 copy_file(original_mail_data->file_path_plain, plain_text_path);
1338                 /*execl("/bin/cp", "/bin/cp", original_mail_data->file_path_plain, plain_text_path,(char *)0);*/
1339                 free(original_mail_data->file_path_plain);
1340                 original_mail_data->file_path_plain = strdup(plain_text_path);
1341         }
1342
1343
1344         /*
1345         body_file = fopen(body_file_path, "w");
1346
1347         testapp_print("\n body_file [%p]\n", body_file);
1348
1349         if (body_file == NULL) {
1350                 testapp_print("\n fopen [%s]failed\n", body_file_path);
1351                 return FALSE;
1352         }
1353
1354         for (i = 0; i < 100; i++)
1355                 fprintf(body_file, "Mail sending Test. [%d]\n", i);
1356
1357         fflush(body_file);
1358         fclose(body_file);
1359         */
1360
1361         /* Add mail */
1362         if ((err = email_add_mail(original_mail_data, original_attachment_array, original_attachment_count, NULL, false)) != EMAIL_ERROR_NONE) {
1363                 testapp_print("email_get_attachment_data_list failed [%d]\n", err);
1364                 email_free_mailbox(&outbox, 1);
1365                 return FALSE;
1366         }
1367
1368         /* Send mail */
1369         if ((err = email_send_mail_with_downloading_attachment_of_original_mail(original_mail_data->mail_id, &handle)) != EMAIL_ERROR_NONE) {
1370                 testapp_print("email_send_mail_with_downloading_attachment_of_original_mail failed [%d]\n", err);
1371                 email_free_mailbox(&outbox, 1);
1372                 return FALSE;
1373         }
1374
1375         if (original_mail_data)
1376                 email_free_mail_data(&original_mail_data, 1);
1377
1378         if (outbox)
1379                 email_free_mailbox(&outbox, 1);
1380
1381         if (original_attachment_array)
1382                 email_free_attachment_data(&original_attachment_array, original_attachment_count);
1383
1384         return TRUE;
1385 }
1386
1387 static gboolean testapp_test_get_mail_data()
1388 {
1389         int err = EMAIL_ERROR_NONE;
1390         int mail_id = 0;
1391         email_mail_data_t *mail_data = NULL;
1392
1393         testapp_print("\n > Enter mail id: ");
1394         if (0 >= scanf("%d", &mail_id))
1395                 testapp_print("Invalid input. ");
1396
1397         /* Get original mail */
1398         if ((err = email_get_mail_data(mail_id, &mail_data)) != EMAIL_ERROR_NONE || !mail_data) {
1399                 testapp_print("email_get_mail_data failed [%d]\n", err);
1400                 return FALSE;
1401         }
1402
1403         testapp_print("mail_id [%d]\n", mail_data->mail_id);
1404         testapp_print("account_id [%d]\n", mail_data->account_id);
1405         testapp_print("mailbox_id [%d]\n", mail_data->mailbox_id);
1406         testapp_print("mailbox_type [%d]\n", mail_data->mailbox_type);
1407         if (mail_data->subject)
1408                 testapp_print("subject [%s]\n", mail_data->subject);
1409         testapp_print("date_time [%d]\n", mail_data->date_time);
1410         testapp_print("server_mail_status [%d]\n", mail_data->server_mail_status);
1411
1412         if (mail_data->server_mailbox_name)
1413                 testapp_print("server_mailbox_name [%s]\n", mail_data->server_mailbox_name);
1414
1415         if (mail_data->server_mail_id)
1416                 testapp_print("server_mail_id [%s]\n", mail_data->server_mail_id);
1417
1418         if (mail_data->message_id)
1419                 testapp_print("message_id [%s]\n", mail_data->message_id);
1420
1421         testapp_print("reference_mail_id [%d]\n", mail_data->reference_mail_id);
1422
1423         if (mail_data->full_address_from)
1424                 testapp_print("full_address_from [%s]\n", mail_data->full_address_from);
1425
1426         if (mail_data->full_address_reply)
1427                 testapp_print("full_address_reply [%s]\n", mail_data->full_address_reply);
1428
1429         if (mail_data->full_address_to)
1430                 testapp_print("full_address_to [%s]\n", mail_data->full_address_to);
1431
1432         if (mail_data->full_address_cc)
1433                 testapp_print("full_address_cc [%s]\n", mail_data->full_address_cc);
1434
1435         if (mail_data->full_address_bcc)
1436                 testapp_print("full_address_bcc [%s]\n", mail_data->full_address_bcc);
1437
1438         if (mail_data->full_address_return)
1439                 testapp_print("full_address_return [%s]\n", mail_data->full_address_return);
1440
1441         if (mail_data->email_address_sender)
1442                 testapp_print("email_address_sender [%s]\n", mail_data->email_address_sender);
1443
1444         if (mail_data->email_address_recipient)
1445                 testapp_print("email_address_recipient [%s]\n", mail_data->email_address_recipient);
1446
1447         if (mail_data->alias_sender)
1448                 testapp_print("alias_sender [%s]\n", mail_data->alias_sender);
1449
1450         if (mail_data->alias_recipient)
1451                 testapp_print("alias_recipient [%s]\n", mail_data->alias_recipient);
1452
1453         testapp_print("body_download_status [%d]\n", mail_data->body_download_status);
1454
1455         if (mail_data->file_path_plain)
1456                 testapp_print("file_path_plain [%s]\n", mail_data->file_path_plain);
1457
1458         if (mail_data->file_path_html)
1459                 testapp_print("file_path_html [%s]\n", mail_data->file_path_html);
1460
1461         testapp_print("file_path_mime_entity [%s]\n", mail_data->file_path_mime_entity);
1462         testapp_print("mail_size [%d]\n", mail_data->mail_size);
1463         testapp_print("flags_seen_field [%d]\n", mail_data->flags_seen_field);
1464         testapp_print("flags_deleted_field [%d]\n", mail_data->flags_deleted_field);
1465         testapp_print("flags_flagged_field [%d]\n", mail_data->flags_flagged_field);
1466         testapp_print("flags_answered_field [%d]\n", mail_data->flags_answered_field);
1467         testapp_print("flags_recent_field [%d]\n", mail_data->flags_recent_field);
1468         testapp_print("flags_draft_field [%d]\n", mail_data->flags_draft_field);
1469         testapp_print("flags_forwarded_field [%d]\n", mail_data->flags_forwarded_field);
1470         testapp_print("DRM_status [%d]\n", mail_data->DRM_status);
1471         testapp_print("priority [%d]\n", mail_data->priority);
1472         testapp_print("save_status [%d]\n", mail_data->save_status);
1473         testapp_print("lock_status [%d]\n", mail_data->lock_status);
1474         testapp_print("report_status [%d]\n", mail_data->report_status);
1475         testapp_print("attachment_count [%d]\n", mail_data->attachment_count);
1476         testapp_print("inline_content_count [%d]\n", mail_data->inline_content_count);
1477         testapp_print("thread_id [%d]\n", mail_data->thread_id);
1478         testapp_print("thread_item_count [%d]\n", mail_data->thread_item_count);
1479
1480         if (mail_data->preview_text)
1481                 testapp_print("preview_text [%s]\n", mail_data->preview_text);
1482
1483         testapp_print("meeting_request_status [%d]\n", mail_data->meeting_request_status);
1484         testapp_print("message_class [%d]\n", mail_data->message_class);
1485         testapp_print("digest_type [%d]\n", mail_data->digest_type);
1486         testapp_print("smime_type [%d]\n", mail_data->smime_type);
1487         testapp_print("scheduled_sending_time [%d]\n", mail_data->scheduled_sending_time);
1488         testapp_print("remaining_resend_times [%d]\n", mail_data->remaining_resend_times);
1489         testapp_print("eas_data_length [%d]\n", mail_data->eas_data_length);
1490
1491         return TRUE;
1492 }
1493
1494 static gboolean testapp_test_schedule_sending_mail()
1495 {
1496         int                    added_mail_id = 0;
1497         int                    err = EMAIL_ERROR_NONE;
1498         int                    handle = 0;
1499         time_t                 time_to_send;
1500
1501         testapp_add_mail_for_sending(&added_mail_id);
1502
1503         if (added_mail_id) {
1504                 time(&time_to_send);
1505                 time_to_send += 60;
1506
1507                 testapp_print("Calling email_schedule_sending_mail...\n");
1508
1509                 if (email_schedule_sending_mail(added_mail_id, time_to_send) < 0) {
1510                         testapp_print("email_schedule_sending_mail failed[%d]\n", err);
1511                 } else {
1512                         testapp_print("Start sending. handle[%d]\n", handle);
1513                 }
1514         }
1515
1516         return TRUE;
1517 }
1518
1519 static gboolean testapp_test_set_flags_field()
1520 {
1521         int account_id = 0;
1522         int mail_id = 0;
1523
1524         testapp_print("\n > Enter Account ID: ");
1525         if (0 >= scanf("%d", &account_id))
1526                 testapp_print("Invalid input. ");
1527
1528         testapp_print("\n > Enter Mail ID: ");
1529         if (0 >= scanf("%d", &mail_id))
1530                 testapp_print("Invalid input. ");
1531
1532         if (email_set_flags_field(account_id, &mail_id, 1, EMAIL_FLAGS_FLAGGED_FIELD, 1, 1) < 0)
1533                 testapp_print("email_set_flags_field failed");
1534         else
1535                 testapp_print("email_set_flags_field success");
1536
1537         return TRUE;
1538 }
1539
1540 static gboolean testapp_test_download_body()
1541 {
1542         int mail_id = 0;
1543         int handle = 0, err;
1544
1545         testapp_print("\n > Enter Mail Id: ");
1546         if (0 >= scanf("%d", &mail_id))
1547                 testapp_print("Invalid input. ");
1548         err = email_download_body(mail_id, 0, &handle);
1549         if (err  < 0)
1550                 testapp_print("email_download_body failed");
1551         else {
1552                 testapp_print("email_download_body success");
1553                 testapp_print("handle[%d]\n", handle);
1554         }
1555         return TRUE;
1556 }
1557
1558
1559 static gboolean testapp_test_cancel_download_body()
1560 {
1561         int mail_id = 0;
1562         int account_id = 0;
1563         int yes = 0;
1564         int handle = 0;
1565
1566         email_mailbox_t mailbox;
1567         memset(&mailbox, 0x00, sizeof(email_mailbox_t));
1568
1569         testapp_print("\n > Enter account_id: ");
1570         if (0 >= scanf("%d", &account_id))
1571                 testapp_print("Invalid input. ");
1572
1573         testapp_print("\n > Enter mail id: ");
1574         if (0 >= scanf("%d", &mail_id))
1575                 testapp_print("Invalid input. ");
1576
1577         if (email_download_body(mail_id, 0, &handle) < 0)
1578                 testapp_print("email_download_body failed");
1579         else {
1580                 testapp_print("email_download_body success\n");
1581                 testapp_print("Do u want to cancel download job>>>>>1/0\n");
1582                 if (0 >= scanf("%d", &yes))
1583                         testapp_print("Invalid input. ");
1584                 if (1 == yes) {
1585                         if (email_cancel_job(account_id, handle , EMAIL_CANCELED_BY_USER) < 0)
1586                                 testapp_print("email_cancel_job failed..!");
1587                         else {
1588                                 testapp_print("email_cancel_job success..!");
1589                                 testapp_print("handle[%d]\n", handle);
1590                         }
1591                 }
1592
1593         }
1594         return TRUE;
1595 }
1596 static gboolean testapp_test_download_attachment()
1597 {
1598         int mail_id = 0;
1599         int attachment_no = 0;
1600         int handle = 0;
1601
1602         testapp_print("\n > Enter Mail Id: ");
1603         if (0 >= scanf("%d", &mail_id))
1604                 testapp_print("Invalid input. ");
1605
1606         testapp_print("\n > Enter attachment number: ");
1607         if (0 >= scanf("%d", &attachment_no))
1608                 testapp_print("Invalid input. ");
1609
1610         if (email_download_attachment(mail_id, attachment_no, &handle) < 0)
1611                 testapp_print("email_download_attachment failed");
1612         else {
1613                 testapp_print("email_download_attachment success");
1614                 testapp_print("handle[%d]\n", handle);
1615         }
1616         return TRUE;
1617
1618 }
1619
1620 static gboolean testapp_test_get_attachment_data_list()
1621 {
1622         int err = EMAIL_ERROR_NONE;
1623         int i = 0;
1624         int mail_id = 0;
1625         int test_attachment_data_count;
1626         email_attachment_data_t *test_attachment_data_list = NULL;
1627
1628         testapp_print("\n > Enter Mail id: ");
1629         if (0 >= scanf("%d", &mail_id))
1630                 testapp_print("Invalid input. ");
1631
1632         if ((err = email_get_attachment_data_list(mail_id, &test_attachment_data_list, &test_attachment_data_count)) != EMAIL_ERROR_NONE) {
1633                 testapp_print("email_get_attachment_data_list() failed [%d]\n", err);
1634                 goto FINISH_OFF;
1635         }
1636         if (test_attachment_data_list) {
1637                 for (i = 0; i < test_attachment_data_count; i++) {
1638                         testapp_print("index [%d]\n", i);
1639                         testapp_print("attachment_name [%s]\n", test_attachment_data_list[i].attachment_name);
1640                         testapp_print("attachment_path [%s]\n", test_attachment_data_list[i].attachment_path);
1641                         testapp_print("attachment_size [%d]\n", test_attachment_data_list[i].attachment_size);
1642                         testapp_print("mail_id [%d]\n", test_attachment_data_list[i].mail_id);
1643                         testapp_print("attachment_mime_type [%s]\n", test_attachment_data_list[i].attachment_mime_type);
1644                 }
1645                 email_free_attachment_data(&test_attachment_data_list, test_attachment_data_count);
1646         }
1647
1648 FINISH_OFF:
1649
1650         return TRUE;
1651 }
1652
1653 static gboolean testapp_test_get_meeting_request()
1654 {
1655         int mail_id = 0;
1656         int err = EMAIL_ERROR_NONE;
1657         email_meeting_request_t *meeting_request;
1658
1659         testapp_print("\n > Enter Mail Id: ");
1660         if (0 >= scanf("%d", &mail_id))
1661                 testapp_print("Invalid input. ");
1662
1663         err = email_get_meeting_request(mail_id, &meeting_request);
1664
1665         testapp_print("err[%d]\n", err);
1666
1667         if (err == EMAIL_ERROR_NONE && meeting_request) {
1668                 testapp_print("mail_id [%d]\n", meeting_request->mail_id);
1669                 testapp_print("global_object_id [%s]\n", meeting_request->global_object_id);
1670                 testapp_print("meeting_response [%d]\n", meeting_request->meeting_response);
1671         }
1672
1673         email_free_meeting_request(&meeting_request, 1);
1674         return TRUE;
1675 }
1676
1677 static gboolean testapp_test_retry_send()
1678 {
1679         int mail_id = 0;
1680         int timeout = 0;
1681
1682         email_mailbox_t mailbox;
1683         memset(&mailbox, 0x00, sizeof(email_mailbox_t));
1684
1685         testapp_print("\n > Enter Mail Id: ");
1686         if (0 >= scanf("%d", &mail_id))
1687                 testapp_print("Invalid input. ");
1688
1689         testapp_print("\n > Enter timeout in seconds: ");
1690         if (0 >= scanf("%d", &timeout))
1691                 testapp_print("Invalid input. ");
1692
1693         if (email_retry_sending_mail(mail_id, timeout) < 0)
1694                 testapp_print("email_retry_sending_mail failed");
1695         return TRUE;
1696 }
1697
1698 static gboolean testapp_test_get_attachment_data()
1699 {
1700         int attachment_id = 0;
1701         email_attachment_data_t *attachment = NULL;
1702
1703         testapp_print("\n > Enter attachment id: ");
1704         if (0 >= scanf("%d", &attachment_id))
1705                 testapp_print("Invalid input. ");
1706
1707         email_get_attachment_data(attachment_id, &attachment);
1708
1709         if (attachment) {
1710                 testapp_print("attachment_name [%s]\n", attachment->attachment_name);
1711                 testapp_print("attachment_path [%s]\n", attachment->attachment_path);
1712                 testapp_print("attachment_size [%d]\n", attachment->attachment_size);
1713                 testapp_print("mail_id [%d]\n", attachment->mail_id);
1714                 testapp_print("attachment_mime_type [%s]\n", attachment->attachment_mime_type);
1715         }
1716
1717         return TRUE;
1718 }
1719
1720 static gboolean testapp_test_move_all_mails_to_mailbox()
1721 {
1722         int err = EMAIL_ERROR_NONE;
1723         int src_mailbox_id;
1724         int dest_mailbox_id;
1725
1726         testapp_print("src mailbox id> ");
1727         if (0 >= scanf("%d", &src_mailbox_id))
1728                 testapp_print("Invalid input. ");
1729
1730         testapp_print("dest mailbox id> ");
1731         if (0 >= scanf("%d", &dest_mailbox_id))
1732                 testapp_print("Invalid input. ");
1733
1734         err = email_move_all_mails_to_mailbox(src_mailbox_id, dest_mailbox_id);
1735         if (err < 0) {
1736                 testapp_print("email_move_all_mails_to_mailbox failed: err[%d]\n", err);
1737         } else {
1738                 testapp_print("email_move_all_mails_to_mailbox suceeded\n");
1739         }
1740
1741         return false;
1742 }
1743
1744 static gboolean testapp_test_get_totaldiskusage()
1745 {
1746         unsigned long total_size = 0;
1747         int err_code = EMAIL_ERROR_NONE ;
1748
1749         err_code = email_get_disk_space_usage(&total_size);
1750         if (err_code < 0)
1751                 testapp_print("email_get_disk_space_usage failed err : %d\n", err_code);
1752         else
1753                 testapp_print("email_get_disk_space_usage SUCCESS, total disk usage in KB : %ld \n", total_size);
1754
1755         return FALSE;
1756 }
1757
1758
1759
1760 static gboolean testapp_test_db_test()
1761 {
1762         int err = EMAIL_ERROR_NONE;
1763         int mail_id;
1764         int account_id;
1765         char *to = NULL;
1766         char *cc = NULL;
1767         char *bcc = NULL;
1768
1769         to = (char *)malloc(500000);
1770         cc = (char *)malloc(500000);
1771         bcc = (char *)malloc(500000);
1772
1773         memset(to, 0x00, sizeof(500000));
1774         memset(cc, 0x00, sizeof(500000));
1775         memset(bcc, 0x00, sizeof(500000));
1776
1777         testapp_print("Input Mail id:\n");
1778         if (0 >= scanf("%d", &mail_id))
1779                 testapp_print("Invalid input. ");
1780         testapp_print("Input Account id:\n");
1781         if (0 >= scanf("%d", &account_id))
1782                 testapp_print("Invalid input. ");
1783         testapp_print("Input TO field:\n");
1784         if (0 >= scanf("%s", to))
1785                 testapp_print("Invalid input. ");
1786         testapp_print("Input CC field:\n");
1787         if (0 >= scanf("%s", cc))
1788                 testapp_print("Invalid input. ");
1789         testapp_print("Input BCC field:\n");
1790         if (0 >= scanf("%s", bcc))
1791                 testapp_print("Invalid input. ");
1792
1793         if (emstorage_test(NULL, mail_id, account_id, to, cc, bcc, &err) == true) {
1794                 testapp_print(">> Saving Succeeded\n");
1795         } else {
1796                 testapp_print(">> Saving Failed[%d]\n", err);
1797         }
1798
1799         free(to);
1800         free(cc);
1801         free(bcc);
1802
1803         return false;
1804 }
1805
1806 static gboolean testapp_test_address_format_check_test()
1807 {
1808         /*
1809         int i;
1810         int type;
1811         int index;
1812         int check_yn;
1813         int err = EMAIL_ERROR_NONE;
1814         char *pAddress = NULL;
1815         char input_address[8096];
1816         char *address_list[] = {
1817                 "tom@gmail.com",
1818                 "tom@gmail,com",
1819                 "tom@gmail.com@gmail.com",
1820                 "[tom@gmail.com]",
1821                 "\"Tom\"<tom@gmail.com>",
1822                 "\"Tom\"[tom@gmail.com]",
1823                 "\"Tom\"<tom,@gmail.com>",
1824                 "<tom@gmail.com>",
1825                 "<tom@gmail,com>",
1826                 "<tom@gmail.>",
1827                 "<tom@gmail.com>,tom@gmail.com",
1828                 "<tom@gmail.com>;tom@gmail.com",
1829                 "tom @gmail.com",
1830                 "tom@ gmail.com",
1831                 "tom@gmail..com",
1832                 "tom@",
1833                 "tom@gmail",
1834                 "tom@gmail.",
1835                 "tom@gmail.c",
1836                 "tom@.",
1837                 "\"\"Tom\"<tom,@gmail.com>",
1838                 "tom@gmail.com,tom@gmail.com",
1839                 "tom@gmail.com.",
1840                 "<tom@gmail.com>,tom@.gmail.com",
1841                 "&& tom@live.com ----",
1842                 "madhu <tom@gmail.com>",
1843                 "tom@gmail.com, && tom@live.com",
1844                 "tom@gmail.com , && tom@live.com",
1845                 "< tom@gmail.com    > , <           tom@.gmail.com     >",
1846                 "tom@gmail.com ,           tom@gmail.com",
1847                 "<tom@gmail.com          >",
1848                 "<to     m@gmail.com          >",
1849                 "<tom@gmail.com>;tom@gmail.com",
1850                "Tom< tom@gmail.com > ,       Tom <tom@gmail.com>",
1851                 " \"Tom\"  < tom@gmail.com>  ,  \"Tom\"   < tom@gmail.com> ,  Tom  < tom@gmail.com> ; Tom  < tom@gmail.com>,\"tomtom\" <   tom@aol.com>,\"tomtom\" <   tom@aol.com>    ,\"tomtom\" <tom@aol.com>;<tom@live.com>,  <tom@live.com>; \"tomtomtomtom\" <tom@live.com>  ; \"tomtomtomtom\" <tom@live.com>,\"Tom\"  < tom@gmail.com>",
1852                 "<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>,<tom@gmail.com>",
1853                 "             tom@gmail.com         ;   <  tom@gmail.com   > ",
1854                 "\"Tom\" <        tom@gmail.com >  ;  mama <  tom@gmail.com    >  ,   abcd@gmail.com     ,   abc@gmail.com ,\"tomtom\" <tom@aol.com>,\"tomtom\"  < tom@aol.com> ;\"tomtom\" <   tom@aol.com   >    ,\"tomtom\" <tom@aol.com> , \"tomtomtomtom\" <tom@live.com>  ",
1855                 "             \"tomtom\" <tom@aol.com>    ;\"tomtom\" <tom@aol.com> ;          ",
1856                 "  tom@gmail.com  ,   tom@gmail.com ,   tom@gmail.com; Tom  < tom@gmail.com   >  ,<   tom@aol.com>, <tom@aol.com>    ,<tom@aol.com>;<tom@live.com>,  tom@live.com;tom@live.com; \"tomtomtomtom\" <tom@live.com>,\"Tom\"  < tom@gmail.com> ;    ",
1857                 "<tom@aol.com>    , \"tomtomtomtom\" <tom@live.com>,\"Tom\"  < tom@gmail.com> ;    ",
1858                 " Tom <tom@gmail.com>,Tom <tom@gmail.com>,Tom <tom@gmail.com>,Tom <tom@gmail.com>,Tom <   tom@gmail.com>  ,<tom@gmail.com>,Tom <tom@gmail.com       >,Tom< tom@gmail.com > ,       Tom <tom@gmail.com>,Tom <tom@gmail.com>,Tom <tom@gmail.com>,Tom <tom@gmail.com>,Tom <tom@gmail.com>,Tom <tom@gmail.com>,Tom <tom@gmail.com>,Tom <tom@gmail.com>",
1859                 NULL
1860         };
1861         int address_count = 0;
1862
1863         testapp_print("Select input method:\n");
1864         testapp_print("1. Test data\n");
1865         testapp_print("2. Keyboard\n");
1866         if (0 >= scanf("%d", &type);
1867
1868         switch (type) {
1869                 case 1:
1870                         do  {
1871                                 for (i = 0; address_list[i] != NULL; i++) {
1872                                         testapp_print("[%d] addr[%s]\n", i, address_list[i]);
1873                                         address_count++;
1874                                 }
1875                                 testapp_print("Choose address to be tested:[99:quit]\n");
1876                                 if (0 >= scanf("%d", &index);
1877                                 if (index == 99 )
1878                                         break;
1879
1880                                 testapp_print(">> [%d] Checking?(1:Yes, Other:No) [%s]\n", index, address_list[index]);
1881                                 if (0 >= scanf("%d", &check_yn);
1882                                 if (check_yn == 1) {
1883                                         pAddress = strdup(address_list[index]);
1884                                         if (em_verify_email_address(pAddress, false, &err ) == true) {
1885                                                 testapp_print("<< [%d] Checking Succeeded : addr[%s]\n", index, address_list[index]);
1886                                         }
1887                                         else {
1888                                                 testapp_print("<< [%d] Checking Failed    : addr[%s], err[%d]\n", index, address_list[index], err);
1889                                         }
1890                                         if (pAddress) {
1891                                                 free(pAddress);
1892                                                 pAddress = NULL;
1893                                         }
1894                                 }
1895                                 else {
1896                                         testapp_print("<< [%d]  Skipped            : addr[%s]\n", index, address_list[index]);
1897                                 }
1898                         }
1899                         while (1);
1900                         break;
1901                 case 2:
1902                         testapp_print("Input address: \n");
1903                         if (0 >= scanf("%s", input_address);
1904                         if (em_verify_email_address(input_address, false, &err ) == true) {
1905                                 testapp_print(">> Saving Succeeded : addr[%s]\n", input_address);
1906                         }
1907                         else {
1908                                 testapp_print(">> Saving Failed : addr[%s], err[%d]\n", input_address, err);
1909                         }
1910                         break;
1911                 default:
1912                         testapp_print("wrong nuber... [%d]\n", type);
1913                         break;
1914         }
1915         */
1916         return FALSE;
1917 }
1918
1919 static gboolean testapp_test_get_max_mail_count()
1920 {
1921         int max_count = -1;
1922         int err = EMAIL_ERROR_NONE;
1923
1924         err = email_get_max_mail_count(&max_count);
1925         testapp_print("\n\t>>>>> email_get_max_mail_count() return [%d][%d]\n\n", max_count, err);
1926
1927         return TRUE;
1928 }
1929
1930 #include "email-storage.h"
1931 static gboolean testapp_test_test_get_thread_information()
1932 {
1933         int error_code, thread_id = 38;
1934         email_mail_list_item_t *result_mail;
1935
1936         if ((error_code = email_get_thread_information_ex(thread_id, &result_mail)) == EMAIL_ERROR_NONE) {
1937                 testapp_print("email_get_thread_information returns = %d\n", error_code);
1938                 testapp_print("subject = %s\n", result_mail->subject);
1939                 testapp_print("mail_id = %d\n", result_mail->mail_id);
1940                 testapp_print("full_address_from = %s\n", result_mail->full_address_from);
1941                 testapp_print("thrad_id = %d\n", result_mail->thread_id);
1942                 testapp_print("count = %d\n", result_mail->thread_item_count);
1943         }
1944
1945         return TRUE;
1946 }
1947
1948 static gboolean testapp_test_get_address_info_list()
1949 {
1950         testapp_print(" >>> testapp_test_get_address_info_list : Entered \n");
1951
1952         char buf[1024];
1953         int i = 0;
1954         int mail_id = 0;
1955         email_address_info_list_t *address_info_list = NULL;
1956         email_address_info_t *p_address_info = NULL;
1957         GList *list = NULL;
1958         GList *node = NULL;
1959
1960         memset(buf, 0x00, sizeof(buf));
1961         testapp_print("\n > Enter mail_id: ");
1962         if (0 >= scanf("%d", &mail_id))
1963                 testapp_print("Invalid input. ");
1964
1965         email_get_address_info_list(mail_id, &address_info_list);
1966
1967         testapp_print("===================================================\n");
1968         testapp_print("\t\t\t address info list\n");
1969         testapp_print("===================================================\n");
1970         testapp_print("address_type\t address \t\tdisplay_name\t contact id\n");
1971         testapp_print("===================================================\n");
1972
1973         for (i = EMAIL_ADDRESS_TYPE_FROM; i <= EMAIL_ADDRESS_TYPE_BCC; i++) {
1974                 switch (i) {
1975                 case EMAIL_ADDRESS_TYPE_FROM:
1976                         list = address_info_list->from;
1977                         break;
1978                 case EMAIL_ADDRESS_TYPE_TO:
1979                         list = address_info_list->to;
1980                         break;
1981                 case EMAIL_ADDRESS_TYPE_CC:
1982                         list = address_info_list->cc;
1983                         break;
1984                 case EMAIL_ADDRESS_TYPE_BCC:
1985                         list = address_info_list->bcc;
1986                         break;
1987                 }
1988
1989                 /*  delete dynamic-allocated memory for each item */
1990                 node = g_list_first(list);
1991                 while (node != NULL) {
1992                         p_address_info = (email_address_info_t *)node->data;
1993                         testapp_print("%d\t\t%s\t%s\t%d\n", p_address_info->address_type, p_address_info->address, p_address_info->display_name, p_address_info->contact_id);
1994
1995                         node = g_list_next(node);
1996                 }
1997                 testapp_print("\n");
1998         }
1999         testapp_print("===================================================\n");
2000
2001         if (address_info_list)
2002                 email_free_address_info_list(&address_info_list);
2003
2004         testapp_print(" >>> testapp_test_get_address_info_list : END \n");
2005         return TRUE;
2006 }
2007
2008 static gboolean testapp_test_search_mail_on_server()
2009 {
2010         testapp_print(" >>> testapp_test_search_mail_on_server : Entered \n");
2011
2012         int err_code = EMAIL_ERROR_NONE;
2013         int account_id = 0;
2014         int mailbox_id = 0;
2015         int search_key_value_integer = 0;
2016         int search_filter_count = 0;
2017         email_search_filter_type search_filter_type = 0;
2018         email_search_filter_t search_filter[10];
2019         int handle = 0;
2020         time_t current_time = 0;
2021         char search_key_value_string[256];
2022
2023         testapp_print("input account id : ");
2024         if (0 >= scanf("%d", &account_id))
2025                 testapp_print("Invalid input. ");
2026
2027         testapp_print("input mailbox id : ");
2028         if (0 >= scanf("%d", &mailbox_id))
2029                 testapp_print("Invalid input. ");
2030
2031         memset(&search_filter, 0x00, sizeof(email_search_filter_t) * 10);
2032
2033         while (1) {
2034                 testapp_print(
2035                         "       EMAIL_SEARCH_FILTER_TYPE_MESSAGE_NO       =  1, (integer type ) \n"
2036                         "       EMAIL_SEARCH_FILTER_TYPE_UID              =  2, (integer type ) \n"
2037                         "   EMAIL_SEARCH_FILTER_TYPE_ALL              =  3, (integer type ) \n"
2038                         "       EMAIL_SEARCH_FILTER_TYPE_BCC              =  7, (string type ) \n"
2039                         "   EMAIL_SEARCH_FILTER_TYPE_BODY             =  8, (string type ) \n"
2040                         "       EMAIL_SEARCH_FILTER_TYPE_CC               =  9, (string type ) \n"
2041                         "       EMAIL_SEARCH_FILTER_TYPE_FROM             = 10, (string type ) \n"
2042                         "       EMAIL_SEARCH_FILTER_TYPE_KEYWORD          = 11, (string type ) \n"
2043                         "   EMAIL_SEARCH_FILTER_TYPE_TEXT             = 12, (string type ) \n"
2044                         "       EMAIL_SEARCH_FILTER_TYPE_SUBJECT          = 13, (string type ) \n"
2045                         "       EMAIL_SEARCH_FILTER_TYPE_TO               = 15, (string type ) \n"
2046                         "       EMAIL_SEARCH_FILTER_TYPE_SIZE_LARSER      = 16, (integet type ) \n"
2047                         "       EMAIL_SEARCH_FILTER_TYPE_SIZE_SMALLER     = 17, (integet type ) \n"
2048                         "       EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_BEFORE = 20, (time type ) \n"
2049                         "       EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_ON     = 21, (time type ) \n"
2050                         "       EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_SINCE  = 22, (time type ) \n"
2051                         "       EMAIL_SEARCH_FILTER_TYPE_FLAGS_ANSWERED   = 26, (integer type ) \n"
2052                         "   EMAIL_SEARCH_FILTER_TYPE_FLAGS_NEW        = 27, (integer type ) \n"
2053                         "       EMAIL_SEARCH_FILTER_TYPE_FLAGS_DELETED    = 28, (integer type ) \n"
2054                         "   EMAIL_SEARCH_FILTER_TYPE_FLAGS_OLD        = 29, (integer type ) \n"
2055                         "       EMAIL_SEARCH_FILTER_TYPE_FLAGS_DRAFT      = 30, (integer type ) \n"
2056                         "       EMAIL_SEARCH_FILTER_TYPE_FLAGS_FLAGED     = 32, (integer type ) \n"
2057                         "       EMAIL_SEARCH_FILTER_TYPE_FLAGS_RECENT     = 34, (integer type ) \n"
2058                         "       EMAIL_SEARCH_FILTER_TYPE_FLAGS_SEEN       = 36, (integer type ) \n"
2059                         "       EMAIL_SEARCH_FILTER_TYPE_MESSAGE_ID       = 43, (string type ) \n"
2060                         "   EMAIL_SEARCH_FILTER_TYPE_HEADER_PRIORITY  = 50, (integer type ) \n"
2061                         "       EMAIL_SEARCH_FILTER_TYPE_ATTACHMENT_NAME  = 60, (string type ) \n"
2062                         "   EMAIL_SEARCH_FILTER_TYPE_CHARSET          = 61, (string type ) \n"
2063                         "   EMAIL_SEARCH_FILTER_TYPE_USER_DEFINED     = 62, (string type ) \n"
2064                         "       END                                       = 0 \n");
2065
2066                 testapp_print("input search filter type : ");
2067                 if (0 >= scanf("%d", (int *)&search_filter_type))
2068                         testapp_print("Invalid input. ");
2069
2070                 search_filter[search_filter_count].search_filter_type = search_filter_type;
2071
2072                 switch (search_filter_type) {
2073                 case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_NO:
2074                 case EMAIL_SEARCH_FILTER_TYPE_UID:
2075                 case EMAIL_SEARCH_FILTER_TYPE_ALL:
2076                 case EMAIL_SEARCH_FILTER_TYPE_SIZE_LARSER:
2077                 case EMAIL_SEARCH_FILTER_TYPE_SIZE_SMALLER:
2078                 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_ANSWERED:
2079                 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_NEW:
2080                 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DELETED:
2081                 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_OLD:
2082                 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DRAFT:
2083                 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_FLAGED:
2084                 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_RECENT:
2085                 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_SEEN:
2086                 case EMAIL_SEARCH_FILTER_TYPE_HEADER_PRIORITY:
2087                         testapp_print("input search filter key value : ");
2088                         if (0 >= scanf("%d", &search_key_value_integer))
2089                                 testapp_print("Invalid input. ");
2090                         search_filter[search_filter_count].search_filter_key_value.integer_type_key_value = search_key_value_integer;
2091                         break;
2092
2093                 case EMAIL_SEARCH_FILTER_TYPE_BCC:
2094                 case EMAIL_SEARCH_FILTER_TYPE_BODY:
2095                 case EMAIL_SEARCH_FILTER_TYPE_CC:
2096                 case EMAIL_SEARCH_FILTER_TYPE_FROM:
2097                 case EMAIL_SEARCH_FILTER_TYPE_KEYWORD:
2098                 case EMAIL_SEARCH_FILTER_TYPE_TEXT:
2099                 case EMAIL_SEARCH_FILTER_TYPE_SUBJECT:
2100                 case EMAIL_SEARCH_FILTER_TYPE_TO:
2101                 case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_ID:
2102                 case EMAIL_SEARCH_FILTER_TYPE_ATTACHMENT_NAME:
2103                 case EMAIL_SEARCH_FILTER_TYPE_CHARSET:
2104                 case EMAIL_SEARCH_FILTER_TYPE_USER_DEFINED:
2105                         testapp_print("input search filter key value : ");
2106                         int readn = read(0, search_key_value_string, 256);
2107                         if (readn < 0)
2108                                 testapp_print("Invalid input. ");
2109
2110                         search_filter[search_filter_count].search_filter_key_value.string_type_key_value = strndup(search_key_value_string, readn - 1);
2111                         break;
2112
2113                 case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_BEFORE:
2114                 case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_ON:
2115                 case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_SINCE:
2116                         time(&current_time);
2117                         /* TODO : write codes for converting string to time */
2118                         /* search_filter.search_filter_key_value.time_type_key_value = search_key_value_string; */
2119                         search_filter[search_filter_count].search_filter_key_value.time_type_key_value = current_time;
2120                         break;
2121                 default:
2122                         testapp_print("END filter type [%d]", search_filter_type);
2123                         break;
2124                 }
2125
2126                 if (!search_filter_type)
2127                         break;
2128
2129                 search_filter_count++;
2130         }
2131
2132         if ((err_code = email_search_mail_on_server(account_id, mailbox_id, search_filter, search_filter_count, &handle)) != EMAIL_ERROR_NONE) {
2133                 testapp_print("email_search_mail_on_server failed [%d]", err_code);
2134         }
2135
2136         testapp_print(" >>> testapp_test_search_mail_on_server : END \n");
2137         return TRUE;
2138 }
2139
2140 static gboolean testapp_test_add_mail_to_search_result_box()
2141 {
2142         int                    i = 0;
2143         int                    account_id = 0;
2144         int                    from_eas = 0;
2145         int                    attachment_count = 0;
2146         int                    err = EMAIL_ERROR_NONE;
2147         char                   arg[50] = { 0 , };
2148         char                  *body_file_path = MAIL_TEMP_BODY;
2149         email_mailbox_t         *mailbox_data = NULL;
2150         email_mail_data_t       *test_mail_data = NULL;
2151         email_attachment_data_t *attachment_data = NULL;
2152         email_meeting_request_t *meeting_req = NULL;
2153         FILE                  *body_file = NULL;
2154
2155         testapp_print("\n > Enter account id : ");
2156         if (0 >= scanf("%d", &account_id))
2157                 testapp_print("Invalid input. ");
2158
2159         email_get_mailbox_by_mailbox_type(account_id, EMAIL_MAILBOX_TYPE_SEARCH_RESULT, &mailbox_data);
2160
2161         test_mail_data = malloc(sizeof(email_mail_data_t));
2162         memset(test_mail_data, 0x00, sizeof(email_mail_data_t));
2163
2164         testapp_print("\n From EAS? [0/1]> ");
2165         if (0 >= scanf("%d", &from_eas))
2166                 testapp_print("Invalid input. ");
2167
2168         test_mail_data->account_id             = account_id;
2169         test_mail_data->save_status            = 1;
2170         test_mail_data->body_download_status   = 1;
2171         test_mail_data->flags_seen_field       = 1;
2172         test_mail_data->file_path_plain        = strdup(body_file_path);
2173         test_mail_data->mailbox_id             = mailbox_data->mailbox_id;
2174         test_mail_data->mailbox_type           = mailbox_data->mailbox_type;
2175         test_mail_data->full_address_from      = strdup("<test1@test.com>");
2176         test_mail_data->full_address_to        = strdup("<test2@test.com>");
2177         test_mail_data->full_address_cc        = strdup("<test3@test.com>");
2178         test_mail_data->full_address_bcc       = strdup("<test4@test.com>");
2179         test_mail_data->subject                = strdup("Into search result mailbox");
2180         test_mail_data->remaining_resend_times = 3;
2181
2182         body_file = fopen(body_file_path, "w");
2183
2184         for (i = 0; i < 500; i++)
2185                 fprintf(body_file, "X2 X2 X2 X2 X2 X2 X2");
2186         fflush(body_file);
2187         fclose(body_file);
2188
2189         testapp_print(" > Attach file? [0/1] : ");
2190         if (0 >= scanf("%d", &attachment_count))
2191                 testapp_print("Invalid input. ");
2192
2193         if (attachment_count) {
2194                 memset(arg, 0x00, 50);
2195                 testapp_print("\n > Enter attachment name : ");
2196                 if (0 >= scanf("%s", arg))
2197                         testapp_print("Invalid input. ");
2198
2199                 attachment_data = malloc(sizeof(email_attachment_data_t));
2200
2201                 attachment_data->attachment_name  = strdup(arg);
2202
2203                 memset(arg, 0x00, 50);
2204                 testapp_print("\n > Enter attachment absolute path : ");
2205                 if (0 >= scanf("%s", arg))
2206                         testapp_print("Invalid input. ");
2207
2208                 attachment_data->attachment_path  = strdup(arg);
2209                 attachment_data->save_status      = 1;
2210                 test_mail_data->attachment_count  = attachment_count;
2211         }
2212
2213         testapp_print("\n > Meeting Request? [0: no, 1: yes(request from server), 2: yes(response from local)]");
2214         if (0 >= scanf("%d", (int *)&(test_mail_data->meeting_request_status)))
2215                 testapp_print("Invalid input. ");
2216
2217         if (test_mail_data->meeting_request_status == 1
2218                 || test_mail_data->meeting_request_status == 2) {
2219                 time_t current_time;
2220                 /*  dummy data for meeting request */
2221                 meeting_req = malloc(sizeof(email_meeting_request_t));
2222                 memset(meeting_req, 0x00, sizeof(email_meeting_request_t));
2223
2224                 meeting_req->meeting_response     = 1;
2225                 current_time = time(NULL);
2226                 gmtime_r(&current_time, &(meeting_req->start_time));
2227                 gmtime_r(&current_time, &(meeting_req->end_time));
2228                 meeting_req->location = malloc(strlen("Seoul") + 1);
2229                 memset(meeting_req->location, 0x00, strlen("Seoul") + 1);
2230                 strcpy(meeting_req->location, "Seoul");
2231                 strcpy(meeting_req->global_object_id, "abcdef12345");
2232
2233                 meeting_req->time_zone.offset_from_GMT = 9;
2234                 strcpy(meeting_req->time_zone.standard_name, "STANDARD_NAME");
2235                 gmtime_r(&current_time, &(meeting_req->time_zone.standard_time_start_date));
2236                 meeting_req->time_zone.standard_bias = 3;
2237
2238                 strcpy(meeting_req->time_zone.daylight_name, "DAYLIGHT_NAME");
2239                 gmtime_r(&current_time, &(meeting_req->time_zone.daylight_time_start_date));
2240                 meeting_req->time_zone.daylight_bias = 7;
2241
2242         }
2243
2244         if ((err = email_add_mail(test_mail_data, attachment_data, attachment_count, meeting_req, from_eas)) != EMAIL_ERROR_NONE)
2245                 testapp_print("email_add_mail failed. [%d]\n", err);
2246         else
2247                 testapp_print("email_add_mail success.\n");
2248
2249         testapp_print("saved mail id = [%d]\n", test_mail_data->mail_id);
2250
2251         if (attachment_data)
2252                 email_free_attachment_data(&attachment_data, attachment_count);
2253
2254         if (meeting_req)
2255                 email_free_meeting_request(&meeting_req, 1);
2256
2257         email_free_mail_data(&test_mail_data, 1);
2258         email_free_mailbox(&mailbox_data, 1);
2259
2260         return FALSE;
2261 }
2262
2263 static gboolean testapp_test_email_parse_mime_file()
2264 {
2265         int i = 0;
2266         int attachment_count = 0;
2267         int output_attachment_count = 0;
2268         int verify = 0;
2269         int err = EMAIL_ERROR_NONE;
2270         char eml_file_path[255] = {0, };
2271         struct tm *struct_time;
2272
2273         email_mail_data_t *mail_data = NULL;
2274         email_attachment_data_t *mail_attachment_data = NULL;
2275         email_mail_data_t *output_mail_data = NULL;
2276         email_attachment_data_t *output_mail_attachment_data = NULL;
2277
2278         testapp_print("Input eml file path : ");
2279         if (0 >= scanf("%s", eml_file_path))
2280                 testapp_print("Invalid input. ");
2281
2282         if ((err = email_parse_mime_file(eml_file_path, &mail_data, &mail_attachment_data, &attachment_count)) != EMAIL_ERROR_NONE) {
2283                 testapp_print("email_parse_mime_file failed : [%d]\n", err);
2284                 return false;
2285         }
2286
2287         testapp_print("load success\n");
2288
2289         struct_time = localtime(&(mail_data->date_time));
2290
2291         testapp_print("%4d year", struct_time->tm_year +1900);
2292         testapp_print("%2d month(0-11)\n", struct_time->tm_mon + 1);
2293         testapp_print("%2d day(1-31)\n", struct_time->tm_mday);
2294         testapp_print("%2d wday\n", struct_time->tm_wday);
2295         testapp_print("%2d hour(0-23)\n", struct_time->tm_hour);
2296         testapp_print("%2d minutes(0-59)\n", struct_time->tm_min);
2297         testapp_print("%2d second(0-59)\n", struct_time->tm_sec);
2298         testapp_print("year day %3d\n", struct_time->tm_yday);
2299
2300         testapp_print("Return-Path: %s\n", mail_data->full_address_return);
2301         testapp_print("To: %s\n", mail_data->full_address_to);
2302         testapp_print("Subject: %s\n", mail_data->subject);
2303         testapp_print("Priority: %d\n", mail_data->priority);
2304         testapp_print("From: %s\n", mail_data->full_address_from);
2305         testapp_print("Reply-To: %s\n", mail_data->full_address_reply);
2306         testapp_print("Sender: %s\n", mail_data->email_address_sender);
2307         testapp_print("Message-ID: %s\n", mail_data->message_id);
2308         testapp_print("attachment_count: %d\n", mail_data->attachment_count);
2309         testapp_print("SMIME type : %d\n", mail_data->smime_type);
2310         testapp_print("inline content count : %d\n", mail_data->inline_content_count);
2311         testapp_print("mail_size : %d\n", mail_data->mail_size);
2312         testapp_print("download_body_status : %d\n", mail_data->body_download_status);
2313
2314
2315         for (i = 0; i < attachment_count ; i++) {
2316                 testapp_print("%d attachment\n", i);
2317                 testapp_print("attachment_id: %d\n", mail_attachment_data[i].attachment_id);
2318                 testapp_print("attachment_size: %d\n", mail_attachment_data[i].attachment_size);
2319                 testapp_print("inline_attachment_status: %d\n", mail_attachment_data[i].inline_content_status);
2320                 testapp_print("attachment_name: %s\n", mail_attachment_data[i].attachment_name);
2321                 testapp_print("attachment_path: %s\n", mail_attachment_data[i].attachment_path);
2322                 testapp_print("attachment_save_status: %d\n", mail_attachment_data[i].save_status);
2323                 testapp_print("content_id: %s\n", mail_attachment_data[i].content_id);
2324                 testapp_print("mailbox_id: %d\n", mail_attachment_data[i].mailbox_id);
2325         }
2326
2327         testapp_print("Success : Open eml file\n");
2328
2329         if (mail_data->smime_type != EMAIL_SMIME_NONE) {
2330                 if (mail_data->smime_type == EMAIL_SMIME_SIGNED || mail_data->smime_type == EMAIL_PGP_SIGNED) {
2331                         if (!email_verify_signature_ex(mail_data, mail_attachment_data, attachment_count, &verify))
2332                                 testapp_print("email_verify_signature_ex failed\n");
2333                 } else {
2334                         if ((err = email_get_decrypt_message_ex(mail_data,
2335                                                                                                         mail_attachment_data,
2336                                                                                                         attachment_count,
2337                                                                                                         &output_mail_data,
2338                                                                                                         &output_mail_attachment_data,
2339                                                                                                         &output_attachment_count,
2340                                                                                                         &verify)) != EMAIL_ERROR_NONE)
2341                                 testapp_print("email_get_decrypt_message_ex failed\n");
2342                 }
2343
2344                 testapp_print("verify : [%d]\n", verify);
2345         }
2346
2347         if ((err = email_delete_parsed_data(mail_data)) != EMAIL_ERROR_NONE) {
2348                 testapp_print("email_delete_eml_data failed : [%d]\n", err);
2349                 return false;
2350         }
2351
2352         testapp_print("Success : email_delete_eml_data\n");
2353
2354         if (mail_data)
2355                 email_free_mail_data(&mail_data, 1);
2356
2357         testapp_print("Success : email_free_mail_data\n");
2358
2359         if (mail_attachment_data)
2360                 email_free_attachment_data(&mail_attachment_data, attachment_count);
2361
2362         testapp_print("Success : email_free_attachment_data\n");
2363
2364         return true;
2365
2366 }
2367
2368 static gboolean testapp_test_email_write_mime_file()
2369 {
2370         int err = EMAIL_ERROR_NONE;
2371         int mail_id = 0;
2372         int attachment_count = 0;
2373         char *file_path = NULL;
2374         email_mail_data_t *mail_data = NULL;
2375         email_attachment_data_t *mail_attachment_data = NULL;
2376
2377
2378         file_path = malloc(512);
2379         memset(file_path, 0x00, 512);
2380
2381         testapp_print("Input mail id : ");
2382         if (0 >= scanf("%d", &mail_id))
2383                 testapp_print("Invalid input. ");
2384
2385         err = email_get_mail_data(mail_id, &mail_data);
2386         if (err != EMAIL_ERROR_NONE || mail_data == NULL) {
2387                 testapp_print("email_get_mail_data failed : [%d]\n", err);
2388                 free(file_path);
2389                 return false;
2390         }
2391
2392         err = email_get_attachment_data_list(mail_id, &mail_attachment_data, &attachment_count);
2393         if (err != EMAIL_ERROR_NONE) {
2394                 testapp_print("email_get_attachment_data_list failed : [%d]\n", err);
2395                 return false;
2396         }
2397
2398         snprintf(file_path, 512, tzplatform_mkpath(TZ_SYS_DATA, "email/.email_data/tmp/%d_%8d.eml"), mail_id, (int)time(NULL));
2399
2400         err = email_write_mime_file(mail_data, mail_attachment_data, attachment_count, &file_path);
2401         if (err != EMAIL_ERROR_NONE) {
2402                 testapp_print("email_write_mime_file failed : [%d]\n", err);
2403                 return false;
2404         }
2405
2406         testapp_print("file path : [%s]\n", file_path);
2407
2408         if (mail_data)
2409                 email_free_mail_data(&mail_data, 1);
2410
2411         if (mail_attachment_data)
2412                 email_free_attachment_data(&mail_attachment_data, attachment_count);
2413
2414         if (file_path)
2415                 free(file_path);
2416
2417         return true;
2418 }
2419
2420 static gboolean testapp_test_smime_verify_signature()
2421 {
2422         int mail_id = 0;
2423         int verify = 0;
2424         int err = EMAIL_ERROR_NONE;
2425
2426         testapp_print("input mail_id :");
2427         if (0 >= scanf("%d", &mail_id))
2428                 testapp_print("Invalid input. ");
2429
2430         err = email_verify_signature(mail_id, &verify);
2431         if (err != EMAIL_ERROR_NONE) {
2432                 testapp_print("Failed Verify\n");
2433                 return false;
2434         }
2435
2436         testapp_print("verify value : [%d]\n", verify);
2437         return true;
2438 }
2439
2440 static gboolean testapp_test_email_add_mail_with_multiple_recipient()
2441 {
2442         int                    i = 0;
2443         int                    account_id = 0;
2444         int                    err = EMAIL_ERROR_NONE;
2445 //      int                    smime_type = 0;
2446         int                    recipient_addresses_count = 0;
2447         char                  *recipient_addresses = NULL;
2448         char                   recipient_address[234] = { 0, };
2449         char                   from_address[300] = { 0 , };
2450         const char            *body_file_path = MAIL_TEMP_BODY;
2451         email_account_t       *account_data = NULL;
2452         email_mailbox_t       *mailbox_data = NULL;
2453         email_mail_data_t     *test_mail_data = NULL;
2454         FILE                  *body_file;
2455
2456         testapp_print("\n > Enter account id : ");
2457         if (0 >= scanf("%d", &account_id))
2458                 testapp_print("Invalid input. ");
2459
2460         testapp_print("\n > Enter recipient address count : ");
2461         if (0 >= scanf("%d", &recipient_addresses_count))
2462                 testapp_print("Invalid input. ");
2463
2464         if (recipient_addresses_count < 1)
2465                 return TRUE;
2466
2467         recipient_addresses = malloc(sizeof(char) * 234 * recipient_addresses_count);
2468
2469         for (i = 0; i < recipient_addresses_count; i++) {
2470                 snprintf(recipient_address, 234, "\"mailtest%05d\" <mailtest%05d@a1234567890b1234567890.com>; ", i, i);
2471                 strcat(recipient_addresses, recipient_address);
2472         }
2473
2474         email_get_account(account_id, GET_FULL_DATA_WITHOUT_PASSWORD, &account_data);
2475
2476         email_get_mailbox_by_mailbox_type(account_id, EMAIL_MAILBOX_TYPE_OUTBOX, &mailbox_data);
2477
2478         test_mail_data = malloc(sizeof(email_mail_data_t));
2479         memset(test_mail_data, 0x00, sizeof(email_mail_data_t));
2480
2481         SNPRINTF(from_address, 300, "<%s>", account_data->user_email_address);
2482
2483         test_mail_data->account_id             = account_id;
2484         test_mail_data->save_status            = EMAIL_MAIL_STATUS_SEND_DELAYED;
2485         test_mail_data->body_download_status   = 1;
2486         test_mail_data->flags_seen_field       = 1;
2487         test_mail_data->file_path_plain        = strdup(body_file_path);
2488         test_mail_data->mailbox_id             = mailbox_data->mailbox_id;
2489         test_mail_data->mailbox_type           = mailbox_data->mailbox_type;
2490         test_mail_data->full_address_from      = strdup(from_address);
2491         test_mail_data->full_address_to        = recipient_addresses;
2492         test_mail_data->subject                = strdup("Read receipt request from TIZEN");
2493         test_mail_data->remaining_resend_times = 3;
2494         test_mail_data->report_status          = EMAIL_MAIL_REQUEST_DSN | EMAIL_MAIL_REQUEST_MDN;
2495         test_mail_data->smime_type             = 0;
2496
2497         body_file = fopen(body_file_path, "w");
2498
2499         testapp_print("\n body_file [%p]\n", body_file);
2500
2501         if (body_file == NULL) {
2502                 testapp_print("\n fopen [%s]failed\n", body_file_path);
2503                 return FALSE;
2504         }
2505
2506         for (i = 0; i < 100; i++)
2507                 fprintf(body_file, "Mail sending Test. [%d]\n", i);
2508
2509         fflush(body_file);
2510         fclose(body_file);
2511
2512
2513         if ((err = email_add_mail(test_mail_data, NULL, 0, NULL, 0)) != EMAIL_ERROR_NONE)
2514                 testapp_print("email_add_mail failed. [%d]\n", err);
2515         else
2516                 testapp_print("email_add_mail success.\n");
2517
2518         testapp_print("saved mail id = [%d]\n", test_mail_data->mail_id);
2519
2520         email_free_mail_data(&test_mail_data, 1);
2521         email_free_mailbox(&mailbox_data, 1);
2522         email_free_account(&account_data, 1);
2523
2524         return FALSE;
2525 }
2526
2527 static gboolean testapp_test_send_mails_every_x_minutes()
2528 {
2529         int                    added_mail_id = 0;
2530         int                    err = EMAIL_ERROR_NONE;
2531         int                    handle = 0;
2532         time_t                 time_to_send;
2533         int                    i = 0;
2534         int                    j = 0;
2535         int                    account_id = 0;
2536         int                    send_interval_in_minutes = 0;
2537         int                    number_of_mails = 0;
2538         char                   recipient_address[300] = { 0 , };
2539         char                   from_address[300] = { 0 , };
2540         char                   subject_form[1024] = { 0 , };
2541         const char            *body_file_path = MAIL_TEMP_BODY;
2542         struct tm             *time_to_send_tm;
2543         email_account_t       *account_data = NULL;
2544         email_mailbox_t       *mailbox_data = NULL;
2545         email_mail_data_t     *test_mail_data = NULL;
2546         FILE                  *body_file;
2547
2548         testapp_print("\n > Enter account id : ");
2549         if (0 >= scanf("%d", &account_id))
2550                 testapp_print("Invalid input. ");
2551
2552         testapp_print("\n > Enter recipient address : ");
2553         if (0 >= scanf("%s", recipient_address))
2554                 testapp_print("Invalid input. ");
2555
2556         testapp_print("\n > Enter number of mails: ");
2557         if (0 >= scanf("%d", &number_of_mails))
2558                 testapp_print("Invalid input. ");
2559
2560         testapp_print("\n > Enter send interval in minutes: ");
2561         if (0 >= scanf("%d", &send_interval_in_minutes))
2562                 testapp_print("Invalid input. ");
2563
2564         email_get_account(account_id, GET_FULL_DATA_WITHOUT_PASSWORD, &account_data);
2565
2566         email_get_mailbox_by_mailbox_type(account_id, EMAIL_MAILBOX_TYPE_OUTBOX, &mailbox_data);
2567
2568         test_mail_data = malloc(sizeof(email_mail_data_t));
2569         memset(test_mail_data, 0x00, sizeof(email_mail_data_t));
2570
2571         SNPRINTF(from_address, 300, "<%s>", account_data->user_email_address);
2572
2573         test_mail_data->account_id             = account_id;
2574         test_mail_data->save_status            = EMAIL_MAIL_STATUS_SEND_DELAYED;
2575         test_mail_data->body_download_status   = 1;
2576         test_mail_data->flags_seen_field       = 1;
2577         test_mail_data->file_path_plain        = strdup(body_file_path);
2578         test_mail_data->mailbox_id             = mailbox_data->mailbox_id;
2579         test_mail_data->mailbox_type           = mailbox_data->mailbox_type;
2580         test_mail_data->full_address_from      = strdup(from_address);
2581         test_mail_data->full_address_to        = strdup(recipient_address);
2582         test_mail_data->remaining_resend_times = 3;
2583         test_mail_data->report_status          = EMAIL_MAIL_REPORT_NONE;
2584
2585
2586         for (i = 0; i < number_of_mails; i++) {
2587                 if (test_mail_data->subject)
2588                         free(test_mail_data->subject);
2589
2590                 time(&time_to_send);
2591                 time_to_send += (60 * send_interval_in_minutes) * (i + 1);
2592                 time_to_send_tm = localtime(&time_to_send);
2593
2594                 strftime(subject_form, 1024, "[%H:%M] TEST.", time_to_send_tm);
2595                 test_mail_data->subject = strdup(subject_form);
2596
2597                 body_file = fopen(body_file_path, "w");
2598
2599                 testapp_print("\n body_file [%p]\n", body_file);
2600
2601                 if (body_file == NULL) {
2602                         testapp_print("\n fopen [%s]failed\n", body_file_path);
2603                         return FALSE;
2604                 }
2605
2606                 for (j = 0; j < 100; j++)
2607                         fprintf(body_file, "Mail sending Test. [%d]\n", j);
2608
2609                 fflush(body_file);
2610                 fclose(body_file);
2611
2612                 if ((err = email_add_mail(test_mail_data, NULL, 0, NULL, 0)) != EMAIL_ERROR_NONE) {
2613                         testapp_print("email_add_mail failed. [%d]\n", err);
2614                         added_mail_id = 0;
2615                 } else {
2616                         testapp_print("email_add_mail success.\n");
2617                         added_mail_id = test_mail_data->mail_id;
2618                 }
2619
2620                 testapp_print("saved mail id = [%d]\n", added_mail_id);
2621
2622                 if (added_mail_id) {
2623                         testapp_print("Calling email_schedule_sending_mail...\n");
2624
2625                         if (email_schedule_sending_mail(added_mail_id, time_to_send) < 0) {
2626                                 testapp_print("email_schedule_sending_mail failed[%d]\n", err);
2627                         } else  {
2628                                 testapp_print("Start sending. handle[%d]\n", handle);
2629                         }
2630                 }
2631         }
2632
2633         email_free_mail_data(&test_mail_data, 1);
2634         email_free_mailbox(&mailbox_data, 1);
2635         email_free_account(&account_data, 1);
2636
2637         return TRUE;
2638 }
2639
2640 /* internal functions */
2641 static gboolean testapp_test_interpret_command(int menu_number)
2642 {
2643         gboolean go_to_loop = TRUE;
2644
2645         switch (menu_number) {
2646         case 1:
2647                 testapp_test_get_mails();
2648                 break;
2649         case 2:
2650                 testapp_test_mail_send(NULL);
2651                 break;
2652         case 3:
2653                 testapp_test_get_mail_list_ex();
2654                 break;
2655         case 4:
2656                 testapp_test_add_attachment();
2657                 break;
2658         case 5:
2659                 testapp_test_set_deleted_flag();
2660                 break;
2661         case 6:
2662                 testapp_test_expunge_mails_deleted_flagged();
2663                 break;
2664         case 7:
2665                 testapp_test_send_read_receipt();
2666                 break;
2667         case 8:
2668                 testapp_test_delete_attachment();
2669                 break;
2670         case 9:
2671                 testapp_test_count();
2672                 break;
2673         case 10:
2674                 testapp_test_move_mails_to_mailbox_of_another_account();
2675                 break;
2676         case 11:
2677                 testapp_test_send_mail_with_downloading_attachment_of_original_mail();
2678                 break;
2679         case 12:
2680                 testapp_test_get_mail_data();
2681                 break;
2682         case 13:
2683                 testapp_test_schedule_sending_mail();
2684                 break;
2685         case 14:
2686                 testapp_test_delete();
2687                 break;
2688         case 15:
2689                 testapp_test_update_mail_attribute();
2690                 break;
2691         case 16:
2692                 testapp_test_download_body();
2693                 break;
2694         case 17:
2695                 testapp_test_download_attachment();
2696                 break;
2697         case 18:
2698                 testapp_test_get_attachment_data_list();
2699                 break;
2700         case 19:
2701                 testapp_test_get_meeting_request();
2702                 break;
2703         case 20:
2704                 testapp_test_delete_all();
2705                 break;
2706         case 21:
2707                 testapp_test_move();
2708                 break;
2709         case 23:
2710                 testapp_test_retry_send();
2711                 break;
2712         case 24:
2713                 testapp_test_get_attachment_data();
2714                 break;
2715         case 27:
2716                 testapp_test_move_all_mails_to_mailbox();
2717                 break;
2718         case 38:
2719                 testapp_test_get_totaldiskusage();
2720                 break;
2721         case 40:
2722                 testapp_test_address_format_check_test();
2723                 break;
2724         case 41:
2725                 testapp_test_get_max_mail_count();
2726                 break;
2727         case 42:
2728                 testapp_test_db_test();
2729                 break;
2730         case 43:
2731                 testapp_test_send_cancel();
2732                 break;
2733         case 44:
2734                 testapp_test_cancel_download_body();
2735                 break;
2736         case 46:
2737                 testapp_test_get_mail_list_for_thread_view();
2738                 break;
2739         case 48:
2740                 testapp_test_test_get_thread_information();
2741                 break;
2742         case 51:
2743                 testapp_test_get_mail_list();
2744                 break;
2745         case 52:
2746                 testapp_test_get_address_info_list();
2747                 break;
2748         case 55:
2749                 testapp_test_set_flags_field();
2750                 break;
2751         case 56:
2752                 testapp_test_add_mail(NULL);
2753                 break;
2754         case 57:
2755                 testapp_test_update_mail();
2756                 break;
2757         case 58:
2758                 testapp_test_search_mail_on_server();
2759                 break;
2760         case 59:
2761                 testapp_test_add_mail_to_search_result_box();
2762                 break;
2763         case 60:
2764                 testapp_test_email_parse_mime_file();
2765                 break;
2766         case 61:
2767                 testapp_test_email_write_mime_file();
2768                 break;
2769         case 62:
2770                 testapp_test_smime_verify_signature();
2771                 break;
2772         case 63:
2773                 testapp_test_email_add_mail_with_multiple_recipient();
2774                 break;
2775         case 64:
2776                 testapp_test_send_mails_every_x_minutes();
2777                 break;
2778         case 0:
2779                 go_to_loop = FALSE;
2780                 break;
2781         default:
2782                 break;
2783         }
2784
2785         return go_to_loop;
2786 }
2787
2788 void testapp_mail_main()
2789 {
2790         gboolean go_to_loop = TRUE;
2791         int menu_number = 0;
2792
2793         while (go_to_loop) {
2794                 testapp_show_menu(EMAIL_MAIL_MENU);
2795                 testapp_show_prompt(EMAIL_MAIL_MENU);
2796
2797                 if (0 >= scanf("%d", &menu_number))
2798                         testapp_print("Invalid input");
2799
2800                 go_to_loop = testapp_test_interpret_command(menu_number);
2801         }
2802 }
2803