/**
\details Test the Compressed RTF compression routine.
This function:
-# Loads some test data and checks it
-# Compresses the test data
-# Checks that the compressed data matches the expected result
\param mt pointer to the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_noserver_rtfcp(struct mapitest *mt)
{
enum MAPISTATUS retval;
uint8_t *compressed;
size_t compressed_length;
char *compressed_hex;
/* compress the test data */
retval = compress_rtf(mt->mem_ctx, RTF_UNCOMPRESSED1, sizeof(RTF_UNCOMPRESSED1) - 1, &compressed, &compressed_length);
if (retval != MAPI_E_SUCCESS) {
mapitest_print_retval(mt, "compress_rtf - step 1 (bad retval)");
return false;
}
/* Check the compressed result matches the compressed array */
compressed_hex = hex_encode_talloc(mt->mem_ctx, compressed, compressed_length);
if (strncasecmp(compressed_hex, RTF_COMPRESSED1_HEX, (size_t)98) != 0) {
mapitest_print(mt, "* %-40s: compare results RTF_COMPRESSED1 - mismatch\n", "RTFCP");
mapitest_print(mt, "- %s\n", RTF_COMPRESSED1_HEX);
mapitest_print(mt, "- %s\n", compressed_hex);
return false;
} else {
mapitest_print(mt, "* %-40s: compare results RTF_COMPRESSED1 - match\n", "RTFCP");
mapitest_print(mt, "- %s\n", RTF_COMPRESSED1_HEX);
mapitest_print(mt, "- %s\n", compressed_hex);
}
talloc_free(compressed_hex);
talloc_free(compressed);
/* compress the test data */
retval = compress_rtf(mt->mem_ctx, RTF_UNCOMPRESSED2, sizeof(RTF_UNCOMPRESSED2) - 1, &compressed, &compressed_length);
if (retval != MAPI_E_SUCCESS) {
mapitest_print_retval(mt, "compress_rtf - step 2 (bad retval)");
return false;
}
// Check the compressed result matches the compressed array.
compressed_hex = hex_encode_talloc(mt->mem_ctx, compressed, compressed_length);
if (strncasecmp(compressed_hex, RTF_COMPRESSED2_HEX, sizeof(RTF_COMPRESSED2_HEX)) != 0) {
mapitest_print(mt, "* %-40s: compare results RTF_COMPRESSED2 - mismatch\n", "RTFCP");
mapitest_print(mt, "- %s\n", RTF_COMPRESSED2_HEX);
mapitest_print(mt, "- %s\n", compressed_hex);
return false;
} else {
mapitest_print(mt, "* %-40s: compare results RTF_COMPRESSED2 - match\n", "RTFCP");
mapitest_print(mt, "- %s\n", RTF_COMPRESSED2_HEX);
mapitest_print(mt, "- %s\n", compressed_hex);
}
talloc_free(compressed_hex);
talloc_free(compressed);
return true;
}
/**
\details Test the RegisterNotification (0x29) operation
This function:
-#
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_oxcnotif_RegisterNotification(struct mapitest *mt)
{
enum MAPISTATUS retval;
bool ret;
mapi_object_t obj_store;
mapi_object_t obj_folder;
struct mapi_session *session;
uint32_t tcon;
/* Step 1. Logon */
mapi_object_init(&obj_store);
retval = OpenMsgStore(mt->session, &obj_store);
mapitest_print_retval(mt, "OpenMsgStore");
if (retval != MAPI_E_SUCCESS) {
return false;
}
/* Step 2. Open Inbox folder */
mapi_object_init(&obj_folder);
ret = mapitest_common_folder_open(mt, &obj_store, &obj_folder, olFolderInbox);
if (!ret) {
return ret;
}
/* Step 3. Register notification */
session = mapi_object_get_session(&obj_store);
retval = RegisterNotification(session);
mapitest_print_retval(mt, "RegisterNotification");
if ( retval != MAPI_E_SUCCESS) {
return false;
}
/* Step 4. Subscribe for notifications */
retval = Subscribe(&obj_store, &tcon, fnevObjectCopied, true, cb, NULL);
mapitest_print_retval(mt, "Subscribe");
if (retval != MAPI_E_SUCCESS) {
return false;
}
/* Step 5. Unsubscribe for notifications */
retval = Unsubscribe(mt->session, tcon);
mapitest_print_retval(mt, "Unsubscribe");
if (retval != MAPI_E_SUCCESS) {
return false;
}
/* Step 6. Cleanup */
mapi_object_release(&obj_folder);
mapi_object_release(&obj_store);
return true;
}
/**
\details Test the QueryColumns (0x37) operation
This function:
-# Opens the Inbox folder and gets the hierarchy table
-# Calls the QueryColumn operation
-# Calls SetColumns on the test folder
-# Checks that QueryColumns on the test folder is correct
-# Cleans up
\param mt pointer to the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_oxctable_QueryColumns(struct mapitest *mt)
{
mapi_object_t obj_htable;
mapi_object_t obj_test_folder;
struct SPropTagArray columns;
struct mt_common_tf_ctx *context;
uint32_t count;
/* Step 1. Logon */
if (! mapitest_common_setup(mt, &obj_htable, NULL)) {
return false;
}
/* Step 2. QueryColumns */
QueryColumns(&obj_htable, &columns);
mapitest_print_retval(mt, "QueryColumns");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
/* Step 3. Get the test folder */
context = mt->priv;
mapi_object_init(&(obj_test_folder));
GetContentsTable(&(context->obj_test_folder), &(obj_test_folder), 0, &count);
mapitest_print_retval(mt, "GetContentsTable");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
if (count != 10) {
mapitest_print(mt, "* %-35s: unexpected count (%i)\n", "GetContentsTable", count);
/* This isn't a hard error for this test though, because it might be from a
previous test failure. Clean up and try again */
}
/* Step 4. QueryColumns on a contents folder */
QueryColumns(&(obj_test_folder), &columns);
mapitest_print_retval(mt, "QueryColumns");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
/* TODO: check the return count against something */
mapitest_print(mt, "column count: %i\n", columns.cValues);
/* Step 6. Release */
mapi_object_release(&obj_htable);
mapi_object_release(&(obj_test_folder));
mapitest_common_cleanup(mt);
return true;
}
/**
\details Test the SetColumns (0x12) operation
This function:
-# Opens the Inbox folder and gets the hierarchy table
-# Calls the SetColumns operation
-# Cleans up
\param mt pointer to the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_oxctable_SetColumns(struct mapitest *mt)
{
mapi_object_t obj_htable;
struct SPropTagArray *SPropTagArray;
/* Step 1. Logon */
if (! mapitest_common_setup(mt, &obj_htable, NULL)) {
return false;
}
/* Step 2. SetColumns */
SPropTagArray = set_SPropTagArray(mt->mem_ctx, 0x3,
PR_DISPLAY_NAME,
PR_FID,
PR_FOLDER_CHILD_COUNT);
SetColumns(&obj_htable, SPropTagArray);
MAPIFreeBuffer(SPropTagArray);
mapitest_print_retval(mt, "SetColumns");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
/* Step 3. Release */
mapi_object_release(&obj_htable);
mapitest_common_cleanup(mt);
return true;
}
/**
\details Test the GetStatus (0x16) operation
This function:
-# Opens the Inbox folder and gets the hierarchy table
-# Call GetStatus
-# Cleans up
*/
_PUBLIC_ bool mapitest_oxctable_GetStatus(struct mapitest *mt)
{
bool ret = true;
mapi_object_t obj_htable;
uint8_t TableStatus;
/* Step 1. Logon */
if (! mapitest_common_setup(mt, &obj_htable, NULL)) {
return false;
}
/* Step 2. GetStatus */
GetStatus(&obj_htable, &TableStatus);
mapitest_print_retval(mt, "GetStatus");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
} else {
mapitest_print(mt, "* %-35s: TableStatus: %d\n", "GetStatus", TableStatus);
}
/* Step 3. Release */
mapi_object_release(&obj_htable);
mapitest_common_cleanup(mt);
return ret;
}
/**
\details Test the NspiUpdateStat RPC operation (0x02)
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_nspi_UpdateStat(struct mapitest *mt)
{
TALLOC_CTX *mem_ctx;
enum MAPISTATUS retval;
struct nspi_context *nspi_ctx;
int32_t plDelta = 1;
struct PropertyRowSet_r *RowSet;
mem_ctx = talloc_named(NULL, 0, "mapitest_nspi_UpdateStat");
nspi_ctx = (struct nspi_context *) mt->session->nspi->ctx;
RowSet = talloc_zero(mem_ctx, struct PropertyRowSet_r);
retval = nspi_GetSpecialTable(nspi_ctx, mem_ctx, 0x2, &RowSet);
MAPIFreeBuffer(RowSet);
if (retval != MAPI_E_SUCCESS) {
talloc_free(mem_ctx);
return false;
}
retval = nspi_UpdateStat(nspi_ctx, mem_ctx, &plDelta);
mapitest_print_retval(mt, "NspiUpdateStat");
if (retval != MAPI_E_SUCCESS) {
talloc_free(mem_ctx);
return false;
}
mapitest_print(mt, "* %-35s: %d\n", "plDelta", plDelta);
talloc_free(mem_ctx);
return true;
}
/**
\details Test the NspiGetPropList RPC operation (0x08)
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_nspi_GetPropList(struct mapitest *mt)
{
TALLOC_CTX *mem_ctx;
enum MAPISTATUS retval;
struct nspi_context *nspi_ctx;
struct SPropTagArray *pPropTags = 0;
struct PropertyTagArray_r *MIds;
struct PropertyValue_r *lpProp;
struct Restriction_r Filter;
struct SPropTagArray *SPropTagArray;
struct PropertyRowSet_r *RowSet;
mem_ctx = talloc_named(NULL, 0, "mapitest_nspi_GetPropList");
nspi_ctx = (struct nspi_context *) mt->session->nspi->ctx;
/* Step 1. Query for current profile username */
SPropTagArray = set_SPropTagArray(mem_ctx, 0x1, PR_DISPLAY_NAME);
lpProp = talloc_zero(mem_ctx, struct PropertyValue_r);
lpProp->ulPropTag = PR_ANR_UNICODE;
lpProp->dwAlignPad = 0;
lpProp->value.lpszW = mt->mapi_ctx->session->profile->username;
Filter.rt = RES_PROPERTY;
Filter.res.resProperty.relop = RES_PROPERTY;
Filter.res.resProperty.ulPropTag = PR_ANR_UNICODE;
Filter.res.resProperty.lpProp = lpProp;
RowSet = talloc_zero(mem_ctx, struct PropertyRowSet_r);
MIds = talloc_zero(mem_ctx, struct PropertyTagArray_r);
retval = nspi_GetMatches(nspi_ctx, mem_ctx, SPropTagArray, &Filter, 5000, &RowSet, &MIds);
MAPIFreeBuffer(SPropTagArray);
MAPIFreeBuffer(lpProp);
MAPIFreeBuffer(RowSet);
if (retval != MAPI_E_SUCCESS) {
MAPIFreeBuffer(MIds);
talloc_free(mem_ctx);
return retval;
}
/* Step 2. Call NspiGetPropList using the MId returned by NspiGetMatches */
pPropTags = talloc_zero(mt->mem_ctx, struct SPropTagArray);
retval = nspi_GetPropList(nspi_ctx, mem_ctx, 0, MIds->aulPropTag[0], &pPropTags);
MAPIFreeBuffer(MIds);
mapitest_print_retval(mt, "NspiGetPropList");
if (retval != MAPI_E_SUCCESS) {
MAPIFreeBuffer(pPropTags);
talloc_free(mem_ctx);
return false;
}
if (pPropTags) {
mapitest_print(mt, "* %-35s: %d\n", "Properties number", pPropTags->cValues);
MAPIFreeBuffer(pPropTags);
}
talloc_free(mem_ctx);
return true;
}
/**
\details Test the NspiGetProps RPC operation (0x09)
\param mt pointer to the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_nspi_GetProps(struct mapitest *mt)
{
TALLOC_CTX *mem_ctx;
enum MAPISTATUS retval;
struct nspi_context *nspi_ctx;
struct StringsArray_r pNames;
struct PropertyTagArray_r *MId;
struct SPropTagArray *SPropTagArray;
struct PropertyRowSet_r *RowSet;
mem_ctx = talloc_named(NULL, 0, "mapitest_nspi_GetProps");
nspi_ctx = (struct nspi_context *) mt->session->nspi->ctx;
pNames.Count = 0x1;
pNames.Strings = (const char **) talloc_array(mem_ctx, char *, 1);
pNames.Strings[0] = mt->mapi_ctx->session->profile->homemdb;
MId = talloc_zero(mem_ctx, struct PropertyTagArray_r);
retval = nspi_DNToMId(nspi_ctx, mem_ctx, &pNames, &MId);
MAPIFreeBuffer((char **)pNames.Strings);
mapitest_print_retval(mt, "NspiDNToMId");
if (retval != MAPI_E_SUCCESS) {
MAPIFreeBuffer(MId);
talloc_free(mem_ctx);
return false;
}
RowSet = talloc_zero(mem_ctx, struct PropertyRowSet_r);
SPropTagArray = set_SPropTagArray(mem_ctx, 0x1, PR_EMS_AB_NETWORK_ADDRESS);
retval = nspi_GetProps(nspi_ctx, mem_ctx, SPropTagArray, MId, &RowSet);
mapitest_print_retval_clean(mt, "NspiGetProps", retval);
MAPIFreeBuffer(SPropTagArray);
MAPIFreeBuffer(MId);
MAPIFreeBuffer(RowSet);
talloc_free(mem_ctx);
if (retval == MAPI_E_SUCCESS) {
return true;
} else {
return false;
}
}
/**
\details Test the SortTable (0x13), ExpandRow (0x59), CollapseRow(0x5a),
GetCollapseState(0x6b) and SetCollapseState (0x6c) operations
This function:
-# Opens the Inbox folder and creates some test content
-# Checks that the content is OK
-# Applies a sort and categorisation
-# Checks the results are as expected.
-# Save away the Row ID and Insatnce Number for the first header
-# Collapse the first category
-# Checks the results are as expected.
-# Save the "collapse state"
-# Expand the first category again
-# Checks the results are as expected
-# Restore the saved "collapse state"
-# Checks the results are as expected
-# Cleans up
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_oxctable_Category(struct mapitest *mt)
{
mapi_object_t obj_htable;
mapi_object_t obj_test_folder;
struct mt_common_tf_ctx *context;
uint32_t count = 0;
uint32_t origcount = 0;
bool ret = true;
struct SSortOrderSet criteria;
uint64_t inst_id = 0;
uint64_t inst_num = 0;
struct SPropTagArray *SPropTagArray;
struct SRowSet SRowSet;
uint32_t rowcount = 0;
uint32_t Numerator = 0;
uint32_t Denominator = 0;
struct SBinary_short collapseState;
/* Step 1. Logon */
if (! mapitest_common_setup(mt, &obj_htable, &count)) {
return false;
}
/* Step 2. Get the test folder */
context = mt->priv;
mapi_object_init(&(obj_test_folder));
GetContentsTable(&(context->obj_test_folder), &(obj_test_folder), 0, &origcount);
if (GetLastError() != MAPI_E_SUCCESS) {
mapitest_print_retval(mt, "GetContentsTable");
ret = false;
goto cleanup;
}
if (origcount != 10) {
mapitest_print(mt, "* %-35s: unexpected count (%i)\n", "GetContentsTable", count);
/* This isn't a hard error for this test though, because it might be from a
previous test failure. Clean up and try again */
}
/* We need the header row InstanceId to fold/unfold the headers */
SPropTagArray = set_SPropTagArray(mt->mem_ctx, 0x6,
PR_SENDER_NAME,
PR_BODY,
PR_LAST_MODIFICATION_TIME,
PR_SUBJECT,
PR_INST_ID,
PR_INSTANCE_NUM);
SetColumns(&(obj_test_folder), SPropTagArray);
MAPIFreeBuffer(SPropTagArray);
mapitest_print_retval(mt, "SetColumns");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
/* Apply a categorised sort */
memset(&criteria, 0x0, sizeof (struct SSortOrderSet));
criteria.cSorts = 1;
criteria.cCategories = 1;
criteria.cExpanded = 1;
criteria.aSort = talloc_array(mt->mem_ctx, struct SSortOrder, criteria.cSorts);
criteria.aSort[0].ulPropTag = PR_SENDER_NAME;
criteria.aSort[0].ulOrder = TABLE_SORT_ASCEND;
SortTable(&(obj_test_folder), &criteria);
mapitest_print_retval(mt, "SortTable");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
rowcount = 2 * origcount;
QueryRows(&(obj_test_folder), rowcount, TBL_ADVANCE, &SRowSet);
mapitest_print_retval(mt, "QueryRows");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
/* Checks the results are as expected */
QueryPosition(&(obj_test_folder), &Numerator, &Denominator);
mapitest_print_retval(mt, "QueryPosition");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
/* the categories are expanded, and there are six unique senders, so there are six
extra rows - one for each header row */
if (Denominator != origcount + 6) {
mapitest_print(mt, "* %-35s: unexpected count (%i)\n", "QueryPosition", Numerator);
ret = false;
goto cleanup;
}
/* save away ID/instance values for first row header */
inst_id = (*(const uint64_t *)get_SPropValue_data(&(SRowSet.aRow[0].lpProps[4])));
inst_num = (*(const uint32_t *)get_SPropValue_data(&(SRowSet.aRow[0].lpProps[5])));
/* Collapse a row header */
CollapseRow(&(obj_test_folder), inst_id, &rowcount);
mapitest_print_retval(mt, "CollapseRow");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
/* Checks the results are as expected */
QueryPosition(&(obj_test_folder), &Numerator, &Denominator);
mapitest_print_retval(mt, "QueryPosition");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
/* there are still six unique headers, but half of the real entries are under the first
header (usually 10, unless we have some other rubbish hanging around), and when we
collapse the first header row, that half disappear */
if (Denominator != origcount/2 + 6) {
mapitest_print(mt, "* %-35s: unexpected count (%i)\n", "QueryPosition", Denominator);
ret = false;
goto cleanup;
}
/* Save the table collapse state */
GetCollapseState(&(obj_test_folder), inst_id, inst_num, &collapseState);
mapitest_print_retval(mt, "GetCollapseState");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
/* Expand a category */
ExpandRow(&(obj_test_folder), inst_id, 20, &SRowSet, &rowcount);
mapitest_print_retval(mt, "ExpandRow");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
/* Checks the results are as expected */
QueryPosition(&(obj_test_folder), &Numerator, &Denominator);
mapitest_print_retval(mt, "QueryPosition");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
/* we've expanded the first header row, so we now get all the entries plus the 6 headers */
if (Denominator != origcount + 6) {
mapitest_print(mt, "* %-35s: unexpected count (%i)\n", "QueryPosition", Denominator);
ret = false;
goto cleanup;
}
/* Restore the collapse state */
SetCollapseState(&(obj_test_folder), &collapseState);
mapitest_print_retval(mt, "SetCollapseState");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
/* Checks the results are as expected */
QueryPosition(&(obj_test_folder), &Numerator, &Denominator);
mapitest_print_retval(mt, "QueryPosition");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
/* back to the situation with the first heading collapsed */
if (Denominator != origcount/2 + 6) {
mapitest_print(mt, "* %-35s: unexpected count (%i)\n", "QueryPosition", Denominator);
ret = false;
goto cleanup;
}
cleanup:
/* Release */
mapi_object_release(&obj_htable);
mapi_object_release(&(obj_test_folder));
mapitest_common_cleanup(mt);
return ret;
}
/**
\details Test the SeekRowBookmark (0x19) operation
This function:
-# Open the Inbox folder and retrieve the hierarchy table
-# Customize the MAPI table view
-# SeekBookmark for each table's row
-# Free Bookmark for each created bookmark
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_oxctable_SeekRowBookmark(struct mapitest *mt)
{
enum MAPISTATUS retval;
mapi_object_t obj_htable;
uint32_t *bkPosition;
uint32_t count;
uint32_t row;
uint32_t i;
struct SPropTagArray *SPropTagArray;
struct SRowSet SRowSet;
/* Step 1. Logon */
if (! mapitest_common_setup(mt, &obj_htable, &count)) {
return false;
}
/* Step 2. Customize the table view */
SPropTagArray = set_SPropTagArray(mt->mem_ctx, 0x3,
PR_DISPLAY_NAME,
PR_FID,
PR_FOLDER_CHILD_COUNT);
retval = SetColumns(&obj_htable, SPropTagArray);
MAPIFreeBuffer(SPropTagArray);
if (retval != MAPI_E_SUCCESS) {
return false;
}
/* Step 3. Create Bookmarks */
bkPosition = talloc_array(mt->mem_ctx, uint32_t, 1);
retval = QueryRows(&obj_htable, 100, TBL_ADVANCE, &SRowSet);
for (i = 0; i < SRowSet.cRows; i++) {
bkPosition = talloc_realloc(mt->mem_ctx, bkPosition, uint32_t, i + 2);
retval = CreateBookmark(&obj_htable, &(bkPosition[i]));
mapitest_print_retval_fmt_clean(mt, "CreateBookmark", retval, "(%.2d)", i);
if (retval != MAPI_E_SUCCESS) {
return false;
}
}
mapitest_print_retval(mt, "CreateBookmark");
retval = mapi_object_bookmark_get_count(&obj_htable, &count);
/* Step 4. SeekRowBookmark */
for (i = 0; i < SRowSet.cRows; i++) {
retval = SeekRowBookmark(&obj_htable, bkPosition[i], 0, &row);
mapitest_print_retval_fmt_clean(mt, "SeekRowBookmark", retval, "(%.2d)", i);
}
/* Step 5. Free Bookmarks */
for (i = 0; i < SRowSet.cRows; i++) {
retval = FreeBookmark(&obj_htable, bkPosition[i]);
mapitest_print_retval_fmt_clean(mt, "FreeBookmark", retval, "(%.2d)", i);
if (retval != MAPI_E_SUCCESS) {
return false;
}
}
/* Step 6. Release */
mapi_object_release(&obj_htable);
mapitest_common_cleanup(mt);
talloc_free(bkPosition);
return true;
}
/**
\details Test the QueryRows (0x15) operation
This function:
-# Opens the Inbox folder and gets the hierarchy table
-# Set the required columns
-# Calls QueryRows until the end of the table
-# Open the test folder, and get its contents
-# Calls QueryRows until the end of the test folder
-# Checks the results are as expected.
-# Cleans up
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_oxctable_QueryRows(struct mapitest *mt)
{
enum MAPISTATUS retval;
mapi_object_t obj_htable;
mapi_object_t obj_test_folder;
struct SRowSet SRowSet;
struct SPropTagArray *SPropTagArray;
struct SPropValue lpProp;
struct mt_common_tf_ctx *context;
uint32_t idx = 0;
uint32_t count = 0;
const char* data;
/* Step 1. Logon */
if (! mapitest_common_setup(mt, &obj_htable, &count)) {
return false;
}
/* Step 2. Set Table Columns */
SPropTagArray = set_SPropTagArray(mt->mem_ctx, 0x3,
PR_DISPLAY_NAME,
PR_FID,
PR_FOLDER_CHILD_COUNT);
retval = SetColumns(&obj_htable, SPropTagArray);
MAPIFreeBuffer(SPropTagArray);
if (GetLastError() != MAPI_E_SUCCESS) {
mapitest_print_retval(mt, "SetColumns");
return false;
}
/* Step 3. QueryRows */
do {
retval = QueryRows(&obj_htable, 0x2, TBL_ADVANCE, &SRowSet);
if (SRowSet.cRows > 0) {
idx += SRowSet.cRows;
if (retval == MAPI_E_SUCCESS) {
mapitest_print(mt, "* %-35s: %.2d/%.2d [PASSED]\n",
"QueryRows", idx, count);
} else {
mapitest_print(mt, "* %-35s: %.2d/%.2d [FAILED]\n",
"QueryRows", idx, count);
}
}
} while (retval == MAPI_E_SUCCESS && SRowSet.cRows > 0);
/* Step 4. Get the test folder */
context = mt->priv;
mapi_object_init(&(obj_test_folder));
GetContentsTable(&(context->obj_test_folder), &(obj_test_folder), 0, &count);
if (GetLastError() != MAPI_E_SUCCESS) {
mapitest_print_retval(mt, "GetContentsTable");
return false;
}
if (count != 10) {
mapitest_print(mt, "* %-35s: unexpected count (%i)\n", "GetContentsTable", count);
/* This isn't a hard error for this test though, because it might be from a
previous test failure. Clean up and try again */
}
/* Step 5. Set Table Columns on the test folder */
SPropTagArray = set_SPropTagArray(mt->mem_ctx, 0x2, PR_BODY, PR_MESSAGE_CLASS);
retval = SetColumns(&obj_test_folder, SPropTagArray);
MAPIFreeBuffer(SPropTagArray);
if (GetLastError() != MAPI_E_SUCCESS) {
mapitest_print_retval(mt, "SetColumns");
return false;
}
/* Step 6. QueryRows on test folder contents */
idx = 0;
do {
retval = QueryRows(&(obj_test_folder), 0x2, TBL_ADVANCE, &SRowSet);
if (SRowSet.cRows > 0) {
idx += SRowSet.cRows;
if (retval == MAPI_E_SUCCESS) {
uint32_t i;
mapitest_print(mt, "* %-35s: %.2d/%.2d [PASSED]\n",
"QueryRows", idx, count);
for (i = 0; i < SRowSet.cRows; ++i) {
lpProp = SRowSet.aRow[i].lpProps[0];
if (lpProp.ulPropTag != PR_BODY) {
mapitest_print(mt, "* %-35s: Bad proptag0 (0x%x)\n",
"QueryRows", lpProp.ulPropTag);
return false;
}
data = get_SPropValue_data(&lpProp);
if (0 != strncmp(data, "Body of message", 15)) {
mapitest_print(mt, "* %-35s: Bad propval0 (%s)\n",
"QueryRows", data);
return false;
}
lpProp = SRowSet.aRow[i].lpProps[1];
if (lpProp.ulPropTag != PR_MESSAGE_CLASS) {
mapitest_print(mt, "* %-35s: Bad proptag1 (0x%x)\n",
"QueryRows", lpProp.ulPropTag);
return false;
}
data = get_SPropValue_data(&lpProp);
if (0 != strncmp(data, "IPM.Note", 8)) {
mapitest_print(mt, "* %-35s: Bad propval1 (%s)\n",
"QueryRows", data);
return false;
}
}
} else {
mapitest_print(mt, "* %-35s: %.2d/%.2d [FAILED]\n",
"QueryRows", idx, count);
}
}
} while (retval == MAPI_E_SUCCESS && SRowSet.cRows > 0);
/* Release */
mapi_object_release(&obj_htable);
mapi_object_release(&(obj_test_folder));
mapitest_common_cleanup(mt);
return true;
}
/**
\details Test the Restrict (0x14) operation
This function:
-# Opens the Inbox folder and creates some test content
-# Checks that the content is OK
-# Applies a filter
-# Checks the results are as expected.
-# Resets the table
-# Checks the results are as expected.
-# Cleans up
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_oxctable_Restrict(struct mapitest *mt)
{
mapi_object_t obj_htable;
mapi_object_t obj_test_folder;
struct mt_common_tf_ctx *context;
uint32_t count = 0;
uint32_t origcount = 0;
uint32_t Numerator = 0;
uint32_t Denominator = 0;
struct mapi_SRestriction res;
bool ret = true;
/* Step 1. Logon */
if (! mapitest_common_setup(mt, &obj_htable, &count)) {
return false;
}
/* Step 2. Get the test folder */
context = mt->priv;
mapi_object_init(&(obj_test_folder));
GetContentsTable(&(context->obj_test_folder), &(obj_test_folder), 0, &origcount);
if (GetLastError() != MAPI_E_SUCCESS) {
mapitest_print_retval(mt, "GetContentsTable");
ret = false;
goto cleanup;
}
if (origcount != 10) {
mapitest_print(mt, "* %-35s: unexpected count (%i)\n", "GetContentsTable", count);
/* This isn't a hard error for this test though, because it might be from a
previous test failure. Clean up and try again */
}
/* Apply a filter */
res.rt = RES_PROPERTY;
res.res.resProperty.relop = RES_PROPERTY;
res.res.resProperty.ulPropTag = PR_SUBJECT;
res.res.resProperty.lpProp.ulPropTag = PR_SUBJECT;
res.res.resProperty.lpProp.value.lpszA = MT_MAIL_SUBJECT;
Restrict(&(obj_test_folder), &res, NULL);
mapitest_print_retval(mt, "Restrict");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
/* Checks the results are as expected */
context = mt->priv;
QueryPosition(&(obj_test_folder), &Numerator, &Denominator);
if (GetLastError() != MAPI_E_SUCCESS) {
mapitest_print_retval(mt, "QueryPosition");
ret = false;
goto cleanup;
}
if (Denominator != origcount/2) {
mapitest_print(mt, "* %-35s: unexpected filtered count (%i)\n", "QueryPosition", Denominator);
ret = false;
goto cleanup;
}
/* Resets the table */
Reset(&(obj_test_folder));
mapitest_print_retval(mt, "Reset");
if (GetLastError() != MAPI_E_SUCCESS) {
ret = false;
goto cleanup;
}
/* Checks the results are as expected */
context = mt->priv;
QueryPosition(&(obj_test_folder), &Numerator, &Denominator);
if (GetLastError() != MAPI_E_SUCCESS) {
mapitest_print_retval(mt, "QueryPosition");
ret = false;
goto cleanup;
}
if (Denominator != origcount) {
mapitest_print(mt, "* %-35s: unexpected reset count (%i)\n", "QueryPosition", Denominator);
ret = false;
goto cleanup;
}
cleanup:
/* Release */
mapi_object_release(&obj_htable);
mapi_object_release(&(obj_test_folder));
mapitest_common_cleanup(mt);
return ret;
}
/**
\details Test the Compressed RTF decompression routine.
This function:
-# Loads some test data and checks it
-# Decompresses the test data
-# Checks that the decompressed data matches the expected result
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_noserver_lzfu(struct mapitest *mt)
{
enum MAPISTATUS retval;
DATA_BLOB uncompressed1;
DATA_BLOB uncompressed2;
uint8_t compressed_hex[1024];
uint8_t *compressed;
uint32_t compressed_length;
compressed = talloc_array(mt->mem_ctx, uint8_t, 1024);
memcpy(compressed_hex, RTF_COMPRESSED1_HEX, 98);
compressed_length = strhex_to_str((char*)compressed, 1024, (char*)compressed_hex, 98);
if (compressed_length != 49) {
mapitest_print(mt, "* %-40s: uncompress RTF - Bad length\n", "LZFU");
return false;
}
uint32_t crc = calculateCRC(compressed, 0x10, (49-0x10));
if (crc == 0xA7C7C5F1) {
mapitest_print(mt, "* CRC pass\n");
} else {
mapitest_print(mt, "* CRC failure, expected 0xA7C7C5F1, but got 0x%08X\n", crc);
}
retval = uncompress_rtf(mt->mem_ctx, compressed, compressed_length, &uncompressed1);
if (retval != MAPI_E_SUCCESS) {
mapitest_print_retval(mt, "uncompress_rtf - step 1 (bad retval)");
return false;
}
if (sizeof(RTF_UNCOMPRESSED1) != uncompressed1.length) {
mapitest_print(mt, "* %-40s: FAILED (bad length: %i vs %i)\n", "uncompress_rtf - step 1",
sizeof(RTF_UNCOMPRESSED1), uncompressed1.length);
return false;
}
if (!strncmp((char*)uncompressed1.data, RTF_UNCOMPRESSED1, uncompressed1.length)) {
mapitest_print(mt, "* %-40s: PASSED\n", "uncompress_rtf - step 1");
} else {
mapitest_print(mt, "* %-40s: FAILED - %s\n", "uncompress_rtf - step 1", (char*)uncompressed1.data);
return false;
}
memcpy(compressed_hex, RTF_COMPRESSED2_HEX, 60);
compressed_length = strhex_to_str((char*)compressed, 1024, (char*)compressed_hex, 60);
if (compressed_length != 30) {
mapitest_print(mt, "* %-40s: uncompress RTF - Bad length\n", "LZFU");
return false;
}
retval = uncompress_rtf(mt->mem_ctx, compressed, compressed_length, &uncompressed2);
if (retval != MAPI_E_SUCCESS) {
mapitest_print_retval(mt, "uncompress_rtf - step 2 (bad retval)");
return false;
}
if (!strncmp((char*)uncompressed2.data, RTF_UNCOMPRESSED2, uncompressed2.length)) {
mapitest_print(mt, "* %-40s: PASSED\n", "uncompress_rtf - step 2");
} else {
mapitest_print(mt, "* %-40s: FAILED - %s\n", "uncompress_rtf - step 2", (char*)uncompressed2.data);
return false;
}
/* TODO: add an uncompressed test here */
return true;
}
/**
\details Test #1804 ModifyRecipients and try to build RecipientRow
with multi-value properties (e.g. PidTagUserX509Certificate)
\param mt pointer to the top level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_zentyal_1804(struct mapitest *mt)
{
enum MAPISTATUS retval;
mapi_object_t obj_store;
mapi_object_t obj_folder;
mapi_object_t obj_message;
mapi_id_t id_folder;
char **username = NULL;
struct SPropTagArray *SPropTagArray = NULL;
struct PropertyValue_r value;
struct PropertyRowSet_r *RowSet = NULL;
struct SRowSet *SRowSet = NULL;
struct PropertyTagArray_r *flaglist = NULL;
mapi_id_t id_msgs[1];
/* Step 1. Logon */
mapi_object_init(&obj_store);
retval = OpenMsgStore(mt->session, &obj_store);
mapitest_print_retval(mt, "OpenMsgStore");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
/* Step 2. Open Outbox folder */
retval = GetDefaultFolder(&obj_store, &id_folder, olFolderOutbox);
mapitest_print_retval(mt, "GetDefaultFolder");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
mapi_object_init(&obj_folder);
retval = OpenFolder(&obj_store, id_folder, &obj_folder);
mapitest_print_retval(mt, "OpenFolder");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
/* Step 3. Create the message */
mapi_object_init(&obj_message);
retval = CreateMessage(&obj_folder, &obj_message);
mapitest_print_retval(mt, "CreateMessage");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
/* Step 4. Resolve the recipients and call ModifyRecipients */
SPropTagArray = set_SPropTagArray(mt->mem_ctx, 0xA,
PR_ENTRYID,
PR_DISPLAY_NAME_UNICODE,
PR_OBJECT_TYPE,
PR_DISPLAY_TYPE,
PR_TRANSMITTABLE_DISPLAY_NAME_UNICODE,
PR_EMAIL_ADDRESS_UNICODE,
PR_ADDRTYPE_UNICODE,
PR_SEND_RICH_INFO,
PR_7BIT_DISPLAY_NAME_UNICODE,
PR_SMTP_ADDRESS_UNICODE);
username = talloc_array(mt->mem_ctx, char *, 2);
username[0] = (char *)mt->profile->username;
username[1] = NULL;
retval = ResolveNames(mapi_object_get_session(&obj_message),
(const char **)username, SPropTagArray,
&RowSet, &flaglist, MAPI_UNICODE);
mapitest_print_retval_clean(mt, "ResolveNames", retval);
if (retval != MAPI_E_SUCCESS) {
return false;
}
if (!RowSet) {
mapitest_print(mt, "Null RowSet\n");
return false;
}
if (!RowSet->cRows) {
mapitest_print(mt, "No values in RowSet\n");
MAPIFreeBuffer(RowSet);
return false;
}
value.ulPropTag = PR_SEND_INTERNET_ENCODING;
value.value.l = 0;
PropertyRowSet_propcpy(mt->mem_ctx, RowSet, value);
/* Fake multi-value property on RecipientRow */
/* PT_MV_STRING8 */
value.ulPropTag = PR_EMS_AB_PROXY_ADDRESSES;
value.value.MVszA.cValues = 2;
value.value.MVszA.lppszA = talloc_array(mt->mem_ctx, const char *, value.value.MVszA.cValues);
value.value.MVszA.lppszA[0] = "smtp:[email protected]";
value.value.MVszA.lppszA[1] = "X400:c=US;a= ;p=First Organizati;o=Exchange;s=test";
PropertyRowSet_propcpy(mt->mem_ctx, RowSet, value);
/* PT_MV_UNICODE - same layout as PT_MV_STRING8 */
value.ulPropTag = PR_EMS_AB_PROXY_ADDRESSES_UNICODE;
PropertyRowSet_propcpy(mt->mem_ctx, RowSet, value);
/* PT_MV_BINARY */
value.ulPropTag = PidTagUserX509Certificate;
value.value.MVbin.cValues = 2;
value.value.MVbin.lpbin = talloc_array(mt->mem_ctx, struct Binary_r, value.value.MVbin.cValues);
value.value.MVbin.lpbin[0].cb = 9;
value.value.MVbin.lpbin[0].lpb = (uint8_t *)"string 1";
value.value.MVbin.lpbin[1].cb = 9;
value.value.MVbin.lpbin[1].lpb = (uint8_t *)"string 2";
PropertyRowSet_propcpy(mt->mem_ctx, RowSet, value);
SRowSet = talloc_zero(RowSet, struct SRowSet);
cast_PropertyRowSet_to_SRowSet(SRowSet, RowSet, SRowSet);
SetRecipientType(&(SRowSet->aRow[0]), MAPI_TO);
mapitest_print_retval(mt, "SetRecipientType");
retval = ModifyRecipients(&obj_message, SRowSet);
mapitest_print_retval_fmt(mt, "ModifyRecipients", "(%s)", "MAPI_TO");
if (retval != MAPI_E_SUCCESS) {
MAPIFreeBuffer(RowSet);
MAPIFreeBuffer(flaglist);
return false;
}
/* Step 5. Delete the message */
id_msgs[0] = mapi_object_get_id(&obj_message);
retval = DeleteMessage(&obj_folder, id_msgs, 1);
mapitest_print_retval(mt, "DeleteMessage");
if (retval != MAPI_E_SUCCESS) {
MAPIFreeBuffer(RowSet);
MAPIFreeBuffer(flaglist);
return false;
}
/* Release */
MAPIFreeBuffer(RowSet);
MAPIFreeBuffer(flaglist);
mapi_object_release(&obj_message);
mapi_object_release(&obj_folder);
mapi_object_release(&obj_store);
return true;
}
