branches/plugfest/utils/mapitest/modules/module_oxcstor.c

   1 /*
   2    Stand-alone MAPI testsuite
   3
   4    OpenChange Project - STORE OBJECT PROTOCOL operations
   5
   6    Copyright (C) Julien Kerihuel 2008
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "utils/mapitest/mapitest.h"
  23 #include "utils/mapitest/proto.h"
  24 #include "libmapi/libmapi_private.h"
  25
  26 /**
  27    \file module_oxcstor.c
  28
  29    \brief Store Object Protocol test suite
  30 */
  31
  32
  33 /**
  34    \details Test the Logon (0xFE) operation
  35
  36    This function:
  37    -# Log on the user private mailbox
  38    -# Log on the public folder store
  39
  40    \param mt pointer on the top-level mapitest structure
  41
  42    \return true on success, otherwise false
  43  */
  44 _PUBLIC_ bool mapitest_oxcstor_Logon(struct mapitest *mt)
  45 {
  46         enum MAPISTATUS         retval;
  47         mapi_object_t           obj_store;
  48
  49         /* Step 1. Logon Private Mailbox */
  50         mapi_object_init(&obj_store);
  51         retval = OpenMsgStore(mt->session, &obj_store);
  52         mapitest_print_retval(mt, "OpenMsgStore");
  53         if (GetLastError() != MAPI_E_SUCCESS) {
  54                 return false;
  55         }
  56         mapi_object_release(&obj_store);
  57
  58         /* Step 2. Logon Public Folder store */
  59         mapi_object_init(&obj_store);
  60         retval = OpenPublicFolder(mt->session, &obj_store);
  61         mapitest_print_retval(mt, "OpenPublicFolder");
  62         if (GetLastError() != MAPI_E_SUCCESS) {
  63                 return false;
  64         }
  65         mapi_object_release(&obj_store);
  66
  67         return true;
  68 }
  69
  70
  71 /**
  72    \details Test the GetReceiveFolder (0x27) operation
  73
  74    This function:
  75    -# Log on the user private mailbox
  76    -# Call the GetReceiveFolder operation
  77    -# Call the GetReceiveFolder with different explicit message class values
  78
  79    \param mt the top-level mapitest structure
  80
  81    \return true on success, otherwise false
  82  */
  83 _PUBLIC_ bool mapitest_oxcstor_GetReceiveFolder(struct mapitest *mt)
  84 {
  85         enum MAPISTATUS         retval;
  86         mapi_object_t           obj_store;
  87         mapi_id_t               receivefolder = 0;
  88         bool                    ret = true;
  89
  90         /* Step 1. Logon */
  91         mapi_object_init(&obj_store);
  92         retval = OpenMsgStore(mt->session, &obj_store);
  93         mapitest_print_retval_clean(mt, "OpenMsgStore", retval);
  94         if (retval != MAPI_E_SUCCESS) {
  95                 ret = false;
  96                 goto release;
  97         }
  98
  99         /* Step 2. Call the GetReceiveFolder operation */
 100         retval = GetReceiveFolder(&obj_store, &receivefolder, NULL);
 101         mapitest_print_retval_clean(mt, "GetReceiveFolder for All target", retval);
 102         mapitest_print(mt, "FID: 0x%016"PRIx64"\n", receivefolder);
 103         if (retval != MAPI_E_SUCCESS) {
 104                 ret = false;
 105                 goto release;
 106         }
 107
 108         /* Step 3. Call GetReceiveFolder again, with an explicit message class */
 109         retval = GetReceiveFolder(&obj_store, &receivefolder, "IPC");
 110         mapitest_print_retval_clean(mt, "GetReceiveFolder for IPC", retval);
 111         mapitest_print(mt, "FID: 0x%016"PRIx64"\n", receivefolder);
 112         if (retval != MAPI_E_SUCCESS) {
 113                 ret = false;
 114                 goto release;
 115         }
 116
 117         /* Step 4. Call GetReceiveFolder again, with an explicit message class */
 118         retval = GetReceiveFolder(&obj_store, &receivefolder, "IPM.FooBarBaz");
 119         mapitest_print_retval_clean(mt, "GetReceiveFolder for IPM.FooBarBaz", retval);
 120         mapitest_print(mt, "FID: 0x%016"PRIx64"\n", receivefolder);
 121         if (retval != MAPI_E_SUCCESS) {
 122                 ret = false;
 123                 goto release;
 124         }
 125
 126         /* Step 5. Call GetReceiveFolder again, with an explicit message class */
 127         retval = GetReceiveFolder(&obj_store, &receivefolder, "MT.Mapitest.tc");
 128         mapitest_print_retval_clean(mt, "GetReceiveFolder for MT.Mapitest.tc", retval);
 129         mapitest_print(mt, "FID: 0x%016"PRIx64"\n", receivefolder);
 130         if (retval != MAPI_E_SUCCESS) {
 131                 ret = false;
 132                 goto release;
 133         }
 134
 135 release:
 136         mapi_object_release(&obj_store);
 137
 138         return ret;
 139 }
 140
 141
 142 /**
 143    \details Test the SetReceiveFolder (0x26) operation
 144
 145    This function:
 146    -# Log on the user private mailbox
 147    -# Call the SetReceiveFolder operations
 148    -# Clean up
 149
 150    \param mt the top-level mapitest structure
 151
 152    \return true on success, otherwise false
 153  */
 154 _PUBLIC_ bool mapitest_oxcstor_SetReceiveFolder(struct mapitest *mt)
 155 {
 156         enum MAPISTATUS         retval;
 157         mapi_object_t           obj_store;
 158         mapi_id_t               id_inbox;
 159         mapi_id_t               id_tis;
 160         mapi_object_t           obj_tis;
 161         mapi_object_t           obj_inbox;
 162         mapi_object_t           obj_folder;
 163         bool                    ret = true;
 164
 165
 166         mapi_object_init(&obj_store);
 167         mapi_object_init(&obj_inbox);
 168         mapi_object_init(&obj_tis);
 169         mapi_object_init(&obj_folder);
 170
 171         /* Step 1. Logon */
 172
 173         retval = OpenMsgStore(mt->session, &obj_store);
 174         mapitest_print_retval_step(mt, "1.", "Logon", retval);
 175         if (retval != MAPI_E_SUCCESS) {
 176                 ret = false;
 177                 goto cleanup;
 178         }
 179
 180         /* Step 2. Get the original ReceiveFolder */
 181         retval = GetReceiveFolder(&obj_store, &id_inbox, NULL);
 182         mapitest_print_retval_step(mt, "2.", "GetReceiveFolder", retval);
 183         if (retval != MAPI_E_SUCCESS) {
 184                 ret = false;
 185                 goto cleanup;
 186         }
 187
 188         /* Step 3. Open the ReceiveFolder */
 189         retval = OpenFolder(&obj_store, id_inbox, &obj_inbox);
 190         mapitest_print_retval_step(mt, "3.", "OpenFolder", retval);
 191         if (retval != MAPI_E_SUCCESS) {
 192                 ret = false;
 193                 goto cleanup;
 194         }
 195
 196         /* Step 4. Open the Top Information Store folder */
 197         retval = GetDefaultFolder(&obj_store, &id_tis, olFolderTopInformationStore);
 198         mapitest_print_retval_step(mt, "4.", "GetDefaultFolder", retval);
 199         if (retval != MAPI_E_SUCCESS) {
 200                 ret = false;
 201                 goto cleanup;
 202         }
 203
 204         retval = OpenFolder(&obj_store, id_tis, &obj_tis);
 205         mapitest_print_retval_step(mt, "4.1.", "OpenFolder", retval);
 206         if (retval != MAPI_E_SUCCESS) {
 207                 ret = false;
 208                 goto cleanup;
 209         }
 210
 211         /* Create the New Inbox folder under Top Information Store */
 212         retval = CreateFolder(&obj_tis, FOLDER_GENERIC, "New Inbox", NULL,
 213                               OPEN_IF_EXISTS, &obj_folder);
 214         mapitest_print_retval_step(mt, "5.", "CreateFolder", retval);
 215         if (retval != MAPI_E_SUCCESS) {
 216                 ret = false;
 217                 goto cleanup;
 218         }
 219
 220         /* Set IPM.Note receive folder to New Inbox */
 221         retval = SetReceiveFolder(&obj_store, &obj_folder, "IPM.Note");
 222         mapitest_print_retval_step_fmt(mt, "6.", "SetReceiveFolder", "%s", "(New Inbox)", retval);
 223         if (retval != MAPI_E_SUCCESS) {
 224                 ret = false;
 225                 goto cleanup;
 226         }
 227
 228         /* Reset receive folder to Inbox */
 229         retval = SetReceiveFolder(&obj_store, &obj_inbox, "IPM.Note");
 230         mapitest_print_retval_step_fmt(mt, "6.1.", "SetReceiveFolder", "%s", "(original folder)", retval);
 231         if (retval != MAPI_E_SUCCESS) {
 232                 ret = false;
 233                 goto cleanup;
 234         }
 235
 236         /* Set a test message class */
 237         retval = SetReceiveFolder(&obj_store, &obj_folder, "MT.Mapitest.ta");
 238         mapitest_print_retval_step_fmt(mt, "7.", "SetReceiveFolder", "%s", "(MT.Mapitest.ta)", retval);
 239         if (retval != MAPI_E_SUCCESS) {
 240                 ret = false;
 241                 goto cleanup;
 242         }
 243
 244         /* Delete New Inbox folder */
 245         retval = EmptyFolder(&obj_folder);
 246         mapitest_print_retval_step(mt, "8.", "EmptyFolder", retval);
 247         if (retval != MAPI_E_SUCCESS) {
 248                 ret = false;
 249                 goto cleanup;
 250         }
 251
 252         retval = DeleteFolder(&obj_tis, mapi_object_get_id(&obj_folder),
 253                               DEL_FOLDERS | DEL_MESSAGES | DELETE_HARD_DELETE, NULL);
 254         mapitest_print_retval_step(mt, "9.", "DeleteFolder", retval);
 255         if (retval != MAPI_E_SUCCESS) {
 256                 ret = false;
 257                 goto cleanup;
 258         }
 259
 260 cleanup:
 261         /* Release */
 262         mapi_object_release(&obj_folder);
 263         mapi_object_release(&obj_tis);
 264         mapi_object_release(&obj_inbox);
 265         mapi_object_release(&obj_store);
 266
 267         return ret;
 268 }
 269
 270
 271 /**
 272    \details Test the GetOwningServers (0x42) operation
 273
 274    This function:
 275    -# Log on the public folders store
 276    -# Open a public folder
 277    -# Call the GetOwningServers operation
 278
 279    \param mt the top-level mapitest structure
 280
 281    \return true on success, otherwise false
 282 */
 283 _PUBLIC_ bool mapitest_oxcstor_GetOwningServers(struct mapitest *mt)
 284 {
 285         enum MAPISTATUS         retval;
 286         bool                    ret = true;
 287         mapi_object_t           obj_store;
 288         mapi_object_t           obj_folder;
 289         uint64_t                folderId;
 290         uint16_t                OwningServersCount;
 291         uint16_t                CheapServersCount;
 292         char                    *OwningServers;
 293
 294         /* Step 1. Logon */
 295         mapi_object_init(&obj_store);
 296         retval = OpenPublicFolder(mt->session, &obj_store);
 297         mapitest_print_retval(mt, "OpenPublicFolder");
 298         if (GetLastError() != MAPI_E_SUCCESS) {
 299                 return false;
 300         }
 301
 302         /* Step 2. Open IPM Subtree folder */
 303         retval = GetDefaultPublicFolder(&obj_store, &folderId, olFolderPublicIPMSubtree);
 304         mapitest_print_retval(mt, "GetDefaultPublicFolder");
 305         if (GetLastError() != MAPI_E_SUCCESS) {
 306                 ret = false;
 307                 goto cleanup;
 308         }
 309
 310         mapi_object_init(&obj_folder);
 311         retval = OpenFolder(&obj_store, folderId, &obj_folder);
 312         mapitest_print_retval(mt, "OpenFolder");
 313         if (GetLastError() != MAPI_E_SUCCESS) {
 314                 ret = false;
 315                 goto cleanup;
 316         }
 317
 318         /* Step 3. Call GetOwningServers */
 319         retval = GetOwningServers(&obj_store, &obj_folder, &OwningServersCount, &CheapServersCount, &OwningServers);
 320         mapitest_print_retval(mt, "GetOwningServers");
 321         if (GetLastError() != MAPI_E_SUCCESS && GetLastError() != ecNoReplicaAvailable) {
 322                 ret = false;
 323         } else if (GetLastError() == ecNoReplicaAvailable) {
 324                 mapitest_print(mt, "* %-35s: No active replica for the folder\n", "GetOwningServers");
 325         } else {
 326                 mapitest_print(mt, "* %-35s: OwningServersCount: %d\n", "PublicFolderIsGhosted", OwningServersCount);
 327                 if (OwningServersCount) {
 328                         uint16_t        i;
 329
 330                         for (i = 0; i < OwningServersCount; i++) {
 331                                 mapitest_print(mt, "* %-35s: OwningServers: %s\n", "GetOwningServers", &OwningServers[i]);
 332                         }
 333                         talloc_free(&OwningServers);
 334                 }
 335         }
 336
 337         /* cleanup objects */
 338         mapi_object_release(&obj_folder);
 339
 340 cleanup:
 341         mapi_object_release(&obj_store);
 342
 343         return ret;
 344 }
 345
 346 /**
 347    \details Test the PublicFolderIsGhosted (0x45) operation
 348
 349    This function:
 350    -# Log on the public folders store
 351    -# Open a public folder
 352    -# Call the PublicFolderIsGhosted operation
 353
 354    \param mt the top-level mapitest structure
 355
 356    \return true on success, otherwise false
 357 */
 358 _PUBLIC_ bool mapitest_oxcstor_PublicFolderIsGhosted(struct mapitest *mt)
 359 {
 360         enum MAPISTATUS         retval;
 361         bool                    ret = true;
 362         mapi_object_t           obj_store;
 363         mapi_object_t           obj_folder;
 364         uint64_t                folderId;
 365         bool                    IsGhosted;
 366
 367         /* Step 1. Logon */
 368         mapi_object_init(&obj_store);
 369         mapi_object_init(&obj_folder);
 370
 371         retval = OpenPublicFolder(mt->session, &obj_store);
 372         mapitest_print_retval(mt, "OpenPublicFolder");
 373         if (GetLastError() != MAPI_E_SUCCESS) {
 374                 return false;
 375         }
 376
 377         /* Step 2. Open IPM Subtree folder */
 378         retval = GetDefaultPublicFolder(&obj_store, &folderId, olFolderPublicIPMSubtree);
 379         mapitest_print_retval(mt, "GetDefaultPublicFolder");
 380         if (GetLastError() != MAPI_E_SUCCESS) {
 381                 ret = false;
 382                 goto cleanup;
 383         }
 384
 385         retval = OpenFolder(&obj_store, folderId, &obj_folder);
 386         mapitest_print_retval(mt, "OpenFolder");
 387         if (GetLastError() != MAPI_E_SUCCESS) {
 388                 ret = false;
 389                 goto cleanup;
 390         }
 391
 392         /* Step 3. Call PublicFolderIsGhosted */
 393         retval = PublicFolderIsGhosted(&obj_store, &obj_folder, &IsGhosted);
 394         mapitest_print_retval(mt, "PublicFolderIsGhosted");
 395         if (GetLastError() != MAPI_E_SUCCESS) {
 396                 ret = false;
 397                 goto cleanup;
 398         }
 399         mapitest_print(mt, "* %-35s: IsGhosted is set to %s\n", "PublicFolderIsGhosted", ((IsGhosted) ? "true" : "false"));
 400
 401 cleanup:
 402         mapi_object_release(&obj_folder);
 403         mapi_object_release(&obj_store);
 404
 405         return ret;
 406 }
 407
 408
 409 /**
 410    \details Test the GetReceiveFolderTable (0x68) operation
 411
 412    This function:
 413    -# Log on the user private mailbox
 414    -# Call the GetReceiveFolderTable operation
 415
 416    \param mt the top-level mapitest structure
 417
 418    \return true on success, otherwise false
 419  */
 420 _PUBLIC_ bool mapitest_oxcstor_GetReceiveFolderTable(struct mapitest *mt)
 421 {
 422         enum MAPISTATUS         retval;
 423         mapi_object_t           obj_store;
 424         struct SRowSet          SRowSet;
 425
 426         /* Step 1. Logon */
 427         mapi_object_init(&obj_store);
 428         retval = OpenMsgStore(mt->session, &obj_store);
 429         mapitest_print_retval(mt, "OpenMsgStore");
 430         if (GetLastError() != MAPI_E_SUCCESS) {
 431                 return false;
 432         }
 433
 434         /* Step 2. Call the GetReceiveFolderTable operation */
 435         retval = GetReceiveFolderTable(&obj_store, &SRowSet);
 436         mapitest_print_retval(mt, "GetReceiveFolderTable");
 437         if (GetLastError() != MAPI_E_SUCCESS) {
 438                 return false;
 439         }
 440
 441         mapitest_print_SRowSet(mt, &SRowSet, "\t\t[*]");
 442         MAPIFreeBuffer(SRowSet.aRow);
 443
 444         /* Release */
 445         mapi_object_release(&obj_store);
 446
 447         return true;
 448 }
 449
 450 /**
 451    \details Test the LongTermIdFromId (0x43) and IdFromLongTermId (0x44)
 452    operations
 453
 454    This function:
 455    -# Logs into the user private mailbox
 456    -# Open the Receive Folder
 457    -# Looks up the long term id for the receive folder FID
 458    -# Looks up the short term id for the long term id
 459    -# Checks the id matches the original FID
 460
 461    \param mt pointer on the top-level mapitest structure
 462
 463    \return true on success, otherwise false
 464  */
 465 _PUBLIC_ bool mapitest_oxcstor_LongTermId(struct mapitest *mt)
 466 {
 467         mapi_object_t           obj_store;
 468         mapi_id_t               id_inbox;
 469         struct LongTermId       long_term_id;
 470         mapi_id_t               id_check;
 471         bool                    ret = true;
 472
 473         /* Step 1. Logon Private Mailbox */
 474         mapi_object_init(&obj_store);
 475         OpenMsgStore(mt->session, &obj_store);
 476         mapitest_print_retval(mt, "OpenMsgStore");
 477         if (GetLastError() != MAPI_E_SUCCESS) {
 478                 ret = false;
 479                 goto cleanup;
 480         }
 481
 482         /* Step 2. Call the GetReceiveFolder operation */
 483         GetReceiveFolder(&obj_store, &id_inbox, "IPF.Post");
 484         mapitest_print_retval(mt, "GetReceiveFolder");
 485         if (GetLastError() != MAPI_E_SUCCESS) {
 486                 ret = false;
 487                 goto cleanup;
 488         }
 489
 490         /* Step 3. Call GetLongTermIdFromId on Folder ID */
 491         GetLongTermIdFromId(&obj_store, id_inbox, &long_term_id);
 492         mapitest_print_retval(mt, "GetLongTermIdFromId");
 493         if (GetLastError() != MAPI_E_SUCCESS) {
 494                 ret = false;
 495                 goto cleanup;
 496         }
 497
 498         /* Step 4. Call GetIdFromLongTermId on LongTermId from previous step*/
 499         GetIdFromLongTermId(&obj_store, long_term_id, &id_check);
 500         mapitest_print_retval(mt, "GetIdFromLongTermId");
 501         if (GetLastError() != MAPI_E_SUCCESS) {
 502                 ret = false;
 503                 goto cleanup;
 504         }
 505
 506         /* Step 5. Check whether ids are the same */
 507         if ( id_check == id_inbox ) {
 508                 mapitest_print(mt, "* Check: IDs match - [SUCCESS]\n" );
 509         } else {
 510                 mapitest_print(mt, "* Check: IDs do not match - [SUCCESS] (0x%x, expected 0x%x)\n",
 511                                id_check, id_inbox);
 512                 ret=false;
 513                 goto cleanup;
 514         }
 515
 516  cleanup:
 517         /* Release */
 518         mapi_object_release(&obj_store);
 519
 520         return ret;
 521 }
 522
 523
 524 /**
 525    \details Test the GetStoreState (0x7b) operation
 526
 527    This function:
 528    -# Logs into the user private mailbox
 529    -# Retrieve the store state
 530
 531    \param mt pointer on the top-level mapitest structure
 532
 533    \return true on success, otherwise false
 534  */
 535 _PUBLIC_ bool mapitest_oxcstor_GetStoreState(struct mapitest *mt)
 536 {
 537         mapi_object_t   obj_store;
 538         uint32_t        StoreState = 0;
 539         bool            ret = true;
 540
 541         /* Step 1. Logon Private Mailbox */
 542         mapi_object_init(&obj_store);
 543         OpenMsgStore(mt->session, &obj_store);
 544         mapitest_print_retval(mt, "OpenMsgStore");
 545         if (GetLastError() != MAPI_E_SUCCESS) {
 546                 return false;
 547         }
 548
 549         /* Step 2. Get the store state */
 550         GetStoreState(&obj_store, &StoreState);
 551         mapitest_print_retval(mt, "GetStoreState");
 552         if (GetLastError() != MAPI_E_SUCCESS) {
 553                 ret = false;
 554         }
 555
 556         mapi_object_release(&obj_store);
 557         return ret;
 558 }
 559
 560 /**
 561    \details Test the IsMailboxFolder convenience function
 562
 563    This function:
 564    -# Logs into the user private mailbox
 565
 566    \param mt pointer on the top-level mapitest structure
 567
 568    \return true on success, otherwise false
 569  */
 570 _PUBLIC_ bool mapitest_oxcstor_IsMailboxFolder(struct mapitest *mt)
 571 {
 572         mapi_object_t           obj_store;
 573         mapi_object_t           obj_pf_store;
 574         bool                    ret = true;
 575         mapi_object_store_t *   store;
 576         mapi_object_store_t *   pf_store;
 577         uint32_t                olFolderNumber;
 578         bool                    callResult;
 579         enum MAPISTATUS         retval;
 580
 581         mapi_object_init(&obj_store);
 582         mapi_object_init(&obj_pf_store);
 583
 584         /* Step 1. Logon Private Mailbox */
 585         retval = OpenMsgStore(mt->session, &obj_store);
 586         mapitest_print_retval(mt, "OpenMsgStore");
 587         if (retval != MAPI_E_SUCCESS) {
 588                 ret = false;
 589                 goto cleanup;
 590         }
 591
 592         store = (mapi_object_store_t *) obj_store.private_data;
 593         if (! store) {
 594                 mapitest_print(mt, "* FAILED to get store private_data\n" );
 595                 ret = false;
 596                 goto cleanup;
 597         }
 598
 599         callResult = IsMailboxFolder(&obj_store, store->fid_top_information_store, &olFolderNumber);
 600         if (! callResult) {
 601                 mapitest_print(mt, "* FAILED to get folder number for top_information_store\n");
 602                 ret = false;
 603                 goto cleanup;
 604         }
 605         if (olFolderNumber != olFolderTopInformationStore) {
 606                 mapitest_print(mt, "* FAILED - wrong folder number for top_information_store\n");
 607                 ret = false;
 608                 goto cleanup;
 609         }
 610
 611         callResult = IsMailboxFolder(&obj_store, store->fid_deleted_items, &olFolderNumber);
 612         if (! callResult) {
 613                 mapitest_print(mt, "* FAILED to get folder number for deleted_items\n");
 614                 ret = false;
 615                 goto cleanup;
 616         }
 617         if (olFolderNumber != olFolderDeletedItems) {
 618                 mapitest_print(mt, "* FAILED - wrong folder number for deleted_items\n");
 619                 ret = false;
 620                 goto cleanup;
 621         }
 622
 623         callResult = IsMailboxFolder(&obj_store, store->fid_outbox, &olFolderNumber);
 624         if (! callResult) {
 625                 mapitest_print(mt, "* FAILED to get folder number for outbox\n");
 626                 ret = false;
 627                 goto cleanup;
 628         }
 629         if (olFolderNumber != olFolderOutbox) {
 630                 mapitest_print(mt, "* FAILED - wrong folder number for outbox\n");
 631                 ret = false;
 632                 goto cleanup;
 633         }
 634
 635         callResult = IsMailboxFolder(&obj_store, store->fid_sent_items, &olFolderNumber);
 636         if (! callResult) {
 637                 mapitest_print(mt, "* FAILED to get folder number for sent items\n");
 638                 ret = false;
 639                 goto cleanup;
 640         }
 641         if (olFolderNumber != olFolderSentMail) {
 642                 mapitest_print(mt, "* FAILED - wrong folder number for sent items\n");
 643                 ret = false;
 644                 goto cleanup;
 645         }
 646
 647         callResult = IsMailboxFolder(&obj_store, store->fid_inbox, &olFolderNumber);
 648         if (! callResult) {
 649                 mapitest_print(mt, "* FAILED to get folder number for inbox\n");
 650                 ret = false;
 651                 goto cleanup;
 652         }
 653         if (olFolderNumber != olFolderInbox) {
 654                 mapitest_print(mt, "* FAILED - wrong folder number for inbox\n");
 655                 ret = false;
 656                 goto cleanup;
 657         }
 658
 659         callResult = IsMailboxFolder(&obj_store, store->fid_common_views, &olFolderNumber);
 660         if (! callResult) {
 661                 mapitest_print(mt, "* FAILED to get folder number for views\n");
 662                 ret = false;
 663                 goto cleanup;
 664         }
 665         if (olFolderNumber != olFolderCommonView) {
 666                 mapitest_print(mt, "* FAILED - wrong folder number for views\n");
 667                 ret = false;
 668                 goto cleanup;
 669         }
 670
 671         callResult = IsMailboxFolder(&obj_store, store->fid_calendar, &olFolderNumber);
 672         if (! callResult) {
 673                 mapitest_print(mt, "* FAILED to get folder number for calendar\n");
 674                 ret = false;
 675                 goto cleanup;
 676         }
 677         if (olFolderNumber != olFolderCalendar) {
 678                 mapitest_print(mt, "* FAILED - wrong folder number for calendar\n");
 679                 ret = false;
 680                 goto cleanup;
 681         }
 682
 683         callResult = IsMailboxFolder(&obj_store, store->fid_contact, &olFolderNumber);
 684         if (! callResult) {
 685                 mapitest_print(mt, "* FAILED to get folder number for contacts\n");
 686                 ret = false;
 687                 goto cleanup;
 688         }
 689         if (olFolderNumber != olFolderContacts) {
 690                 mapitest_print(mt, "* FAILED - wrong folder number for contacts\n");
 691                 ret = false;
 692                 goto cleanup;
 693         }
 694
 695         callResult = IsMailboxFolder(&obj_store, store->fid_journal, &olFolderNumber);
 696         if (! callResult) {
 697                 mapitest_print(mt, "* FAILED to get folder number for journal\n");
 698                 ret = false;
 699                 goto cleanup;
 700         }
 701         if (olFolderNumber != olFolderJournal) {
 702                 mapitest_print(mt, "* FAILED - wrong folder number for journal\n");
 703                 ret = false;
 704                 goto cleanup;
 705         }
 706
 707         callResult = IsMailboxFolder(&obj_store, store->fid_note, &olFolderNumber);
 708         if (! callResult) {
 709                 mapitest_print(mt, "* FAILED to get folder number for notes\n");
 710                 ret = false;
 711                 goto cleanup;
 712         }
 713         if (olFolderNumber != olFolderNotes) {
 714                 mapitest_print(mt, "* FAILED - wrong folder number for note\n");
 715                 ret = false;
 716                 goto cleanup;
 717         }
 718
 719         callResult = IsMailboxFolder(&obj_store, store->fid_task, &olFolderNumber);
 720         if (! callResult) {
 721                 mapitest_print(mt, "* FAILED to get folder number for tasks\n");
 722                 ret = false;
 723                 goto cleanup;
 724         }
 725         if (olFolderNumber != olFolderTasks) {
 726                 mapitest_print(mt, "* FAILED - wrong folder number for tasks\n");
 727                 ret = false;
 728                 goto cleanup;
 729         }
 730
 731         callResult = IsMailboxFolder(&obj_store, store->fid_drafts, &olFolderNumber);
 732         if (! callResult) {
 733                 mapitest_print(mt, "* FAILED to get folder number for drafts\n");
 734                 ret = false;
 735                 goto cleanup;
 736         }
 737         if (olFolderNumber != olFolderDrafts) {
 738                 mapitest_print(mt, "* FAILED - wrong folder number for drafts\n");
 739                 ret = false;
 740                 goto cleanup;
 741         }
 742
 743         callResult = IsMailboxFolder(&obj_store, store->fid_search, &olFolderNumber);
 744         if (! callResult) {
 745                 mapitest_print(mt, "* FAILED to get folder number for search\n");
 746                 ret = false;
 747                 goto cleanup;
 748         }
 749         if (olFolderNumber != olFolderFinder) {
 750                 mapitest_print(mt, "* FAILED - wrong folder number for search\n");
 751                 ret = false;
 752                 goto cleanup;
 753         }
 754
 755         retval = OpenPublicFolder(mt->session, &obj_pf_store);
 756         mapitest_print_retval(mt, "OpenPublicFolder");
 757         if (retval != MAPI_E_SUCCESS) {
 758                 ret = false;
 759                 goto cleanup;
 760         }
 761
 762         pf_store = (mapi_object_store_t *) obj_pf_store.private_data;
 763
 764         callResult = IsMailboxFolder(&obj_pf_store, pf_store->fid_pf_OfflineAB, &olFolderNumber);
 765         if (! callResult) {
 766                 mapitest_print(mt, "* FAILED to get folder number for offline address book\n");
 767                 ret = false;
 768                 goto cleanup;
 769         }
 770         if (olFolderNumber != olFolderPublicOfflineAB) {
 771                 mapitest_print(mt, "* FAILED - wrong folder number for offline address book\n");
 772                 ret = false;
 773                 goto cleanup;
 774         }
 775
 776         callResult = IsMailboxFolder(&obj_pf_store, pf_store->fid_pf_FreeBusyRoot, &olFolderNumber);
 777         if (! callResult) {
 778                 mapitest_print(mt, "* FAILED to get folder number for free-busy root\n");
 779                 ret = false;
 780                 goto cleanup;
 781         }
 782         if (olFolderNumber != olFolderPublicFreeBusyRoot) {
 783                 mapitest_print(mt, "* FAILED - wrong folder number for free-busy root\n");
 784                 ret = false;
 785                 goto cleanup;
 786         }
 787
 788         callResult = IsMailboxFolder(&obj_pf_store, pf_store->fid_pf_EFormsRegistryRoot, &olFolderNumber);
 789         if (! callResult) {
 790                 mapitest_print(mt, "* FAILED to get folder number for EForms root\n");
 791                 ret = false;
 792                 goto cleanup;
 793         }
 794         if (olFolderNumber != olFolderPublicEFormsRoot) {
 795                 mapitest_print(mt, "* FAILED - wrong folder number for EForms root\n");
 796                 ret = false;
 797                 goto cleanup;
 798         }
 799
 800         /* this one is a bit sensitive. sometimes the EFormsRegistry is null */
 801         callResult = IsMailboxFolder(&obj_pf_store, pf_store->fid_pf_EFormsRegistry, &olFolderNumber);
 802         if (pf_store->fid_pf_EFormsRegistry != 0) {
 803                 if (! callResult) {
 804                         mapitest_print(mt, "* FAILED to get folder number for EForms registry\n");
 805                         ret = false;
 806                         goto cleanup;
 807                 }
 808                 if (olFolderNumber != olFolderPublicEFormsRegistry) {
 809                         mapitest_print(mt, "* FAILED - wrong folder number for EForms registry\n");
 810                         ret = false;
 811                         goto cleanup;
 812                 }
 813         }
 814
 815         callResult = IsMailboxFolder(&obj_pf_store, pf_store->fid_pf_public_root, &olFolderNumber);
 816         if (! callResult) {
 817                 mapitest_print(mt, "* FAILED to get folder number for Public root\n");
 818                 ret = false;
 819                 goto cleanup;
 820         }
 821         if (olFolderNumber != olFolderPublicRoot) {
 822                 mapitest_print(mt, "* FAILED - wrong folder number for Public root\n");
 823                 ret = false;
 824                 goto cleanup;
 825         }
 826
 827         callResult = IsMailboxFolder(&obj_pf_store, pf_store->fid_pf_ipm_subtree, &olFolderNumber);
 828         if (! callResult) {
 829                 mapitest_print(mt, "* FAILED to get folder number for IPM subtree\n");
 830                 ret = false;
 831                 goto cleanup;
 832         }
 833         if (olFolderNumber != olFolderPublicIPMSubtree) {
 834                 mapitest_print(mt, "* FAILED - wrong folder number for IPM subtree\n");
 835                 ret = false;
 836                 goto cleanup;
 837         }
 838
 839         callResult = IsMailboxFolder(&obj_pf_store, pf_store->fid_pf_non_ipm_subtree, &olFolderNumber);
 840         if (! callResult) {
 841                 mapitest_print(mt, "* FAILED to get folder number for non-IPM subtree\n");
 842                 ret = false;
 843                 goto cleanup;
 844         }
 845         if (olFolderNumber != olFolderPublicNonIPMSubtree) {
 846                 mapitest_print(mt, "* FAILED - wrong folder number for non-IPM subtree\n");
 847                 ret = false;
 848                 goto cleanup;
 849         }
 850
 851         callResult = IsMailboxFolder(&obj_pf_store, pf_store->fid_pf_LocalSiteFreeBusy, &olFolderNumber);
 852         if (! callResult) {
 853                 mapitest_print(mt, "* FAILED to get folder number for local free busy folder\n");
 854                 ret = false;
 855                 goto cleanup;
 856         }
 857         if (olFolderNumber != olFolderPublicLocalFreeBusy) {
 858                 mapitest_print(mt, "* FAILED - wrong folder number for local free busy folder\n");
 859                 ret = false;
 860                 goto cleanup;
 861         }
 862
 863         callResult = IsMailboxFolder(&obj_pf_store, pf_store->fid_pf_LocalSiteOfflineAB, &olFolderNumber);
 864         if (! callResult) {
 865                 mapitest_print(mt, "* FAILED to get folder number for local offline address book\n");
 866                 ret = false;
 867                 goto cleanup;
 868         }
 869         if (olFolderNumber != olFolderPublicLocalOfflineAB) {
 870                 mapitest_print(mt, "* FAILED - wrong folder number for local offline address folder\n");
 871                 ret = false;
 872                 goto cleanup;
 873         }
 874
 875         /* this one is a bit sensitive. sometimes the NNTP Articles Folder ID is null */
 876         callResult = IsMailboxFolder(&obj_pf_store, pf_store->fid_pf_NNTPArticle, &olFolderNumber);
 877         if (pf_store->fid_pf_NNTPArticle != 0) {
 878                 if (! callResult) {
 879                         mapitest_print(mt, "* FAILED to get folder number for NNTP Articles\n");
 880                         ret = false;
 881                         goto cleanup;
 882                 }
 883                 if (olFolderNumber != olFolderPublicNNTPArticle) {
 884                         mapitest_print(mt, "* FAILED - wrong folder number for NNTP Articles\n");
 885                         ret = false;
 886                         goto cleanup;
 887                 }
 888         }
 889
 890         /* this is meant to break */
 891         callResult = IsMailboxFolder(&obj_store, 0xFFEEDDCC, &olFolderNumber);
 892         if (callResult) {
 893                 mapitest_print(mt, "* FAILED - expected no folder number\n");
 894                 ret = false;
 895                 goto cleanup;
 896         }
 897         if (olFolderNumber != 0xFFFFFFFF) {
 898                 mapitest_print(mt, "* FAILED - wrong folder number for bad folder id\n");
 899                 ret = false;
 900                 goto cleanup;
 901         }
 902
 903         mapitest_print(mt, "* All PASSED\n");
 904
 905 cleanup:
 906         mapi_object_release(&obj_store);
 907         mapi_object_release(&obj_pf_store);
 908
 909         return ret;
 910 }