1361 lines
46 KiB
C
1361 lines
46 KiB
C
/*
|
|
* Unit test suite for MAPI property functions
|
|
*
|
|
* Copyright 2004 Jon Griffiths
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#define NONAMELESSUNION
|
|
#define NONAMELESSSTRUCT
|
|
#include "wine/test.h"
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winuser.h"
|
|
#include "winerror.h"
|
|
#include "winnt.h"
|
|
#include "mapiutil.h"
|
|
#include "mapitags.h"
|
|
|
|
HRESULT WINAPI MAPIInitialize(LPVOID);
|
|
|
|
static HMODULE hMapi32 = 0;
|
|
|
|
static SCODE (WINAPI *pScInitMapiUtil)(ULONG);
|
|
static SCODE (WINAPI *pPropCopyMore)(LPSPropValue,LPSPropValue,ALLOCATEMORE*,LPVOID);
|
|
static ULONG (WINAPI *pUlPropSize)(LPSPropValue);
|
|
static BOOL (WINAPI *pFPropContainsProp)(LPSPropValue,LPSPropValue,ULONG);
|
|
static BOOL (WINAPI *pFPropCompareProp)(LPSPropValue,ULONG,LPSPropValue);
|
|
static LONG (WINAPI *pLPropCompareProp)(LPSPropValue,LPSPropValue);
|
|
static LPSPropValue (WINAPI *pPpropFindProp)(LPSPropValue,ULONG,ULONG);
|
|
static SCODE (WINAPI *pScCountProps)(INT,LPSPropValue,ULONG*);
|
|
static SCODE (WINAPI *pScCopyProps)(int,LPSPropValue,LPVOID,ULONG*);
|
|
static SCODE (WINAPI *pScRelocProps)(int,LPSPropValue,LPVOID,LPVOID,ULONG*);
|
|
static LPSPropValue (WINAPI *pLpValFindProp)(ULONG,ULONG,LPSPropValue);
|
|
static BOOL (WINAPI *pFBadRglpszA)(LPSTR*,ULONG);
|
|
static BOOL (WINAPI *pFBadRglpszW)(LPWSTR*,ULONG);
|
|
static BOOL (WINAPI *pFBadRowSet)(LPSRowSet);
|
|
static ULONG (WINAPI *pFBadPropTag)(ULONG);
|
|
static ULONG (WINAPI *pFBadRow)(LPSRow);
|
|
static ULONG (WINAPI *pFBadProp)(LPSPropValue);
|
|
static ULONG (WINAPI *pFBadColumnSet)(LPSPropTagArray);
|
|
static SCODE (WINAPI *pCreateIProp)(LPCIID,ALLOCATEBUFFER*,ALLOCATEMORE*,
|
|
FREEBUFFER*,LPVOID,LPPROPDATA*);
|
|
|
|
static ULONG ptTypes[] = {
|
|
PT_I2, PT_I4, PT_R4, PT_R8, PT_CURRENCY, PT_APPTIME, PT_SYSTIME,
|
|
PT_ERROR, PT_BOOLEAN, PT_I8, PT_CLSID, PT_STRING8, PT_BINARY,
|
|
PT_UNICODE
|
|
};
|
|
|
|
static inline int strcmpW(const WCHAR *str1, const WCHAR *str2)
|
|
{
|
|
while (*str1 && (*str1 == *str2)) { str1++; str2++; }
|
|
return *str1 - *str2;
|
|
}
|
|
|
|
static void test_PropCopyMore(void)
|
|
{
|
|
static const char *szHiA = "Hi!";
|
|
static const WCHAR szHiW[] = { 'H', 'i', '!', '\0' };
|
|
SPropValue *lpDest = NULL, *lpSrc = NULL;
|
|
ULONG i;
|
|
SCODE scode;
|
|
|
|
pPropCopyMore = (void*)GetProcAddress(hMapi32, "PropCopyMore@16");
|
|
|
|
if (!pPropCopyMore)
|
|
return;
|
|
|
|
scode = MAPIAllocateBuffer(sizeof(LPSPropValue), (LPVOID *)lpDest);
|
|
if (FAILED(scode))
|
|
return;
|
|
|
|
scode = MAPIAllocateMore(sizeof(LPSPropValue), lpDest, (LPVOID *)lpSrc);
|
|
if (FAILED(scode))
|
|
return;
|
|
|
|
for (i = 0; i < sizeof(ptTypes)/sizeof(ptTypes[0]); i++)
|
|
{
|
|
lpSrc->ulPropTag = ptTypes[i];
|
|
|
|
switch (ptTypes[i])
|
|
{
|
|
case PT_STRING8:
|
|
lpSrc->Value.lpszA = (char*)szHiA;
|
|
break;
|
|
case PT_UNICODE:
|
|
lpSrc->Value.lpszW = (WCHAR*)szHiW;
|
|
break;
|
|
case PT_BINARY:
|
|
lpSrc->Value.bin.cb = 4;
|
|
lpSrc->Value.bin.lpb = (LPBYTE)szHiA;
|
|
break;
|
|
}
|
|
|
|
memset(lpDest, 0xff, sizeof(SPropValue));
|
|
|
|
scode = pPropCopyMore(lpDest, lpSrc, MAPIAllocateMore, lpDest);
|
|
ok(!scode && lpDest->ulPropTag == lpSrc->ulPropTag,
|
|
"PropCopyMore: Expected 0x0,%ld, got 0x%08lx,%ld\n",
|
|
lpSrc->ulPropTag, scode, lpDest->ulPropTag);
|
|
if (SUCCEEDED(scode))
|
|
{
|
|
switch (ptTypes[i])
|
|
{
|
|
case PT_STRING8:
|
|
ok(lstrcmpA(lpDest->Value.lpszA, lpSrc->Value.lpszA) == 0,
|
|
"PropCopyMore: Ascii string differs\n");
|
|
break;
|
|
case PT_UNICODE:
|
|
ok(strcmpW(lpDest->Value.lpszW, lpSrc->Value.lpszW) == 0,
|
|
"PropCopyMore: Unicode string differs\n");
|
|
break;
|
|
case PT_BINARY:
|
|
ok(lpDest->Value.bin.cb == 4 &&
|
|
!memcmp(lpSrc->Value.bin.lpb, lpDest->Value.bin.lpb, 4),
|
|
"PropCopyMore: Binary array differs\n");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Since all allocations are linked, freeing lpDest frees everything */
|
|
MAPIFreeBuffer(lpDest);
|
|
}
|
|
|
|
static void test_UlPropSize(void)
|
|
{
|
|
static const char *szHiA = "Hi!";
|
|
static const WCHAR szHiW[] = { 'H', 'i', '!', '\0' };
|
|
LPSTR buffa[2];
|
|
LPWSTR buffw[2];
|
|
SBinary buffbin[2];
|
|
ULONG pt, exp, res;
|
|
|
|
pUlPropSize = (void*)GetProcAddress(hMapi32, "UlPropSize@4");
|
|
|
|
if (!pUlPropSize)
|
|
return;
|
|
|
|
for (pt = 0; pt < PROP_ID_INVALID; pt++)
|
|
{
|
|
SPropValue pv;
|
|
|
|
memset(&pv, 0 ,sizeof(pv));
|
|
pv.ulPropTag = pt;
|
|
|
|
exp = 1u; /* Default to one item for non-MV properties */
|
|
|
|
switch (PROP_TYPE(pt))
|
|
{
|
|
case PT_MV_I2: pv.Value.MVi.cValues = exp = 2;
|
|
case PT_I2: exp *= sizeof(USHORT); break;
|
|
case PT_MV_I4: pv.Value.MVl.cValues = exp = 2;
|
|
case PT_I4: exp *= sizeof(LONG); break;
|
|
case PT_MV_R4: pv.Value.MVflt.cValues = exp = 2;
|
|
case PT_R4: exp *= sizeof(float); break;
|
|
case PT_MV_DOUBLE: pv.Value.MVdbl.cValues = exp = 2;
|
|
case PT_R8: exp *= sizeof(double); break;
|
|
case PT_MV_CURRENCY: pv.Value.MVcur.cValues = exp = 2;
|
|
case PT_CURRENCY: exp *= sizeof(CY); break;
|
|
case PT_MV_APPTIME: pv.Value.MVat.cValues = exp = 2;
|
|
case PT_APPTIME: exp *= sizeof(double); break;
|
|
case PT_MV_SYSTIME: pv.Value.MVft.cValues = exp = 2;
|
|
case PT_SYSTIME: exp *= sizeof(FILETIME); break;
|
|
case PT_ERROR: exp = sizeof(SCODE); break;
|
|
case PT_BOOLEAN: exp = sizeof(USHORT); break;
|
|
case PT_OBJECT: exp = 0; break;
|
|
case PT_MV_I8: pv.Value.MVli.cValues = exp = 2;
|
|
case PT_I8: exp *= sizeof(LONG64); break;
|
|
#if 0
|
|
/* My version of native mapi returns 0 for PT_MV_CLSID even if a valid
|
|
* array is given. This _has_ to be a bug, so Wine does
|
|
* the right thing(tm) and we don't test it here.
|
|
*/
|
|
case PT_MV_CLSID: pv.Value.MVguid.cValues = exp = 2;
|
|
#endif
|
|
case PT_CLSID: exp *= sizeof(GUID); break;
|
|
case PT_STRING8:
|
|
pv.Value.lpszA = (LPSTR)szHiA;
|
|
exp = 4;
|
|
break;
|
|
case PT_UNICODE:
|
|
pv.Value.lpszW = (LPWSTR)szHiW;
|
|
exp = 4 * sizeof(WCHAR);
|
|
break;
|
|
case PT_BINARY:
|
|
pv.Value.bin.cb = exp = 19;
|
|
break;
|
|
case PT_MV_STRING8:
|
|
pv.Value.MVszA.cValues = 2;
|
|
pv.Value.MVszA.lppszA = buffa;
|
|
buffa[0] = (LPSTR)szHiA;
|
|
buffa[1] = (LPSTR)szHiA;
|
|
exp = 8;
|
|
break;
|
|
case PT_MV_UNICODE:
|
|
pv.Value.MVszW.cValues = 2;
|
|
pv.Value.MVszW.lppszW = buffw;
|
|
buffw[0] = (LPWSTR)szHiW;
|
|
buffw[1] = (LPWSTR)szHiW;
|
|
exp = 8 * sizeof(WCHAR);
|
|
break;
|
|
case PT_MV_BINARY:
|
|
pv.Value.MVbin.cValues = 2;
|
|
pv.Value.MVbin.lpbin = buffbin;
|
|
buffbin[0].cb = 19;
|
|
buffbin[1].cb = 1;
|
|
exp = 20;
|
|
break;
|
|
default:
|
|
exp = 0;
|
|
}
|
|
|
|
res = pUlPropSize(&pv);
|
|
ok(res == exp, "pt= %ld: Expected %ld, got %ld\n", pt, exp, res);
|
|
}
|
|
}
|
|
|
|
static void test_FPropContainsProp(void)
|
|
{
|
|
static const char *szFull = "Full String";
|
|
static const char *szFullLower = "full string";
|
|
static const char *szPrefix = "Full";
|
|
static const char *szPrefixLower = "full";
|
|
static const char *szSubstring = "ll St";
|
|
static const char *szSubstringLower = "ll st";
|
|
SPropValue pvLeft, pvRight;
|
|
ULONG pt;
|
|
BOOL bRet;
|
|
|
|
pFPropContainsProp = (void*)GetProcAddress(hMapi32, "FPropContainsProp@12");
|
|
|
|
if (!pFPropContainsProp)
|
|
return;
|
|
|
|
/* Ensure that only PT_STRING8 and PT_BINARY are handled */
|
|
for (pt = 0; pt < PROP_ID_INVALID; pt++)
|
|
{
|
|
if (pt == PT_STRING8 || pt == PT_BINARY)
|
|
continue; /* test these later */
|
|
|
|
memset(&pvLeft, 0 ,sizeof(pvLeft));
|
|
memset(&pvRight, 0 ,sizeof(pvRight));
|
|
pvLeft.ulPropTag = pvRight.ulPropTag = pt;
|
|
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
|
|
ok(bRet == FALSE, "pt= %ld: Expected FALSE, got %d\n", pt, bRet);
|
|
}
|
|
|
|
/* test the various flag combinations */
|
|
pvLeft.ulPropTag = pvRight.ulPropTag = PT_STRING8;
|
|
pvLeft.Value.lpszA = (LPSTR)szFull;
|
|
pvRight.Value.lpszA = (LPSTR)szFull;
|
|
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
|
|
ok(bRet == TRUE, "(full,full)[] match failed\n");
|
|
pvRight.Value.lpszA = (LPSTR)szPrefix;
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
|
|
ok(bRet == FALSE, "(full,prefix)[] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
|
|
ok(bRet == TRUE, "(full,prefix)[PREFIX] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
|
|
ok(bRet == TRUE, "(full,prefix)[SUBSTRING] match failed\n");
|
|
pvRight.Value.lpszA = (LPSTR)szPrefixLower;
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
|
|
ok(bRet == FALSE, "(full,prefixlow)[PREFIX] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
|
|
ok(bRet == FALSE, "(full,prefixlow)[SUBSTRING] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX|FL_IGNORECASE);
|
|
ok(bRet == TRUE, "(full,prefixlow)[PREFIX|IGNORECASE] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING|FL_IGNORECASE);
|
|
ok(bRet == TRUE, "(full,prefixlow)[SUBSTRING|IGNORECASE] match failed\n");
|
|
pvRight.Value.lpszA = (LPSTR)szSubstring;
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
|
|
ok(bRet == FALSE, "(full,substr)[] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
|
|
ok(bRet == FALSE, "(full,substr)[PREFIX] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
|
|
ok(bRet == TRUE, "(full,substr)[SUBSTRING] match failed\n");
|
|
pvRight.Value.lpszA = (LPSTR)szSubstringLower;
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
|
|
ok(bRet == FALSE, "(full,substrlow)[PREFIX] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
|
|
ok(bRet == FALSE, "(full,substrlow)[SUBSTRING] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX|FL_IGNORECASE);
|
|
ok(bRet == FALSE, "(full,substrlow)[PREFIX|IGNORECASE] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING|FL_IGNORECASE);
|
|
ok(bRet == TRUE, "(full,substrlow)[SUBSTRING|IGNORECASE] match failed\n");
|
|
pvRight.Value.lpszA = (LPSTR)szFullLower;
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING|FL_IGNORECASE);
|
|
ok(bRet == TRUE, "(full,fulllow)[IGNORECASE] match failed\n");
|
|
|
|
pvLeft.ulPropTag = pvRight.ulPropTag = PT_BINARY;
|
|
pvLeft.Value.bin.lpb = (LPBYTE)szFull;
|
|
pvRight.Value.bin.lpb = (LPBYTE)szFull;
|
|
pvLeft.Value.bin.cb = pvRight.Value.bin.cb = strlen(szFull);
|
|
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
|
|
ok(bRet == TRUE, "bin(full,full)[] match failed\n");
|
|
pvRight.Value.bin.lpb = (LPBYTE)szPrefix;
|
|
pvRight.Value.bin.cb = strlen(szPrefix);
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
|
|
ok(bRet == FALSE, "bin(full,prefix)[] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
|
|
ok(bRet == TRUE, "bin(full,prefix)[PREFIX] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
|
|
ok(bRet == TRUE, "bin(full,prefix)[SUBSTRING] match failed\n");
|
|
pvRight.Value.bin.lpb = (LPBYTE)szPrefixLower;
|
|
pvRight.Value.bin.cb = strlen(szPrefixLower);
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
|
|
ok(bRet == FALSE, "bin(full,prefixlow)[PREFIX] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
|
|
ok(bRet == FALSE, "bin(full,prefixlow)[SUBSTRING] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX|FL_IGNORECASE);
|
|
ok(bRet == FALSE, "bin(full,prefixlow)[PREFIX|IGNORECASE] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING|FL_IGNORECASE);
|
|
ok(bRet == FALSE, "bin(full,prefixlow)[SUBSTRING|IGNORECASE] match failed\n");
|
|
pvRight.Value.bin.lpb = (LPBYTE)szSubstring;
|
|
pvRight.Value.bin.cb = strlen(szSubstring);
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
|
|
ok(bRet == FALSE, "bin(full,substr)[] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
|
|
ok(bRet == FALSE, "bin(full,substr)[PREFIX] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
|
|
ok(bRet == TRUE, "bin(full,substr)[SUBSTRING] match failed\n");
|
|
pvRight.Value.bin.lpb = (LPBYTE)szSubstringLower;
|
|
pvRight.Value.bin.cb = strlen(szSubstringLower);
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
|
|
ok(bRet == FALSE, "bin(full,substrlow)[PREFIX] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
|
|
ok(bRet == FALSE, "bin(full,substrlow)[SUBSTRING] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX|FL_IGNORECASE);
|
|
ok(bRet == FALSE, "bin(full,substrlow)[PREFIX|IGNORECASE] match failed\n");
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING|FL_IGNORECASE);
|
|
ok(bRet == FALSE, "bin(full,substrlow)[SUBSTRING|IGNORECASE] match failed\n");
|
|
pvRight.Value.bin.lpb = (LPBYTE)szFullLower;
|
|
pvRight.Value.bin.cb = strlen(szFullLower);
|
|
bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING|FL_IGNORECASE);
|
|
ok(bRet == FALSE, "bin(full,fulllow)[IGNORECASE] match failed\n");
|
|
}
|
|
|
|
typedef struct tagFPropCompareProp_Result
|
|
{
|
|
SHORT lVal;
|
|
SHORT rVal;
|
|
ULONG relOp;
|
|
BOOL bRet;
|
|
} FPropCompareProp_Result;
|
|
|
|
static const FPropCompareProp_Result FPCProp_Results[] =
|
|
{
|
|
{ 1, 2, RELOP_LT, TRUE },
|
|
{ 1, 1, RELOP_LT, FALSE },
|
|
{ 2, 1, RELOP_LT, FALSE },
|
|
{ 1, 2, RELOP_LE, TRUE },
|
|
{ 1, 1, RELOP_LE, TRUE },
|
|
{ 2, 1, RELOP_LE, FALSE },
|
|
{ 1, 2, RELOP_GT, FALSE },
|
|
{ 1, 1, RELOP_GT, FALSE },
|
|
{ 2, 1, RELOP_GT, TRUE },
|
|
{ 1, 2, RELOP_GE, FALSE },
|
|
{ 1, 1, RELOP_GE, TRUE },
|
|
{ 2, 1, RELOP_GE, TRUE },
|
|
{ 1, 2, RELOP_EQ, FALSE },
|
|
{ 1, 1, RELOP_EQ, TRUE },
|
|
{ 2, 1, RELOP_EQ, FALSE }
|
|
};
|
|
|
|
static const char *relops[] = { "RELOP_LT", "RELOP_LE", "RELOP_GT", "RELOP_GE", "RELOP_EQ" };
|
|
|
|
static void test_FPropCompareProp(void)
|
|
{
|
|
SPropValue pvLeft, pvRight;
|
|
GUID lguid, rguid;
|
|
char lbuffa[2], rbuffa[2];
|
|
WCHAR lbuffw[2], rbuffw[2];
|
|
ULONG i, j;
|
|
BOOL bRet, bExp;
|
|
|
|
pFPropCompareProp = (void*)GetProcAddress(hMapi32, "FPropCompareProp@12");
|
|
|
|
if (!pFPropCompareProp)
|
|
return;
|
|
|
|
lbuffa[1] = '\0';
|
|
rbuffa[1] = '\0';
|
|
lbuffw[1] = '\0';
|
|
rbuffw[1] = '\0';
|
|
|
|
for (i = 0; i < sizeof(ptTypes)/sizeof(ptTypes[0]); i++)
|
|
{
|
|
pvLeft.ulPropTag = pvRight.ulPropTag = ptTypes[i];
|
|
|
|
for (j = 0; j < sizeof(FPCProp_Results)/sizeof(FPCProp_Results[0]); j++)
|
|
{
|
|
SHORT lVal = FPCProp_Results[j].lVal;
|
|
SHORT rVal = FPCProp_Results[j].rVal;
|
|
|
|
bExp = FPCProp_Results[j].bRet;
|
|
|
|
switch (ptTypes[i])
|
|
{
|
|
case PT_BOOLEAN:
|
|
/* Boolean values have no concept of less or greater than, only equality */
|
|
if ((lVal == 1 && rVal == 2 && FPCProp_Results[j].relOp == RELOP_LT) ||
|
|
(lVal == 2 && rVal == 1 && FPCProp_Results[j].relOp == RELOP_LE)||
|
|
(lVal == 2 && rVal == 1 && FPCProp_Results[j].relOp == RELOP_GT)||
|
|
(lVal == 1 && rVal == 2 && FPCProp_Results[j].relOp == RELOP_GE)||
|
|
(lVal == 1 && rVal == 2 && FPCProp_Results[j].relOp == RELOP_EQ)||
|
|
(lVal == 2 && rVal == 1 && FPCProp_Results[j].relOp == RELOP_EQ))
|
|
bExp = !bExp;
|
|
/* Fall through ... */
|
|
case PT_I2:
|
|
pvLeft.Value.i = lVal;
|
|
pvRight.Value.i = rVal;
|
|
break;
|
|
case PT_ERROR:
|
|
case PT_I4:
|
|
pvLeft.Value.l = lVal;
|
|
pvRight.Value.l = rVal;
|
|
break;
|
|
case PT_R4:
|
|
pvLeft.Value.flt = lVal;
|
|
pvRight.Value.flt = rVal;
|
|
break;
|
|
case PT_APPTIME:
|
|
case PT_R8:
|
|
pvLeft.Value.dbl = lVal;
|
|
pvRight.Value.dbl = rVal;
|
|
break;
|
|
case PT_CURRENCY:
|
|
pvLeft.Value.cur.int64 = lVal;
|
|
pvRight.Value.cur.int64 = rVal;
|
|
break;
|
|
case PT_SYSTIME:
|
|
pvLeft.Value.ft.dwLowDateTime = lVal;
|
|
pvLeft.Value.ft.dwHighDateTime = 0;
|
|
pvRight.Value.ft.dwLowDateTime = rVal;
|
|
pvRight.Value.ft.dwHighDateTime = 0;
|
|
break;
|
|
case PT_I8:
|
|
pvLeft.Value.li.u.LowPart = lVal;
|
|
pvLeft.Value.li.u.HighPart = 0;
|
|
pvRight.Value.li.u.LowPart = rVal;
|
|
pvRight.Value.li.u.HighPart = 0;
|
|
break;
|
|
case PT_CLSID:
|
|
memset(&lguid, 0, sizeof(GUID));
|
|
memset(&rguid, 0, sizeof(GUID));
|
|
lguid.Data4[7] = lVal;
|
|
rguid.Data4[7] = rVal;
|
|
pvLeft.Value.lpguid = &lguid;
|
|
pvRight.Value.lpguid = &rguid;
|
|
break;
|
|
case PT_STRING8:
|
|
pvLeft.Value.lpszA = lbuffa;
|
|
pvRight.Value.lpszA = rbuffa;
|
|
lbuffa[0] = '0' + lVal;
|
|
rbuffa[0] = '0' + rVal;
|
|
break;
|
|
case PT_UNICODE:
|
|
pvLeft.Value.lpszW = lbuffw;
|
|
pvRight.Value.lpszW = rbuffw;
|
|
lbuffw[0] = '0' + lVal;
|
|
rbuffw[0] = '0' + rVal;
|
|
break;
|
|
case PT_BINARY:
|
|
pvLeft.Value.bin.cb = 1;
|
|
pvRight.Value.bin.cb = 1;
|
|
pvLeft.Value.bin.lpb = lbuffa;
|
|
pvRight.Value.bin.lpb = rbuffa;
|
|
lbuffa[0] = lVal;
|
|
rbuffa[0] = rVal;
|
|
break;
|
|
}
|
|
|
|
bRet = pFPropCompareProp(&pvLeft, FPCProp_Results[j].relOp, &pvRight);
|
|
ok(bRet == bExp, "pt %ld (%d,%d,%s): expected %d, got %d\n", ptTypes[i],
|
|
FPCProp_Results[j].lVal, FPCProp_Results[j].rVal,
|
|
relops[FPCProp_Results[j].relOp], bExp, bRet);
|
|
}
|
|
}
|
|
}
|
|
|
|
typedef struct tagLPropCompareProp_Result
|
|
{
|
|
SHORT lVal;
|
|
SHORT rVal;
|
|
INT iRet;
|
|
} LPropCompareProp_Result;
|
|
|
|
static const LPropCompareProp_Result LPCProp_Results[] =
|
|
{
|
|
{ 1, 2, -1 },
|
|
{ 1, 1, 0 },
|
|
{ 2, 1, 1 },
|
|
};
|
|
|
|
static void test_LPropCompareProp(void)
|
|
{
|
|
SPropValue pvLeft, pvRight;
|
|
GUID lguid, rguid;
|
|
char lbuffa[2], rbuffa[2];
|
|
WCHAR lbuffw[2], rbuffw[2];
|
|
ULONG i, j;
|
|
INT iRet, iExp;
|
|
|
|
pLPropCompareProp = (void*)GetProcAddress(hMapi32, "LPropCompareProp@8");
|
|
|
|
if (!pLPropCompareProp)
|
|
return;
|
|
|
|
lbuffa[1] = '\0';
|
|
rbuffa[1] = '\0';
|
|
lbuffw[1] = '\0';
|
|
rbuffw[1] = '\0';
|
|
|
|
for (i = 0; i < sizeof(ptTypes)/sizeof(ptTypes[0]); i++)
|
|
{
|
|
pvLeft.ulPropTag = pvRight.ulPropTag = ptTypes[i];
|
|
|
|
for (j = 0; j < sizeof(LPCProp_Results)/sizeof(LPCProp_Results[0]); j++)
|
|
{
|
|
SHORT lVal = LPCProp_Results[j].lVal;
|
|
SHORT rVal = LPCProp_Results[j].rVal;
|
|
|
|
iExp = LPCProp_Results[j].iRet;
|
|
|
|
switch (ptTypes[i])
|
|
{
|
|
case PT_BOOLEAN:
|
|
/* Boolean values have no concept of less or greater than, only equality */
|
|
if (lVal && rVal)
|
|
iExp = 0;
|
|
/* Fall through ... */
|
|
case PT_I2:
|
|
pvLeft.Value.i = lVal;
|
|
pvRight.Value.i = rVal;
|
|
break;
|
|
case PT_ERROR:
|
|
case PT_I4:
|
|
pvLeft.Value.l = lVal;
|
|
pvRight.Value.l = rVal;
|
|
break;
|
|
case PT_R4:
|
|
pvLeft.Value.flt = lVal;
|
|
pvRight.Value.flt = rVal;
|
|
break;
|
|
case PT_APPTIME:
|
|
case PT_R8:
|
|
pvLeft.Value.dbl = lVal;
|
|
pvRight.Value.dbl = rVal;
|
|
break;
|
|
case PT_CURRENCY:
|
|
pvLeft.Value.cur.int64 = lVal;
|
|
pvRight.Value.cur.int64 = rVal;
|
|
break;
|
|
case PT_SYSTIME:
|
|
pvLeft.Value.ft.dwLowDateTime = lVal;
|
|
pvLeft.Value.ft.dwHighDateTime = 0;
|
|
pvRight.Value.ft.dwLowDateTime = rVal;
|
|
pvRight.Value.ft.dwHighDateTime = 0;
|
|
break;
|
|
case PT_I8:
|
|
pvLeft.Value.li.u.LowPart = lVal;
|
|
pvLeft.Value.li.u.HighPart = 0;
|
|
pvRight.Value.li.u.LowPart = rVal;
|
|
pvRight.Value.li.u.HighPart = 0;
|
|
break;
|
|
case PT_CLSID:
|
|
memset(&lguid, 0, sizeof(GUID));
|
|
memset(&rguid, 0, sizeof(GUID));
|
|
lguid.Data4[7] = lVal;
|
|
rguid.Data4[7] = rVal;
|
|
pvLeft.Value.lpguid = &lguid;
|
|
pvRight.Value.lpguid = &rguid;
|
|
break;
|
|
case PT_STRING8:
|
|
pvLeft.Value.lpszA = lbuffa;
|
|
pvRight.Value.lpszA = rbuffa;
|
|
lbuffa[0] = '0' + lVal;
|
|
rbuffa[0] = '0' + rVal;
|
|
break;
|
|
case PT_UNICODE:
|
|
pvLeft.Value.lpszW = lbuffw;
|
|
pvRight.Value.lpszW = rbuffw;
|
|
lbuffw[0] = '0' + lVal;
|
|
rbuffw[0] = '0' + rVal;
|
|
break;
|
|
case PT_BINARY:
|
|
pvLeft.Value.bin.cb = 1;
|
|
pvRight.Value.bin.cb = 1;
|
|
pvLeft.Value.bin.lpb = lbuffa;
|
|
pvRight.Value.bin.lpb = rbuffa;
|
|
lbuffa[0] = lVal;
|
|
rbuffa[0] = rVal;
|
|
break;
|
|
}
|
|
|
|
iRet = pLPropCompareProp(&pvLeft, &pvRight);
|
|
ok(iRet == iExp, "pt %ld (%d,%d): expected %d, got %d\n", ptTypes[i],
|
|
LPCProp_Results[j].lVal, LPCProp_Results[j].rVal, iExp, iRet);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void test_PpropFindProp(void)
|
|
{
|
|
SPropValue pvProp, *pRet;
|
|
ULONG i;
|
|
|
|
pPpropFindProp = (void*)GetProcAddress(hMapi32, "PpropFindProp@12");
|
|
|
|
if (!pPpropFindProp)
|
|
return;
|
|
|
|
for (i = 0; i < sizeof(ptTypes)/sizeof(ptTypes[0]); i++)
|
|
{
|
|
pvProp.ulPropTag = ptTypes[i];
|
|
|
|
pRet = pPpropFindProp(&pvProp, 1u, ptTypes[i]);
|
|
ok(pRet == &pvProp, "PpropFindProp[%ld]: Didn't find existing propery\n",
|
|
ptTypes[i]);
|
|
|
|
pRet = pPpropFindProp(&pvProp, 1u, i ? ptTypes[i-1] : ptTypes[i+1]);
|
|
ok(pRet == NULL, "PpropFindProp[%ld]: Found nonexistent propery\n",
|
|
ptTypes[i]);
|
|
}
|
|
|
|
pvProp.ulPropTag = PROP_TAG(PT_I2, 1u);
|
|
pRet = pPpropFindProp(&pvProp, 1u, PROP_TAG(PT_UNSPECIFIED, 0u));
|
|
ok(pRet == NULL, "PpropFindProp[UNSPECIFIED]: Matched on different id\n");
|
|
pRet = pPpropFindProp(&pvProp, 1u, PROP_TAG(PT_UNSPECIFIED, 1u));
|
|
ok(pRet == &pvProp, "PpropFindProp[UNSPECIFIED]: Didn't match id\n");
|
|
}
|
|
|
|
static void test_ScCountProps(void)
|
|
{
|
|
static const char *szHiA = "Hi!";
|
|
static const WCHAR szHiW[] = { 'H', 'i', '!', '\0' };
|
|
static const ULONG ULHILEN = 4; /* chars in szHiA/W incl. NUL */
|
|
LPSTR buffa[3];
|
|
LPWSTR buffw[3];
|
|
SBinary buffbin[3];
|
|
GUID iids[4], *iid = iids;
|
|
SCODE res;
|
|
ULONG pt, exp, ulRet;
|
|
int success = 1;
|
|
|
|
pScCountProps = (void*)GetProcAddress(hMapi32, "ScCountProps@12");
|
|
|
|
if (!pScCountProps)
|
|
return;
|
|
|
|
for (pt = 0; pt < PROP_ID_INVALID && success; pt++)
|
|
{
|
|
SPropValue pv;
|
|
|
|
memset(&pv, 0 ,sizeof(pv));
|
|
pv.ulPropTag = PROP_TAG(pt, 1u);
|
|
|
|
switch (PROP_TYPE(pt))
|
|
{
|
|
case PT_I2:
|
|
case PT_I4:
|
|
case PT_R4:
|
|
case PT_R8:
|
|
case PT_CURRENCY:
|
|
case PT_APPTIME:
|
|
case PT_SYSTIME:
|
|
case PT_ERROR:
|
|
case PT_BOOLEAN:
|
|
case PT_OBJECT:
|
|
case PT_I8:
|
|
exp = sizeof(pv);
|
|
break;
|
|
case PT_CLSID:
|
|
pv.Value.lpguid = iid;
|
|
exp = sizeof(GUID) + sizeof(pv);
|
|
break;
|
|
case PT_STRING8:
|
|
pv.Value.lpszA = (LPSTR)szHiA;
|
|
exp = 4 + sizeof(pv);
|
|
break;
|
|
case PT_UNICODE:
|
|
pv.Value.lpszW = (LPWSTR)szHiW;
|
|
exp = 4 * sizeof(WCHAR) + sizeof(pv);
|
|
break;
|
|
case PT_BINARY:
|
|
pv.Value.bin.cb = 2;
|
|
pv.Value.bin.lpb = (LPBYTE)iid;
|
|
exp = 2 + sizeof(pv);
|
|
break;
|
|
case PT_MV_I2:
|
|
pv.Value.MVi.cValues = 3;
|
|
pv.Value.MVi.lpi = (SHORT*)iid;
|
|
exp = 3 * sizeof(SHORT) + sizeof(pv);
|
|
break;
|
|
case PT_MV_I4:
|
|
pv.Value.MVl.cValues = 3;
|
|
pv.Value.MVl.lpl = (LONG*)iid;
|
|
exp = 3 * sizeof(LONG) + sizeof(pv);
|
|
break;
|
|
case PT_MV_I8:
|
|
pv.Value.MVli.cValues = 3;
|
|
pv.Value.MVli.lpli = (LARGE_INTEGER*)iid;
|
|
exp = 3 * sizeof(LARGE_INTEGER) + sizeof(pv);
|
|
break;
|
|
case PT_MV_R4:
|
|
pv.Value.MVflt.cValues = 3;
|
|
pv.Value.MVflt.lpflt = (float*)iid;
|
|
exp = 3 * sizeof(float) + sizeof(pv);
|
|
break;
|
|
case PT_MV_APPTIME:
|
|
case PT_MV_R8:
|
|
pv.Value.MVdbl.cValues = 3;
|
|
pv.Value.MVdbl.lpdbl = (double*)iid;
|
|
exp = 3 * sizeof(double) + sizeof(pv);
|
|
break;
|
|
case PT_MV_CURRENCY:
|
|
pv.Value.MVcur.cValues = 3;
|
|
pv.Value.MVcur.lpcur = (CY*)iid;
|
|
exp = 3 * sizeof(CY) + sizeof(pv);
|
|
break;
|
|
case PT_MV_SYSTIME:
|
|
pv.Value.MVft.cValues = 3;
|
|
pv.Value.MVft.lpft = (FILETIME*)iid;
|
|
exp = 3 * sizeof(CY) + sizeof(pv);
|
|
break;
|
|
case PT_MV_STRING8:
|
|
pv.Value.MVszA.cValues = 3;
|
|
pv.Value.MVszA.lppszA = buffa;
|
|
buffa[0] = (LPSTR)szHiA;
|
|
buffa[1] = (LPSTR)szHiA;
|
|
buffa[2] = (LPSTR)szHiA;
|
|
exp = ULHILEN * 3 + 3 * sizeof(char*) + sizeof(pv);
|
|
break;
|
|
case PT_MV_UNICODE:
|
|
pv.Value.MVszW.cValues = 3;
|
|
pv.Value.MVszW.lppszW = buffw;
|
|
buffw[0] = (LPWSTR)szHiW;
|
|
buffw[1] = (LPWSTR)szHiW;
|
|
buffw[2] = (LPWSTR)szHiW;
|
|
exp = ULHILEN * 3 * sizeof(WCHAR) + 3 * sizeof(WCHAR*) + sizeof(pv);
|
|
break;
|
|
case PT_MV_BINARY:
|
|
pv.Value.MVbin.cValues = 3;
|
|
pv.Value.MVbin.lpbin = buffbin;
|
|
buffbin[0].cb = 17;
|
|
buffbin[0].lpb = (LPBYTE)&iid;
|
|
buffbin[1].cb = 2;
|
|
buffbin[1].lpb = (LPBYTE)&iid;
|
|
buffbin[2].cb = 1;
|
|
buffbin[2].lpb = (LPBYTE)&iid;
|
|
exp = 20 + sizeof(pv) + sizeof(SBinary) * 3;
|
|
break;
|
|
default:
|
|
exp = 0;
|
|
}
|
|
|
|
ulRet = 0xffffffff;
|
|
res = pScCountProps(1, &pv, &ulRet);
|
|
if (!exp) {
|
|
success = res == MAPI_E_INVALID_PARAMETER && ulRet == 0xffffffff;
|
|
ok(success, "pt= %ld: Expected failure, got %ld, ret=0x%08lX\n",
|
|
pt, ulRet, res);
|
|
}
|
|
else {
|
|
success = res == S_OK && ulRet == exp;
|
|
ok(success, "pt= %ld: Expected %ld, got %ld, ret=0x%08lX\n",
|
|
pt, exp, ulRet, res);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
static void test_ScCopyRelocProps(void)
|
|
{
|
|
static const char* szTestA = "Test";
|
|
char buffer[512], buffer2[512], *lppszA[1];
|
|
SPropValue pvProp, *lpResProp = (LPSPropValue)buffer;
|
|
ULONG ulCount;
|
|
SCODE sc;
|
|
|
|
pScCopyProps = (void*)GetProcAddress(hMapi32, "ScCopyProps@16");
|
|
pScRelocProps = (void*)GetProcAddress(hMapi32, "ScRelocProps@20");
|
|
|
|
if (!pScCopyProps || !pScRelocProps)
|
|
return;
|
|
|
|
pvProp.ulPropTag = PROP_TAG(PT_MV_STRING8, 1u);
|
|
|
|
lppszA[0] = (char *)szTestA;
|
|
pvProp.Value.MVszA.cValues = 1;
|
|
pvProp.Value.MVszA.lppszA = lppszA;
|
|
ulCount = 0;
|
|
|
|
sc = pScCopyProps(1, &pvProp, buffer, &ulCount);
|
|
ok(sc == S_OK && lpResProp->ulPropTag == pvProp.ulPropTag &&
|
|
lpResProp->Value.MVszA.cValues == 1 &&
|
|
lpResProp->Value.MVszA.lppszA[0] == buffer + sizeof(SPropValue) + sizeof(char*) &&
|
|
ulCount == sizeof(SPropValue) + sizeof(char*) + 5 &&
|
|
!strcmp(lpResProp->Value.MVszA.lppszA[0], szTestA),
|
|
"CopyProps(str): Expected 0 {1,%lx,%p,%s} %d got 0x%08lx {%ld,%lx,%p,%s} %ld\n",
|
|
pvProp.ulPropTag, buffer + sizeof(SPropValue) + sizeof(char*),
|
|
szTestA, sizeof(SPropValue) + sizeof(char*) + 5, sc,
|
|
lpResProp->Value.MVszA.cValues, lpResProp->ulPropTag,
|
|
sc==S_OK?lpResProp->Value.MVszA.lppszA[0]:NULL,
|
|
sc==S_OK?lpResProp->Value.MVszA.lppszA[0]:NULL, ulCount);
|
|
|
|
memcpy(buffer2, buffer, sizeof(buffer));
|
|
|
|
/* Clear the data in the source buffer. Since pointers in the copied buffer
|
|
* refer to the source buffer, this proves that native always assumes that
|
|
* the copied buffers pointers are bad (needing to be relocated first).
|
|
*/
|
|
memset(buffer, 0, sizeof(buffer));
|
|
ulCount = 0;
|
|
|
|
sc = pScRelocProps(1, (LPSPropValue)buffer2, buffer, buffer2, &ulCount);
|
|
lpResProp = (LPSPropValue)buffer2;
|
|
ok(sc == S_OK && lpResProp->ulPropTag == pvProp.ulPropTag &&
|
|
lpResProp->Value.MVszA.cValues == 1 &&
|
|
lpResProp->Value.MVszA.lppszA[0] == buffer2 + sizeof(SPropValue) + sizeof(char*) &&
|
|
/* Native has a bug whereby it calculates the size correctly when copying
|
|
* but when relocating does not (presumably it uses UlPropSize() which
|
|
* ignores multivalue pointers). Wine returns the correct value.
|
|
*/
|
|
(ulCount == sizeof(SPropValue) + sizeof(char*) + 5 || ulCount == sizeof(SPropValue) + 5) &&
|
|
!strcmp(lpResProp->Value.MVszA.lppszA[0], szTestA),
|
|
"RelocProps(str): Expected 0 {1,%lx,%p,%s} %d got 0x%08lx {%ld,%lx,%p,%s} %ld\n",
|
|
pvProp.ulPropTag, buffer2 + sizeof(SPropValue) + sizeof(char*),
|
|
szTestA, sizeof(SPropValue) + sizeof(char*) + 5, sc,
|
|
lpResProp->Value.MVszA.cValues, lpResProp->ulPropTag,
|
|
sc==S_OK?lpResProp->Value.MVszA.lppszA[0]:NULL,
|
|
sc==S_OK?lpResProp->Value.MVszA.lppszA[0]:NULL, ulCount);
|
|
|
|
/* Native crashes with lpNew or lpOld set to NULL so skip testing this */
|
|
}
|
|
|
|
static void test_LpValFindProp(void)
|
|
{
|
|
SPropValue pvProp, *pRet;
|
|
ULONG i;
|
|
|
|
pLpValFindProp = (void*)GetProcAddress(hMapi32, "LpValFindProp@12");
|
|
|
|
if (!pLpValFindProp)
|
|
return;
|
|
|
|
for (i = 0; i < sizeof(ptTypes)/sizeof(ptTypes[0]); i++)
|
|
{
|
|
pvProp.ulPropTag = PROP_TAG(ptTypes[i], 1u);
|
|
|
|
pRet = pLpValFindProp(PROP_TAG(ptTypes[i], 1u), 1u, &pvProp);
|
|
ok(pRet == &pvProp, "LpValFindProp[%ld]: Didn't find existing propery id/type\n",
|
|
ptTypes[i]);
|
|
|
|
pRet = pLpValFindProp(PROP_TAG(ptTypes[i], 0u), 1u, &pvProp);
|
|
ok(pRet == NULL, "LpValFindProp[%ld]: Found nonexistent propery id\n",
|
|
ptTypes[i]);
|
|
|
|
pRet = pLpValFindProp(PROP_TAG(PT_NULL, 0u), 1u, &pvProp);
|
|
ok(pRet == NULL, "LpValFindProp[%ld]: Found nonexistent propery id/type\n",
|
|
ptTypes[i]);
|
|
|
|
pRet = pLpValFindProp(PROP_TAG(PT_NULL, 1u), 1u, &pvProp);
|
|
ok(pRet == &pvProp, "LpValFindProp[%ld]: Didn't find existing propery id\n",
|
|
ptTypes[i]);
|
|
}
|
|
}
|
|
|
|
static void test_FBadRglpszA(void)
|
|
{
|
|
LPSTR lpStrs[4];
|
|
char *szString = "A String";
|
|
BOOL bRet;
|
|
|
|
pFBadRglpszA = (void*)GetProcAddress(hMapi32, "FBadRglpszA@8");
|
|
if (!pFBadRglpszA)
|
|
return;
|
|
|
|
bRet = pFBadRglpszA(NULL, 10);
|
|
ok(bRet == TRUE, "FBadRglpszA(Null): expected TRUE, got FALSE\n");
|
|
|
|
lpStrs[0] = lpStrs[1] = lpStrs[2] = lpStrs[3] = NULL;
|
|
bRet = pFBadRglpszA(lpStrs, 4);
|
|
ok(bRet == TRUE, "FBadRglpszA(Nulls): expected TRUE, got FALSE\n");
|
|
|
|
lpStrs[0] = lpStrs[1] = lpStrs[2] = szString;
|
|
bRet = pFBadRglpszA(lpStrs, 3);
|
|
ok(bRet == FALSE, "FBadRglpszA(valid): expected FALSE, got TRUE\n");
|
|
|
|
bRet = pFBadRglpszA(lpStrs, 4);
|
|
ok(bRet == TRUE, "FBadRglpszA(1 invalid): expected TRUE, got FALSE\n");
|
|
}
|
|
|
|
static void test_FBadRglpszW(void)
|
|
{
|
|
LPWSTR lpStrs[4];
|
|
WCHAR szString[] = { 'A',' ','S','t','r','i','n','g','\0' };
|
|
BOOL bRet;
|
|
|
|
pFBadRglpszW = (void*)GetProcAddress(hMapi32, "FBadRglpszW@8");
|
|
if (!pFBadRglpszW)
|
|
return;
|
|
|
|
bRet = pFBadRglpszW(NULL, 10);
|
|
ok(bRet == TRUE, "FBadRglpszW(Null): expected TRUE, got FALSE\n");
|
|
|
|
lpStrs[0] = lpStrs[1] = lpStrs[2] = lpStrs[3] = NULL;
|
|
bRet = pFBadRglpszW(lpStrs, 4);
|
|
ok(bRet == TRUE, "FBadRglpszW(Nulls): expected TRUE, got FALSE\n");
|
|
|
|
lpStrs[0] = lpStrs[1] = lpStrs[2] = szString;
|
|
bRet = pFBadRglpszW(lpStrs, 3);
|
|
ok(bRet == FALSE, "FBadRglpszW(valid): expected FALSE, got TRUE\n");
|
|
|
|
bRet = pFBadRglpszW(lpStrs, 4);
|
|
ok(bRet == TRUE, "FBadRglpszW(1 invalid): expected TRUE, got FALSE\n");
|
|
}
|
|
|
|
static void test_FBadRowSet(void)
|
|
{
|
|
ULONG ulRet;
|
|
|
|
pFBadRowSet = (void*)GetProcAddress(hMapi32, "FBadRowSet@4");
|
|
if (!pFBadRowSet)
|
|
return;
|
|
|
|
ulRet = pFBadRowSet(NULL);
|
|
ok(ulRet != 0, "FBadRow(null): Expected non-zero, got 0\n");
|
|
|
|
/* FIXME */
|
|
}
|
|
|
|
static void test_FBadPropTag(void)
|
|
{
|
|
ULONG pt, res;
|
|
|
|
pFBadPropTag = (void*)GetProcAddress(hMapi32, "FBadPropTag@4");
|
|
if (!pFBadPropTag)
|
|
return;
|
|
|
|
for (pt = 0; pt < PROP_ID_INVALID; pt++)
|
|
{
|
|
BOOL bBad = TRUE;
|
|
|
|
switch (pt & (~MV_FLAG & PROP_TYPE_MASK))
|
|
{
|
|
case PT_UNSPECIFIED:
|
|
case PT_NULL: case PT_I2: case PT_I4: case PT_R4:
|
|
case PT_R8: case PT_CURRENCY: case PT_APPTIME:
|
|
case PT_ERROR: case PT_BOOLEAN: case PT_OBJECT:
|
|
case PT_I8: case PT_STRING8: case PT_UNICODE:
|
|
case PT_SYSTIME: case PT_CLSID: case PT_BINARY:
|
|
bBad = FALSE;
|
|
}
|
|
|
|
res = pFBadPropTag(pt);
|
|
if (bBad)
|
|
ok(res != 0, "pt= %ld: Expected non-zero, got 0\n", pt);
|
|
else
|
|
ok(res == 0, "pt= %ld: Expected zero, got %ld\n", pt, res);
|
|
}
|
|
}
|
|
|
|
static void test_FBadRow(void)
|
|
{
|
|
ULONG ulRet;
|
|
|
|
pFBadRow = (void*)GetProcAddress(hMapi32, "FBadRow@4");
|
|
if (!pFBadRow)
|
|
return;
|
|
|
|
ulRet = pFBadRow(NULL);
|
|
ok(ulRet != 0, "FBadRow(null): Expected non-zero, got 0\n");
|
|
|
|
/* FIXME */
|
|
}
|
|
|
|
static void test_FBadProp(void)
|
|
{
|
|
WCHAR szEmpty[] = { '\0' };
|
|
GUID iid;
|
|
ULONG pt, res;
|
|
SPropValue pv;
|
|
|
|
pFBadProp = (void*)GetProcAddress(hMapi32, "FBadProp@4");
|
|
if (!pFBadProp)
|
|
return;
|
|
|
|
for (pt = 0; pt < PROP_ID_INVALID; pt++)
|
|
{
|
|
BOOL bBad = TRUE;
|
|
|
|
memset(&pv, 0, sizeof(pv));
|
|
pv.ulPropTag = pt;
|
|
|
|
/* Note that MV values are valid below because their array count is 0,
|
|
* so no pointers are validated.
|
|
*/
|
|
switch (PROP_TYPE(pt))
|
|
{
|
|
case (MV_FLAG|PT_UNSPECIFIED):
|
|
case PT_UNSPECIFIED:
|
|
case (MV_FLAG|PT_NULL):
|
|
case PT_NULL:
|
|
case PT_MV_I2:
|
|
case PT_I2:
|
|
case PT_MV_I4:
|
|
case PT_I4:
|
|
case PT_MV_I8:
|
|
case PT_I8:
|
|
case PT_MV_R4:
|
|
case PT_R4:
|
|
case PT_MV_R8:
|
|
case PT_R8:
|
|
case PT_MV_CURRENCY:
|
|
case PT_CURRENCY:
|
|
case PT_MV_APPTIME:
|
|
case PT_APPTIME:
|
|
case (MV_FLAG|PT_ERROR):
|
|
case PT_ERROR:
|
|
case (MV_FLAG|PT_BOOLEAN):
|
|
case PT_BOOLEAN:
|
|
case (MV_FLAG|PT_OBJECT):
|
|
case PT_OBJECT:
|
|
case PT_MV_STRING8:
|
|
case PT_MV_UNICODE:
|
|
case PT_MV_SYSTIME:
|
|
case PT_SYSTIME:
|
|
case PT_MV_BINARY:
|
|
case PT_BINARY:
|
|
case PT_MV_CLSID:
|
|
bBad = FALSE;
|
|
break;
|
|
case PT_STRING8:
|
|
case PT_UNICODE:
|
|
pv.Value.lpszW = szEmpty;
|
|
bBad = FALSE;
|
|
break;
|
|
case PT_CLSID:
|
|
pv.Value.lpguid = &iid;
|
|
bBad = FALSE;
|
|
break;
|
|
}
|
|
|
|
res = pFBadProp(&pv);
|
|
if (bBad)
|
|
ok(res != 0, "pt= %ld: Expected non-zero, got 0\n", pt);
|
|
else
|
|
ok(res == 0, "pt= %ld: Expected zero, got %ld\n", pt, res);
|
|
}
|
|
}
|
|
|
|
static void test_FBadColumnSet(void)
|
|
{
|
|
SPropTagArray pta;
|
|
ULONG pt, res;
|
|
|
|
pFBadColumnSet = (void*)GetProcAddress(hMapi32, "FBadColumnSet@4");
|
|
if (!pFBadColumnSet)
|
|
return;
|
|
|
|
res = pFBadColumnSet(NULL);
|
|
ok(res != 0, "(null): Expected non-zero, got 0\n");
|
|
|
|
pta.cValues = 1;
|
|
|
|
for (pt = 0; pt < PROP_ID_INVALID; pt++)
|
|
{
|
|
BOOL bBad = TRUE;
|
|
|
|
pta.aulPropTag[0] = pt;
|
|
|
|
switch (pt & (~MV_FLAG & PROP_TYPE_MASK))
|
|
{
|
|
case PT_UNSPECIFIED:
|
|
case PT_NULL:
|
|
case PT_I2:
|
|
case PT_I4:
|
|
case PT_R4:
|
|
case PT_R8:
|
|
case PT_CURRENCY:
|
|
case PT_APPTIME:
|
|
case PT_BOOLEAN:
|
|
case PT_OBJECT:
|
|
case PT_I8:
|
|
case PT_STRING8:
|
|
case PT_UNICODE:
|
|
case PT_SYSTIME:
|
|
case PT_CLSID:
|
|
case PT_BINARY:
|
|
bBad = FALSE;
|
|
}
|
|
if (pt == (MV_FLAG|PT_ERROR))
|
|
bBad = FALSE;
|
|
|
|
res = pFBadColumnSet(&pta);
|
|
if (bBad)
|
|
ok(res != 0, "pt= %ld: Expected non-zero, got 0\n", pt);
|
|
else
|
|
ok(res == 0, "pt= %ld: Expected zero, got %ld\n", pt, res);
|
|
}
|
|
}
|
|
|
|
|
|
static void test_IProp(void)
|
|
{
|
|
IPropData *lpIProp;
|
|
LPMAPIERROR lpError;
|
|
LPSPropProblemArray lpProbs;
|
|
LPSPropValue lpProps;
|
|
LPSPropTagArray lpTags;
|
|
SPropValue pvs[2];
|
|
SizedSPropTagArray(2,tags);
|
|
ULONG access[2], count;
|
|
SCODE sc;
|
|
|
|
pCreateIProp = (void*)GetProcAddress(hMapi32, "CreateIProp@24");
|
|
if (!pCreateIProp)
|
|
return;
|
|
|
|
memset(&tags, 0 , sizeof(tags));
|
|
|
|
/* Create the object */
|
|
lpIProp = NULL;
|
|
sc = pCreateIProp(&IID_IMAPIPropData, MAPIAllocateBuffer, MAPIAllocateMore,
|
|
MAPIFreeBuffer, NULL, &lpIProp);
|
|
ok(sc == S_OK && lpIProp,
|
|
"CreateIProp: expected S_OK, non-null, got 0x%08lX,%p\n", sc, lpIProp);
|
|
|
|
if (sc != S_OK || !lpIProp)
|
|
return;
|
|
|
|
/* GetLastError - No errors set */
|
|
lpError = NULL;
|
|
IPropData_GetLastError(lpIProp, E_INVALIDARG, 0, &lpError);
|
|
ok(sc == S_OK && !lpError,
|
|
"GetLastError: Expected S_OK, null, got 0x%08lX,%p\n", sc, lpError);
|
|
|
|
/* Get prop tags - succeeds returning 0 items */
|
|
lpTags = NULL;
|
|
sc = IPropData_GetPropList(lpIProp, 0, &lpTags);
|
|
ok(sc == S_OK && lpTags && lpTags->cValues == 0,
|
|
"GetPropList(empty): Expected S_OK, non-null, 0, got 0x%08lX,%p,%ld\n",
|
|
sc, lpTags, lpTags ? lpTags->cValues : 0);
|
|
if (lpTags)
|
|
MAPIFreeBuffer(lpTags);
|
|
|
|
/* Get props - succeeds returning 0 items */
|
|
lpProps = NULL;
|
|
count = 0;
|
|
tags.cValues = 1;
|
|
tags.aulPropTag[0] = PR_IMPORTANCE;
|
|
sc = IPropData_GetProps(lpIProp, (LPSPropTagArray)&tags, 0, &count, &lpProps);
|
|
ok(sc == MAPI_W_ERRORS_RETURNED && lpProps && count == 1,
|
|
"GetProps(empty): Expected ERRORS_RETURNED, non-null, 1, got 0x%08lX,%p,%ld\n",
|
|
sc, lpProps, count);
|
|
if (lpProps && count > 0)
|
|
{
|
|
ok(lpProps[0].ulPropTag == CHANGE_PROP_TYPE(PR_IMPORTANCE,PT_ERROR),
|
|
"GetProps(empty): Expected %x, got %lx\n",
|
|
CHANGE_PROP_TYPE(PR_IMPORTANCE,PT_ERROR), lpProps[0].ulPropTag);
|
|
|
|
MAPIFreeBuffer(lpProps);
|
|
}
|
|
|
|
/* Add (NULL) - Can't add NULL's */
|
|
lpProbs = NULL;
|
|
pvs[0].ulPropTag = PROP_TAG(PT_NULL,0x01);
|
|
sc = IPropData_SetProps(lpIProp, 1, pvs, &lpProbs);
|
|
ok(sc == MAPI_E_INVALID_PARAMETER && !lpProbs,
|
|
"SetProps(): Expected INVALID_PARAMETER, null, got 0x%08lX,%p\n",
|
|
sc, lpProbs);
|
|
|
|
/* Add (OBJECT) - Can't add OBJECTS's */
|
|
lpProbs = NULL;
|
|
pvs[0].ulPropTag = PROP_TAG(PT_OBJECT,0x01);
|
|
sc = IPropData_SetProps(lpIProp, 1, pvs, &lpProbs);
|
|
ok(sc == MAPI_E_INVALID_PARAMETER && !lpProbs,
|
|
"SetProps(OBJECT): Expected INVALID_PARAMETER, null, got 0x%08lX,%p\n",
|
|
sc, lpProbs);
|
|
|
|
/* Add - Adds value */
|
|
lpProbs = NULL;
|
|
pvs[0].ulPropTag = PR_IMPORTANCE;
|
|
sc = IPropData_SetProps(lpIProp, 1, pvs, &lpProbs);
|
|
ok(sc == S_OK && !lpProbs,
|
|
"SetProps(ERROR): Expected S_OK, null, got 0x%08lX,%p\n", sc, lpProbs);
|
|
|
|
/* Get prop list - returns 1 item */
|
|
lpTags = NULL;
|
|
IPropData_GetPropList(lpIProp, 0, &lpTags);
|
|
ok(sc == S_OK && lpTags && lpTags->cValues == 1,
|
|
"GetPropList: Expected S_OK, non-null, 1, got 0x%08lX,%p,%ld\n",
|
|
sc, lpTags, lpTags ? lpTags->cValues : 0);
|
|
if (lpTags && lpTags->cValues > 0)
|
|
{
|
|
ok(lpTags->aulPropTag[0] == PR_IMPORTANCE,
|
|
"GetPropList: Expected %x, got %lx\n",
|
|
PR_IMPORTANCE, lpTags->aulPropTag[0]);
|
|
MAPIFreeBuffer(lpTags);
|
|
}
|
|
|
|
/* Set access to read and write */
|
|
sc = IPropData_HrSetObjAccess(lpIProp, IPROP_READWRITE);
|
|
ok(sc == S_OK, "SetObjAcess(WRITE): Expected S_OK got 0x%08lX\n", sc);
|
|
|
|
tags.cValues = 1;
|
|
tags.aulPropTag[0] = PR_IMPORTANCE;
|
|
|
|
/* Set item access (bad access) - Fails */
|
|
access[0] = 0;
|
|
sc = IPropData_HrSetPropAccess(lpIProp, (LPSPropTagArray)&tags, access);
|
|
ok(sc == MAPI_E_INVALID_PARAMETER,
|
|
"SetPropAcess(0): Expected INVALID_PARAMETER got 0x%08lX\n",sc);
|
|
access[0] = IPROP_READWRITE;
|
|
sc = IPropData_HrSetPropAccess(lpIProp, (LPSPropTagArray)&tags, access);
|
|
ok(sc == MAPI_E_INVALID_PARAMETER,
|
|
"SetPropAcess(RW): Expected INVALID_PARAMETER got 0x%08lX\n",sc);
|
|
access[0] = IPROP_CLEAN;
|
|
sc = IPropData_HrSetPropAccess(lpIProp, (LPSPropTagArray)&tags, access);
|
|
ok(sc == MAPI_E_INVALID_PARAMETER,
|
|
"SetPropAcess(C): Expected INVALID_PARAMETER got 0x%08lX\n",sc);
|
|
|
|
/* Set item access to read/write/clean */
|
|
tags.cValues = 1;
|
|
tags.aulPropTag[0] = PR_IMPORTANCE;
|
|
access[0] = IPROP_READWRITE|IPROP_CLEAN;
|
|
sc = IPropData_HrSetPropAccess(lpIProp, (LPSPropTagArray)&tags, access);
|
|
ok(sc == S_OK, "SetPropAcess(RW/C): Expected S_OK got 0x%08lX\n",sc);
|
|
|
|
/* Set object access to read only */
|
|
sc = IPropData_HrSetObjAccess(lpIProp, IPROP_READONLY);
|
|
ok(sc == S_OK, "SetObjAcess(READ): Expected S_OK got 0x%08lX\n", sc);
|
|
|
|
/* Set item access to read/write/dirty - doesn't care about RO object */
|
|
access[0] = IPROP_READONLY|IPROP_DIRTY;
|
|
sc = IPropData_HrSetPropAccess(lpIProp, (LPSPropTagArray)&tags, access);
|
|
ok(sc == S_OK, "SetPropAcess(WRITE): Expected S_OK got 0x%08lX\n", sc);
|
|
|
|
/* Delete any item when set to read only - Error */
|
|
lpProbs = NULL;
|
|
tags.aulPropTag[0] = PR_RESPONSE_REQUESTED;
|
|
sc = IPropData_DeleteProps(lpIProp, (LPSPropTagArray)&tags, &lpProbs);
|
|
ok(sc == E_ACCESSDENIED && !lpProbs,
|
|
"DeleteProps(nonexistent): Expected E_ACCESSDENIED null got 0x%08lX %p\n",
|
|
sc, lpProbs);
|
|
|
|
/* Set access to read and write */
|
|
sc = IPropData_HrSetObjAccess(lpIProp, IPROP_READWRITE);
|
|
ok(sc == S_OK, "SetObjAcess(WRITE): Expected S_OK got 0x%08lX\n", sc);
|
|
|
|
/* Delete nonexistent item - No error */
|
|
lpProbs = NULL;
|
|
tags.aulPropTag[0] = PR_RESPONSE_REQUESTED;
|
|
sc = IPropData_DeleteProps(lpIProp, (LPSPropTagArray)&tags, &lpProbs);
|
|
ok(sc == S_OK && !lpProbs,
|
|
"DeleteProps(nonexistent): Expected S_OK null got 0x%08lX %p\n",
|
|
sc, lpProbs);
|
|
|
|
/* Delete existing item (r/o) - No error, but lpProbs populated */
|
|
lpProbs = NULL;
|
|
tags.aulPropTag[0] = PR_IMPORTANCE;
|
|
sc = IPropData_DeleteProps(lpIProp, (LPSPropTagArray)&tags, &lpProbs);
|
|
ok(sc == S_OK && lpProbs,
|
|
"DeleteProps(RO): Expected S_OK non-null got 0x%08lX %p\n", sc, lpProbs);
|
|
|
|
if (lpProbs && lpProbs->cProblem > 0)
|
|
{
|
|
ok(lpProbs->cProblem == 1 &&
|
|
lpProbs->aProblem[0].ulIndex == 0 &&
|
|
lpProbs->aProblem[0].ulPropTag == PR_IMPORTANCE &&
|
|
lpProbs->aProblem[0].scode == E_ACCESSDENIED,
|
|
"DeleteProps(RO): Expected (1,0,%x,%lx) got (%ld,%lx,%lx)\n",
|
|
PR_IMPORTANCE, E_ACCESSDENIED,
|
|
lpProbs->aProblem[0].ulIndex, lpProbs->aProblem[0].ulPropTag,
|
|
lpProbs->aProblem[0].scode);
|
|
MAPIFreeBuffer(lpProbs);
|
|
}
|
|
|
|
lpProbs = NULL;
|
|
tags.cValues = 1;
|
|
tags.aulPropTag[0] = PR_RESPONSE_REQUESTED;
|
|
IPropData_HrAddObjProps(lpIProp, (LPSPropTagArray)&tags, &lpProbs);
|
|
ok(sc == S_OK && !lpProbs,
|
|
"AddObjProps(RO): Expected S_OK null got 0x%08lX %p\n", sc, lpProbs);
|
|
|
|
/* Get prop list - returns 1 item */
|
|
lpTags = NULL;
|
|
IPropData_GetPropList(lpIProp, 0, &lpTags);
|
|
ok(sc == S_OK && lpTags && lpTags->cValues == 1,
|
|
"GetPropList: Expected S_OK, non-null, 1, got 0x%08lX,%p,%ld\n",
|
|
sc, lpTags, lpTags ? lpTags->cValues : 0);
|
|
if (lpTags && lpTags->cValues > 0)
|
|
{
|
|
ok(lpTags->aulPropTag[0] == PR_IMPORTANCE,
|
|
"GetPropList: Expected %x, got %lx\n",
|
|
PR_IMPORTANCE, lpTags->aulPropTag[0]);
|
|
MAPIFreeBuffer(lpTags);
|
|
}
|
|
|
|
/* Set item to r/w again */
|
|
access[0] = IPROP_READWRITE|IPROP_DIRTY;
|
|
sc = IPropData_HrSetPropAccess(lpIProp, (LPSPropTagArray)&tags, access);
|
|
ok(sc == S_OK, "SetPropAcess(WRITE): Expected S_OK got 0x%08lX\n", sc);
|
|
|
|
/* Delete existing item (r/w) - No error, no problems */
|
|
lpProbs = NULL;
|
|
sc = IPropData_DeleteProps(lpIProp, (LPSPropTagArray)&tags, &lpProbs);
|
|
ok(sc == S_OK && !lpProbs,
|
|
"DeleteProps(RO): Expected S_OK null got 0x%08lX %p\n", sc, lpProbs);
|
|
|
|
/* Free the list */
|
|
IPropData_Release(lpIProp);
|
|
}
|
|
|
|
START_TEST(prop)
|
|
{
|
|
hMapi32 = LoadLibraryA("mapi32.dll");
|
|
|
|
pScInitMapiUtil = (void*)GetProcAddress(hMapi32, "ScInitMapiUtil@4");
|
|
if (!pScInitMapiUtil)
|
|
return;
|
|
pScInitMapiUtil(0);
|
|
|
|
test_PropCopyMore();
|
|
test_UlPropSize();
|
|
test_FPropContainsProp();
|
|
test_FPropCompareProp();
|
|
test_LPropCompareProp();
|
|
test_PpropFindProp();
|
|
test_ScCountProps();
|
|
test_ScCopyRelocProps();
|
|
test_LpValFindProp();
|
|
test_FBadRglpszA();
|
|
test_FBadRglpszW();
|
|
test_FBadRowSet();
|
|
test_FBadPropTag();
|
|
test_FBadRow();
|
|
test_FBadProp();
|
|
test_FBadColumnSet();
|
|
|
|
test_IProp();
|
|
}
|