git.oblomov.eu Git - wine/blob - dlls/mapi32/tests/prop.c

   1 /*
   2  * Unit test suite for MAPI property functions
   3  *
   4  * Copyright 2004 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "wine/test.h"
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "winuser.h"
  25 #include "winerror.h"
  26 #include "winnt.h"
  27 #include "initguid.h"
  28 #include "mapiutil.h"
  29 #include "mapitags.h"
  30 #include "mapi32_test.h"
  31
  32 static HMODULE hMapi32 = 0;
  33
  34 static SCODE        (WINAPI *pScInitMapiUtil)(ULONG);
  35 static void         (WINAPI *pDeinitMapiUtil)(void);
  36 static SCODE        (WINAPI *pPropCopyMore)(LPSPropValue,LPSPropValue,ALLOCATEMORE*,LPVOID);
  37 static ULONG        (WINAPI *pUlPropSize)(LPSPropValue);
  38 static BOOL         (WINAPI *pFPropContainsProp)(LPSPropValue,LPSPropValue,ULONG);
  39 static BOOL         (WINAPI *pFPropCompareProp)(LPSPropValue,ULONG,LPSPropValue);
  40 static LONG         (WINAPI *pLPropCompareProp)(LPSPropValue,LPSPropValue);
  41 static LPSPropValue (WINAPI *pPpropFindProp)(LPSPropValue,ULONG,ULONG);
  42 static SCODE        (WINAPI *pScCountProps)(INT,LPSPropValue,ULONG*);
  43 static SCODE        (WINAPI *pScCopyProps)(int,LPSPropValue,LPVOID,ULONG*);
  44 static SCODE        (WINAPI *pScRelocProps)(int,LPSPropValue,LPVOID,LPVOID,ULONG*);
  45 static LPSPropValue (WINAPI *pLpValFindProp)(ULONG,ULONG,LPSPropValue);
  46 static BOOL         (WINAPI *pFBadRglpszA)(LPSTR*,ULONG);
  47 static BOOL         (WINAPI *pFBadRglpszW)(LPWSTR*,ULONG);
  48 static BOOL         (WINAPI *pFBadRowSet)(LPSRowSet);
  49 static ULONG        (WINAPI *pFBadPropTag)(ULONG);
  50 static ULONG        (WINAPI *pFBadRow)(LPSRow);
  51 static ULONG        (WINAPI *pFBadProp)(LPSPropValue);
  52 static ULONG        (WINAPI *pFBadColumnSet)(LPSPropTagArray);
  53 static SCODE        (WINAPI *pCreateIProp)(LPCIID,ALLOCATEBUFFER*,ALLOCATEMORE*,
  54                                            FREEBUFFER*,LPVOID,LPPROPDATA*);
  55 static SCODE        (WINAPI *pMAPIAllocateBuffer)(ULONG, LPVOID);
  56 static SCODE        (WINAPI *pMAPIAllocateMore)(ULONG, LPVOID, LPVOID);
  57 static SCODE        (WINAPI *pMAPIInitialize)(LPVOID);
  58 static SCODE        (WINAPI *pMAPIFreeBuffer)(LPVOID);
  59 static void         (WINAPI *pMAPIUninitialize)(void);
  60
  61 static BOOL InitFuncPtrs(void)
  62 {
  63     hMapi32 = LoadLibraryA("mapi32.dll");
  64
  65     pPropCopyMore = (void*)GetProcAddress(hMapi32, "PropCopyMore@16");
  66     pUlPropSize = (void*)GetProcAddress(hMapi32, "UlPropSize@4");
  67     pFPropContainsProp = (void*)GetProcAddress(hMapi32, "FPropContainsProp@12");
  68     pFPropCompareProp = (void*)GetProcAddress(hMapi32, "FPropCompareProp@12");
  69     pLPropCompareProp = (void*)GetProcAddress(hMapi32, "LPropCompareProp@8");
  70     pPpropFindProp = (void*)GetProcAddress(hMapi32, "PpropFindProp@12");
  71     pScCountProps = (void*)GetProcAddress(hMapi32, "ScCountProps@12");
  72     pScCopyProps = (void*)GetProcAddress(hMapi32, "ScCopyProps@16");
  73     pScRelocProps = (void*)GetProcAddress(hMapi32, "ScRelocProps@20");
  74     pLpValFindProp = (void*)GetProcAddress(hMapi32, "LpValFindProp@12");
  75     pFBadRglpszA = (void*)GetProcAddress(hMapi32, "FBadRglpszA@8");
  76     pFBadRglpszW = (void*)GetProcAddress(hMapi32, "FBadRglpszW@8");
  77     pFBadRowSet = (void*)GetProcAddress(hMapi32, "FBadRowSet@4");
  78     pFBadPropTag = (void*)GetProcAddress(hMapi32, "FBadPropTag@4");
  79     pFBadRow = (void*)GetProcAddress(hMapi32, "FBadRow@4");
  80     pFBadProp = (void*)GetProcAddress(hMapi32, "FBadProp@4");
  81     pFBadColumnSet = (void*)GetProcAddress(hMapi32, "FBadColumnSet@4");
  82     pCreateIProp = (void*)GetProcAddress(hMapi32, "CreateIProp@24");
  83
  84     pScInitMapiUtil = (void*)GetProcAddress(hMapi32, "ScInitMapiUtil@4");
  85     pDeinitMapiUtil = (void*)GetProcAddress(hMapi32, "DeinitMapiUtil@0");
  86     pMAPIAllocateBuffer = (void*)GetProcAddress(hMapi32, "MAPIAllocateBuffer");
  87     pMAPIAllocateMore = (void*)GetProcAddress(hMapi32, "MAPIAllocateMore");
  88     pMAPIFreeBuffer = (void*)GetProcAddress(hMapi32, "MAPIFreeBuffer");
  89     pMAPIInitialize = (void*)GetProcAddress(hMapi32, "MAPIInitialize");
  90     pMAPIUninitialize = (void*)GetProcAddress(hMapi32, "MAPIUninitialize");
  91
  92     return pMAPIAllocateBuffer && pMAPIAllocateMore && pMAPIFreeBuffer &&
  93            pScInitMapiUtil && pDeinitMapiUtil;
  94 }
  95
  96 /* FIXME: Test PT_I2, PT_I4, PT_R4, PT_R8, PT_CURRENCY, PT_APPTIME, PT_SYSTIME,
  97  * PT_ERROR, PT_BOOLEAN, PT_I8, and PT_CLSID. */
  98 static ULONG ptTypes[] = {
  99     PT_STRING8, PT_BINARY, PT_UNICODE
 100 };
 101
 102 static inline int strcmpW(const WCHAR *str1, const WCHAR *str2)
 103 {
 104     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 105     return *str1 - *str2;
 106 }
 107
 108 static void test_PropCopyMore(void)
 109 {
 110     static char szHiA[] = "Hi!";
 111     static WCHAR szHiW[] = { 'H', 'i', '!', '\0' };
 112     SPropValue *lpDest = NULL, *lpSrc = NULL;
 113     ULONG i;
 114     SCODE scode;
 115
 116     if (!pPropCopyMore)
 117     {
 118         win_skip("PropCopyMore is not available\n");
 119         return;
 120     }
 121
 122     scode = pMAPIAllocateBuffer(sizeof(SPropValue), &lpDest);
 123     ok(scode == S_OK, "Expected MAPIAllocateBuffer to return S_OK, got 0x%x\n", scode);
 124     if (FAILED(scode))
 125     {
 126         skip("MAPIAllocateBuffer failed\n");
 127         return;
 128     }
 129
 130     scode = pMAPIAllocateMore(sizeof(SPropValue), lpDest, &lpSrc);
 131     ok(scode == S_OK, "Expected MAPIAllocateMore to return S_OK, got 0x%x\n", scode);
 132     if (FAILED(scode))
 133     {
 134         skip("MAPIAllocateMore failed\n");
 135         return;
 136     }
 137
 138     for (i = 0; i < sizeof(ptTypes)/sizeof(ptTypes[0]); i++)
 139     {
 140         lpSrc->ulPropTag = ptTypes[i];
 141
 142         switch (ptTypes[i])
 143         {
 144         case PT_STRING8:
 145             lpSrc->Value.lpszA = szHiA;
 146             break;
 147         case PT_UNICODE:
 148             lpSrc->Value.lpszW = szHiW;
 149             break;
 150         case PT_BINARY:
 151             lpSrc->Value.bin.cb = 4;
 152             lpSrc->Value.bin.lpb = (LPBYTE)szHiA;
 153             break;
 154         }
 155
 156         memset(lpDest, 0xff, sizeof(SPropValue));
 157
 158         scode = pPropCopyMore(lpDest, lpSrc, (ALLOCATEMORE*)pMAPIAllocateMore, lpDest);
 159         ok(!scode && lpDest->ulPropTag == lpSrc->ulPropTag,
 160            "PropCopyMore: Expected 0x0,%d, got 0x%08x,%d\n",
 161            lpSrc->ulPropTag, scode, lpDest->ulPropTag);
 162         if (SUCCEEDED(scode))
 163         {
 164             switch (ptTypes[i])
 165             {
 166             case PT_STRING8:
 167                 ok(lstrcmpA(lpDest->Value.lpszA, lpSrc->Value.lpszA) == 0,
 168                    "PropCopyMore: Ascii string differs\n");
 169                 break;
 170             case PT_UNICODE:
 171                 ok(strcmpW(lpDest->Value.lpszW, lpSrc->Value.lpszW) == 0,
 172                    "PropCopyMore: Unicode string differs\n");
 173                 break;
 174             case PT_BINARY:
 175                 ok(lpDest->Value.bin.cb == 4 &&
 176                    !memcmp(lpSrc->Value.bin.lpb, lpDest->Value.bin.lpb, 4),
 177                    "PropCopyMore: Binary array  differs\n");
 178                 break;
 179             }
 180         }
 181     }
 182
 183     /* Since all allocations are linked, freeing lpDest frees everything */
 184     scode = pMAPIFreeBuffer(lpDest);
 185     ok(scode == S_OK, "Expected MAPIFreeBuffer to return S_OK, got 0x%x\n", scode);
 186 }
 187
 188 static void test_UlPropSize(void)
 189 {
 190     static char szHiA[] = "Hi!";
 191     static WCHAR szHiW[] = { 'H', 'i', '!', '\0' };
 192     LPSTR  buffa[2];
 193     LPWSTR buffw[2];
 194     SBinary buffbin[2];
 195     ULONG pt, exp, res;
 196
 197     if (!pUlPropSize)
 198     {
 199         win_skip("UlPropSize is not available\n");
 200         return;
 201     }
 202
 203     for (pt = 0; pt < PROP_ID_INVALID; pt++)
 204     {
 205         SPropValue pv;
 206
 207         memset(&pv, 0 ,sizeof(pv));
 208         pv.ulPropTag = pt;
 209
 210         exp = 1u; /* Default to one item for non-MV properties */
 211
 212         switch (PROP_TYPE(pt))
 213         {
 214         case PT_MV_I2:       pv.Value.MVi.cValues = exp = 2;
 215         case PT_I2:          exp *= sizeof(USHORT); break;
 216         case PT_MV_I4:       pv.Value.MVl.cValues = exp = 2;
 217         case PT_I4:          exp *= sizeof(LONG); break;
 218         case PT_MV_R4:       pv.Value.MVflt.cValues = exp = 2;
 219         case PT_R4:          exp *= sizeof(float); break;
 220         case PT_MV_DOUBLE:   pv.Value.MVdbl.cValues = exp = 2;
 221         case PT_R8:          exp *= sizeof(double); break;
 222         case PT_MV_CURRENCY: pv.Value.MVcur.cValues = exp = 2;
 223         case PT_CURRENCY:    exp *= sizeof(CY); break;
 224         case PT_MV_APPTIME:  pv.Value.MVat.cValues = exp = 2;
 225         case PT_APPTIME:     exp *= sizeof(double); break;
 226         case PT_MV_SYSTIME:  pv.Value.MVft.cValues = exp = 2;
 227         case PT_SYSTIME:     exp *= sizeof(FILETIME); break;
 228         case PT_ERROR:       exp = sizeof(SCODE); break;
 229         case PT_BOOLEAN:     exp = sizeof(USHORT); break;
 230         case PT_OBJECT:      exp = 0; break;
 231         case PT_MV_I8:       pv.Value.MVli.cValues = exp = 2;
 232         case PT_I8:          exp *= sizeof(LONG64); break;
 233 #if 0
 234         /* My version of native mapi returns 0 for PT_MV_CLSID even if a valid
 235          * array is given. This _has_ to be a bug, so Wine does
 236          * the right thing(tm) and we don't test it here.
 237          */
 238         case PT_MV_CLSID:    pv.Value.MVguid.cValues = exp = 2;
 239 #endif
 240         case PT_CLSID:       exp *= sizeof(GUID); break;
 241         case PT_STRING8:
 242             pv.Value.lpszA = szHiA;
 243             exp = 4;
 244             break;
 245         case PT_UNICODE:
 246             pv.Value.lpszW = szHiW;
 247             exp = 4 * sizeof(WCHAR);
 248             break;
 249         case PT_BINARY:
 250             pv.Value.bin.cb = exp = 19;
 251             break;
 252         case PT_MV_STRING8:
 253             pv.Value.MVszA.cValues = 2;
 254             pv.Value.MVszA.lppszA = buffa;
 255             buffa[0] = szHiA;
 256             buffa[1] = szHiA;
 257             exp = 8;
 258             break;
 259         case PT_MV_UNICODE:
 260             pv.Value.MVszW.cValues = 2;
 261             pv.Value.MVszW.lppszW = buffw;
 262             buffw[0] = szHiW;
 263             buffw[1] = szHiW;
 264             exp = 8 * sizeof(WCHAR);
 265             break;
 266         case PT_MV_BINARY:
 267             pv.Value.MVbin.cValues = 2;
 268             pv.Value.MVbin.lpbin = buffbin;
 269             buffbin[0].cb = 19;
 270             buffbin[1].cb = 1;
 271             exp = 20;
 272             break;
 273         default:
 274             exp = 0;
 275         }
 276
 277         res = pUlPropSize(&pv);
 278         ok(res == exp,
 279            "pt= %d: Expected %d, got %d\n", pt, exp, res);
 280     }
 281 }
 282
 283 static void test_FPropContainsProp(void)
 284 {
 285     static char szFull[] = "Full String";
 286     static char szFullLower[] = "full string";
 287     static char szPrefix[] = "Full";
 288     static char szPrefixLower[] = "full";
 289     static char szSubstring[] = "ll St";
 290     static char szSubstringLower[] = "ll st";
 291     SPropValue pvLeft, pvRight;
 292     ULONG pt;
 293     BOOL bRet;
 294
 295     if (!pFPropContainsProp)
 296     {
 297         win_skip("FPropContainsProp is not available\n");
 298         return;
 299     }
 300
 301     /* Ensure that only PT_STRING8 and PT_BINARY are handled */
 302     for (pt = 0; pt < PROP_ID_INVALID; pt++)
 303     {
 304         if (pt == PT_STRING8 || pt == PT_BINARY)
 305             continue; /* test these later */
 306
 307         memset(&pvLeft, 0 ,sizeof(pvLeft));
 308         memset(&pvRight, 0 ,sizeof(pvRight));
 309         pvLeft.ulPropTag = pvRight.ulPropTag = pt;
 310
 311         bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
 312         ok(bRet == FALSE, "pt= %d: Expected FALSE, got %d\n", pt, bRet);
 313     }
 314
 315     /* test the various flag combinations */
 316     pvLeft.ulPropTag = pvRight.ulPropTag = PT_STRING8;
 317     pvLeft.Value.lpszA = szFull;
 318     pvRight.Value.lpszA = szFull;
 319
 320     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
 321     ok(bRet == TRUE, "(full,full)[] match failed\n");
 322     pvRight.Value.lpszA = szPrefix;
 323     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
 324     ok(bRet == FALSE, "(full,prefix)[] match failed\n");
 325     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
 326     ok(bRet == TRUE, "(full,prefix)[PREFIX] match failed\n");
 327     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
 328     ok(bRet == TRUE, "(full,prefix)[SUBSTRING] match failed\n");
 329     pvRight.Value.lpszA = szPrefixLower;
 330     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
 331     ok(bRet == FALSE, "(full,prefixlow)[PREFIX] match failed\n");
 332     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
 333     ok(bRet == FALSE, "(full,prefixlow)[SUBSTRING] match failed\n");
 334     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX|FL_IGNORECASE);
 335     ok(bRet == TRUE, "(full,prefixlow)[PREFIX|IGNORECASE] match failed\n");
 336     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING|FL_IGNORECASE);
 337     ok(bRet == TRUE, "(full,prefixlow)[SUBSTRING|IGNORECASE] match failed\n");
 338     pvRight.Value.lpszA = szSubstring;
 339     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
 340     ok(bRet == FALSE, "(full,substr)[] match failed\n");
 341     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
 342     ok(bRet == FALSE, "(full,substr)[PREFIX] match failed\n");
 343     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
 344     ok(bRet == TRUE, "(full,substr)[SUBSTRING] match failed\n");
 345     pvRight.Value.lpszA = szSubstringLower;
 346     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
 347     ok(bRet == FALSE, "(full,substrlow)[PREFIX] match failed\n");
 348     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
 349     ok(bRet == FALSE, "(full,substrlow)[SUBSTRING] match failed\n");
 350     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX|FL_IGNORECASE);
 351     ok(bRet == FALSE, "(full,substrlow)[PREFIX|IGNORECASE] match failed\n");
 352     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING|FL_IGNORECASE);
 353     ok(bRet == TRUE, "(full,substrlow)[SUBSTRING|IGNORECASE] match failed\n");
 354     pvRight.Value.lpszA = szFullLower;
 355     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING|FL_IGNORECASE);
 356     ok(bRet == TRUE, "(full,fulllow)[IGNORECASE] match failed\n");
 357
 358     pvLeft.ulPropTag = pvRight.ulPropTag = PT_BINARY;
 359     pvLeft.Value.bin.lpb = (LPBYTE)szFull;
 360     pvRight.Value.bin.lpb = (LPBYTE)szFull;
 361     pvLeft.Value.bin.cb = pvRight.Value.bin.cb = strlen(szFull);
 362
 363     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
 364     ok(bRet == TRUE, "bin(full,full)[] match failed\n");
 365     pvRight.Value.bin.lpb = (LPBYTE)szPrefix;
 366     pvRight.Value.bin.cb = strlen(szPrefix);
 367     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
 368     ok(bRet == FALSE, "bin(full,prefix)[] match failed\n");
 369     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
 370     ok(bRet == TRUE, "bin(full,prefix)[PREFIX] match failed\n");
 371     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
 372     ok(bRet == TRUE, "bin(full,prefix)[SUBSTRING] match failed\n");
 373     pvRight.Value.bin.lpb = (LPBYTE)szPrefixLower;
 374     pvRight.Value.bin.cb = strlen(szPrefixLower);
 375     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
 376     ok(bRet == FALSE, "bin(full,prefixlow)[PREFIX] match failed\n");
 377     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
 378     ok(bRet == FALSE, "bin(full,prefixlow)[SUBSTRING] match failed\n");
 379     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX|FL_IGNORECASE);
 380     ok(bRet == FALSE, "bin(full,prefixlow)[PREFIX|IGNORECASE] match failed\n");
 381     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING|FL_IGNORECASE);
 382     ok(bRet == FALSE, "bin(full,prefixlow)[SUBSTRING|IGNORECASE] match failed\n");
 383     pvRight.Value.bin.lpb = (LPBYTE)szSubstring;
 384     pvRight.Value.bin.cb = strlen(szSubstring);
 385     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING);
 386     ok(bRet == FALSE, "bin(full,substr)[] match failed\n");
 387     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
 388     ok(bRet == FALSE, "bin(full,substr)[PREFIX] match failed\n");
 389     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
 390     ok(bRet == TRUE, "bin(full,substr)[SUBSTRING] match failed\n");
 391     pvRight.Value.bin.lpb = (LPBYTE)szSubstringLower;
 392     pvRight.Value.bin.cb = strlen(szSubstringLower);
 393     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX);
 394     ok(bRet == FALSE, "bin(full,substrlow)[PREFIX] match failed\n");
 395     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING);
 396     ok(bRet == FALSE, "bin(full,substrlow)[SUBSTRING] match failed\n");
 397     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_PREFIX|FL_IGNORECASE);
 398     ok(bRet == FALSE, "bin(full,substrlow)[PREFIX|IGNORECASE] match failed\n");
 399     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_SUBSTRING|FL_IGNORECASE);
 400     ok(bRet == FALSE, "bin(full,substrlow)[SUBSTRING|IGNORECASE] match failed\n");
 401     pvRight.Value.bin.lpb = (LPBYTE)szFullLower;
 402     pvRight.Value.bin.cb = strlen(szFullLower);
 403     bRet = pFPropContainsProp(&pvLeft, &pvRight, FL_FULLSTRING|FL_IGNORECASE);
 404     ok(bRet == FALSE, "bin(full,fulllow)[IGNORECASE] match failed\n");
 405 }
 406
 407 typedef struct tagFPropCompareProp_Result
 408 {
 409     SHORT lVal;
 410     SHORT rVal;
 411     ULONG relOp;
 412     BOOL  bRet;
 413 } FPropCompareProp_Result;
 414
 415 static const FPropCompareProp_Result FPCProp_Results[] =
 416 {
 417     { 1, 2, RELOP_LT, TRUE },
 418     { 1, 1, RELOP_LT, FALSE },
 419     { 2, 1, RELOP_LT, FALSE },
 420     { 1, 2, RELOP_LE, TRUE },
 421     { 1, 1, RELOP_LE, TRUE },
 422     { 2, 1, RELOP_LE, FALSE },
 423     { 1, 2, RELOP_GT, FALSE },
 424     { 1, 1, RELOP_GT, FALSE },
 425     { 2, 1, RELOP_GT, TRUE },
 426     { 1, 2, RELOP_GE, FALSE },
 427     { 1, 1, RELOP_GE, TRUE },
 428     { 2, 1, RELOP_GE, TRUE },
 429     { 1, 2, RELOP_EQ, FALSE },
 430     { 1, 1, RELOP_EQ, TRUE },
 431     { 2, 1, RELOP_EQ, FALSE }
 432 };
 433
 434 static const char *relops[] = { "RELOP_LT", "RELOP_LE", "RELOP_GT", "RELOP_GE", "RELOP_EQ" };
 435
 436 static void test_FPropCompareProp(void)
 437 {
 438     SPropValue pvLeft, pvRight;
 439     GUID lguid, rguid;
 440     char lbuffa[2], rbuffa[2];
 441     WCHAR lbuffw[2], rbuffw[2];
 442     ULONG i, j;
 443     BOOL bRet, bExp;
 444
 445     if (!pFPropCompareProp)
 446     {
 447         win_skip("FPropCompareProp is not available\n");
 448         return;
 449     }
 450
 451     lbuffa[1] = '\0';
 452     rbuffa[1] = '\0';
 453     lbuffw[1] = '\0';
 454     rbuffw[1] = '\0';
 455
 456     for (i = 0; i < sizeof(ptTypes)/sizeof(ptTypes[0]); i++)
 457     {
 458         pvLeft.ulPropTag = pvRight.ulPropTag = ptTypes[i];
 459
 460         for (j = 0; j < sizeof(FPCProp_Results)/sizeof(FPCProp_Results[0]); j++)
 461         {
 462             SHORT lVal = FPCProp_Results[j].lVal;
 463             SHORT rVal = FPCProp_Results[j].rVal;
 464
 465             bExp = FPCProp_Results[j].bRet;
 466
 467             switch (ptTypes[i])
 468             {
 469             case PT_BOOLEAN:
 470                 /* Boolean values have no concept of less or greater than, only equality */
 471                 if ((lVal == 1 && rVal == 2 && FPCProp_Results[j].relOp == RELOP_LT) ||
 472                     (lVal == 2 && rVal == 1 && FPCProp_Results[j].relOp == RELOP_LE)||
 473                     (lVal == 2 && rVal == 1 && FPCProp_Results[j].relOp == RELOP_GT)||
 474                     (lVal == 1 && rVal == 2 && FPCProp_Results[j].relOp == RELOP_GE)||
 475                     (lVal == 1 && rVal == 2 && FPCProp_Results[j].relOp == RELOP_EQ)||
 476                     (lVal == 2 && rVal == 1 && FPCProp_Results[j].relOp == RELOP_EQ))
 477                     bExp = !bExp;
 478                     /* Fall through ... */
 479             case PT_I2:
 480                 pvLeft.Value.i = lVal;
 481                 pvRight.Value.i = rVal;
 482                 break;
 483             case PT_ERROR:
 484             case PT_I4:
 485                 pvLeft.Value.l = lVal;
 486                 pvRight.Value.l = rVal;
 487                 break;
 488             case PT_R4:
 489                 pvLeft.Value.flt = lVal;
 490                 pvRight.Value.flt = rVal;
 491                 break;
 492             case PT_APPTIME:
 493             case PT_R8:
 494                 pvLeft.Value.dbl = lVal;
 495                 pvRight.Value.dbl = rVal;
 496                 break;
 497             case PT_CURRENCY:
 498                 pvLeft.Value.cur.int64 = lVal;
 499                 pvRight.Value.cur.int64 = rVal;
 500                 break;
 501             case PT_SYSTIME:
 502                 pvLeft.Value.ft.dwLowDateTime = lVal;
 503                 pvLeft.Value.ft.dwHighDateTime = 0;
 504                 pvRight.Value.ft.dwLowDateTime = rVal;
 505                 pvRight.Value.ft.dwHighDateTime = 0;
 506                 break;
 507             case PT_I8:
 508                 pvLeft.Value.li.u.LowPart = lVal;
 509                 pvLeft.Value.li.u.HighPart = 0;
 510                 pvRight.Value.li.u.LowPart = rVal;
 511                 pvRight.Value.li.u.HighPart = 0;
 512                 break;
 513             case PT_CLSID:
 514                 memset(&lguid, 0, sizeof(GUID));
 515                 memset(&rguid, 0, sizeof(GUID));
 516                 lguid.Data4[7] = lVal;
 517                 rguid.Data4[7] = rVal;
 518                 pvLeft.Value.lpguid = &lguid;
 519                 pvRight.Value.lpguid = &rguid;
 520                 break;
 521             case PT_STRING8:
 522                 pvLeft.Value.lpszA = lbuffa;
 523                 pvRight.Value.lpszA = rbuffa;
 524                 lbuffa[0] = '0' + lVal;
 525                 rbuffa[0] = '0' + rVal;
 526                 break;
 527             case PT_UNICODE:
 528                 pvLeft.Value.lpszW = lbuffw;
 529                 pvRight.Value.lpszW = rbuffw;
 530                 lbuffw[0] = '0' + lVal;
 531                 rbuffw[0] = '0' + rVal;
 532                 break;
 533             case PT_BINARY:
 534                 pvLeft.Value.bin.cb = 1;
 535                 pvRight.Value.bin.cb = 1;
 536                 pvLeft.Value.bin.lpb = (LPBYTE)lbuffa;
 537                 pvRight.Value.bin.lpb = (LPBYTE)rbuffa;
 538                 lbuffa[0] = lVal;
 539                 rbuffa[0] = rVal;
 540                 break;
 541             }
 542
 543             bRet = pFPropCompareProp(&pvLeft, FPCProp_Results[j].relOp, &pvRight);
 544             ok(bRet == bExp,
 545                "pt %d (%d,%d,%s): expected %d, got %d\n", ptTypes[i],
 546                FPCProp_Results[j].lVal, FPCProp_Results[j].rVal,
 547                relops[FPCProp_Results[j].relOp], bExp, bRet);
 548         }
 549     }
 550 }
 551
 552 typedef struct tagLPropCompareProp_Result
 553 {
 554     SHORT lVal;
 555     SHORT rVal;
 556     INT   iRet;
 557 } LPropCompareProp_Result;
 558
 559 static const LPropCompareProp_Result LPCProp_Results[] =
 560 {
 561     { 1, 2, -1 },
 562     { 1, 1, 0 },
 563     { 2, 1, 1 },
 564 };
 565
 566 static void test_LPropCompareProp(void)
 567 {
 568     SPropValue pvLeft, pvRight;
 569     GUID lguid, rguid;
 570     char lbuffa[2], rbuffa[2];
 571     WCHAR lbuffw[2], rbuffw[2];
 572     ULONG i, j;
 573     INT iRet, iExp;
 574
 575     if (!pLPropCompareProp)
 576     {
 577         win_skip("LPropCompareProp is not available\n");
 578         return;
 579     }
 580
 581     lbuffa[1] = '\0';
 582     rbuffa[1] = '\0';
 583     lbuffw[1] = '\0';
 584     rbuffw[1] = '\0';
 585
 586     for (i = 0; i < sizeof(ptTypes)/sizeof(ptTypes[0]); i++)
 587     {
 588         pvLeft.ulPropTag = pvRight.ulPropTag = ptTypes[i];
 589
 590         for (j = 0; j < sizeof(LPCProp_Results)/sizeof(LPCProp_Results[0]); j++)
 591         {
 592             SHORT lVal = LPCProp_Results[j].lVal;
 593             SHORT rVal = LPCProp_Results[j].rVal;
 594
 595             iExp = LPCProp_Results[j].iRet;
 596
 597             switch (ptTypes[i])
 598             {
 599             case PT_BOOLEAN:
 600                 /* Boolean values have no concept of less or greater than, only equality */
 601                 if (lVal && rVal)
 602                     iExp = 0;
 603                     /* Fall through ... */
 604             case PT_I2:
 605                 pvLeft.Value.i = lVal;
 606                 pvRight.Value.i = rVal;
 607                 break;
 608             case PT_ERROR:
 609             case PT_I4:
 610                 pvLeft.Value.l = lVal;
 611                 pvRight.Value.l = rVal;
 612                 break;
 613             case PT_R4:
 614                 pvLeft.Value.flt = lVal;
 615                 pvRight.Value.flt = rVal;
 616                 break;
 617             case PT_APPTIME:
 618             case PT_R8:
 619                 pvLeft.Value.dbl = lVal;
 620                 pvRight.Value.dbl = rVal;
 621                 break;
 622             case PT_CURRENCY:
 623                 pvLeft.Value.cur.int64 = lVal;
 624                 pvRight.Value.cur.int64 = rVal;
 625                 break;
 626             case PT_SYSTIME:
 627                 pvLeft.Value.ft.dwLowDateTime = lVal;
 628                 pvLeft.Value.ft.dwHighDateTime = 0;
 629                 pvRight.Value.ft.dwLowDateTime = rVal;
 630                 pvRight.Value.ft.dwHighDateTime = 0;
 631                 break;
 632             case PT_I8:
 633                 pvLeft.Value.li.u.LowPart = lVal;
 634                 pvLeft.Value.li.u.HighPart = 0;
 635                 pvRight.Value.li.u.LowPart = rVal;
 636                 pvRight.Value.li.u.HighPart = 0;
 637                 break;
 638             case PT_CLSID:
 639                 memset(&lguid, 0, sizeof(GUID));
 640                 memset(&rguid, 0, sizeof(GUID));
 641                 lguid.Data4[7] = lVal;
 642                 rguid.Data4[7] = rVal;
 643                 pvLeft.Value.lpguid = &lguid;
 644                 pvRight.Value.lpguid = &rguid;
 645                 break;
 646             case PT_STRING8:
 647                 pvLeft.Value.lpszA = lbuffa;
 648                 pvRight.Value.lpszA = rbuffa;
 649                 lbuffa[0] = '0' + lVal;
 650                 rbuffa[0] = '0' + rVal;
 651                 break;
 652             case PT_UNICODE:
 653                 pvLeft.Value.lpszW = lbuffw;
 654                 pvRight.Value.lpszW = rbuffw;
 655                 lbuffw[0] = '0' + lVal;
 656                 rbuffw[0] = '0' + rVal;
 657                 break;
 658             case PT_BINARY:
 659                 pvLeft.Value.bin.cb = 1;
 660                 pvRight.Value.bin.cb = 1;
 661                 pvLeft.Value.bin.lpb = (LPBYTE)lbuffa;
 662                 pvRight.Value.bin.lpb = (LPBYTE)rbuffa;
 663                 lbuffa[0] = lVal;
 664                 rbuffa[0] = rVal;
 665                 break;
 666             }
 667
 668             iRet = pLPropCompareProp(&pvLeft, &pvRight);
 669             ok(iRet == iExp,
 670                "pt %d (%d,%d): expected %d, got %d\n", ptTypes[i],
 671                LPCProp_Results[j].lVal, LPCProp_Results[j].rVal, iExp, iRet);
 672         }
 673     }
 674 }
 675
 676 static void test_PpropFindProp(void)
 677 {
 678     SPropValue pvProp, *pRet;
 679     ULONG i;
 680
 681     if (!pPpropFindProp)
 682     {
 683         win_skip("PpropFindProp is not available\n");
 684         return;
 685     }
 686
 687     for (i = 0; i < sizeof(ptTypes)/sizeof(ptTypes[0]); i++)
 688     {
 689         pvProp.ulPropTag = ptTypes[i];
 690
 691         pRet = pPpropFindProp(&pvProp, 1u, ptTypes[i]);
 692         ok(pRet == &pvProp,
 693            "PpropFindProp[%d]: Didn't find existing property\n",
 694            ptTypes[i]);
 695
 696         pRet = pPpropFindProp(&pvProp, 1u, i ? ptTypes[i-1] : ptTypes[i+1]);
 697         ok(pRet == NULL, "PpropFindProp[%d]: Found nonexistent property\n",
 698            ptTypes[i]);
 699     }
 700
 701     pvProp.ulPropTag = PROP_TAG(PT_I2, 1u);
 702     pRet = pPpropFindProp(&pvProp, 1u, PROP_TAG(PT_UNSPECIFIED, 0u));
 703     ok(pRet == NULL, "PpropFindProp[UNSPECIFIED]: Matched on different id\n");
 704     pRet = pPpropFindProp(&pvProp, 1u, PROP_TAG(PT_UNSPECIFIED, 1u));
 705     ok(pRet == &pvProp, "PpropFindProp[UNSPECIFIED]: Didn't match id\n");
 706 }
 707
 708 static void test_ScCountProps(void)
 709 {
 710     static char szHiA[] = "Hi!";
 711     static WCHAR szHiW[] = { 'H', 'i', '!', '\0' };
 712     static const ULONG ULHILEN = 4; /* chars in szHiA/W incl. NUL */
 713     LPSTR  buffa[3];
 714     LPWSTR buffw[3];
 715     SBinary buffbin[3];
 716     GUID iids[4], *iid = iids;
 717     SCODE res;
 718     ULONG pt, exp, ulRet;
 719     int success = 1;
 720
 721     if (!pScCountProps)
 722     {
 723         win_skip("ScCountProps is not available\n");
 724         return;
 725     }
 726
 727     for (pt = 0; pt < PROP_ID_INVALID && success; pt++)
 728     {
 729         SPropValue pv;
 730
 731         memset(&pv, 0 ,sizeof(pv));
 732         pv.ulPropTag = PROP_TAG(pt, 1u);
 733
 734         switch (PROP_TYPE(pt))
 735         {
 736         case PT_I2:
 737         case PT_I4:
 738         case PT_R4:
 739         case PT_R8:
 740         case PT_CURRENCY:
 741         case PT_APPTIME:
 742         case PT_SYSTIME:
 743         case PT_ERROR:
 744         case PT_BOOLEAN:
 745         case PT_OBJECT:
 746         case PT_I8:
 747             exp = sizeof(pv);
 748             break;
 749         case PT_CLSID:
 750             pv.Value.lpguid = iid;
 751             exp = sizeof(GUID) + sizeof(pv);
 752             break;
 753         case PT_STRING8:
 754             pv.Value.lpszA = szHiA;
 755             exp = 4 + sizeof(pv);
 756             break;
 757         case PT_UNICODE:
 758             pv.Value.lpszW = szHiW;
 759             exp = 4 * sizeof(WCHAR) + sizeof(pv);
 760             break;
 761         case PT_BINARY:
 762             pv.Value.bin.cb = 2;
 763             pv.Value.bin.lpb = (LPBYTE)iid;
 764             exp = 2 + sizeof(pv);
 765             break;
 766         case PT_MV_I2:
 767             pv.Value.MVi.cValues = 3;
 768             pv.Value.MVi.lpi = (SHORT*)iid;
 769             exp = 3 * sizeof(SHORT) + sizeof(pv);
 770             break;
 771         case PT_MV_I4:
 772             pv.Value.MVl.cValues = 3;
 773             pv.Value.MVl.lpl = (LONG*)iid;
 774             exp = 3 * sizeof(LONG) + sizeof(pv);
 775             break;
 776         case PT_MV_I8:
 777             pv.Value.MVli.cValues = 3;
 778             pv.Value.MVli.lpli = (LARGE_INTEGER*)iid;
 779             exp = 3 * sizeof(LARGE_INTEGER) + sizeof(pv);
 780             break;
 781         case PT_MV_R4:
 782             pv.Value.MVflt.cValues = 3;
 783             pv.Value.MVflt.lpflt = (float*)iid;
 784             exp = 3 * sizeof(float) + sizeof(pv);
 785             break;
 786         case PT_MV_APPTIME:
 787         case PT_MV_R8:
 788             pv.Value.MVdbl.cValues = 3;
 789             pv.Value.MVdbl.lpdbl = (double*)iid;
 790             exp = 3 * sizeof(double) + sizeof(pv);
 791             break;
 792         case PT_MV_CURRENCY:
 793             pv.Value.MVcur.cValues = 3;
 794             pv.Value.MVcur.lpcur = (CY*)iid;
 795             exp = 3 * sizeof(CY) + sizeof(pv);
 796             break;
 797         case PT_MV_SYSTIME:
 798             pv.Value.MVft.cValues = 3;
 799             pv.Value.MVft.lpft = (FILETIME*)iid;
 800             exp = 3 * sizeof(CY) + sizeof(pv);
 801             break;
 802         case PT_MV_STRING8:
 803             pv.Value.MVszA.cValues = 3;
 804             pv.Value.MVszA.lppszA = buffa;
 805             buffa[0] = szHiA;
 806             buffa[1] = szHiA;
 807             buffa[2] = szHiA;
 808             exp = ULHILEN * 3 + 3 * sizeof(char*) + sizeof(pv);
 809             break;
 810         case PT_MV_UNICODE:
 811             pv.Value.MVszW.cValues = 3;
 812             pv.Value.MVszW.lppszW = buffw;
 813             buffw[0] = szHiW;
 814             buffw[1] = szHiW;
 815             buffw[2] = szHiW;
 816             exp = ULHILEN * 3 * sizeof(WCHAR) + 3 * sizeof(WCHAR*) + sizeof(pv);
 817             break;
 818         case PT_MV_BINARY:
 819             pv.Value.MVbin.cValues = 3;
 820             pv.Value.MVbin.lpbin = buffbin;
 821             buffbin[0].cb = 17;
 822             buffbin[0].lpb = (LPBYTE)&iid;
 823             buffbin[1].cb = 2;
 824             buffbin[1].lpb = (LPBYTE)&iid;
 825             buffbin[2].cb = 1;
 826             buffbin[2].lpb = (LPBYTE)&iid;
 827             exp = 20 + sizeof(pv) + sizeof(SBinary) * 3;
 828             break;
 829         default:
 830             exp = 0;
 831         }
 832
 833         ulRet = 0xffffffff;
 834         res = pScCountProps(1, &pv, &ulRet);
 835         if (!exp) {
 836             success = res == MAPI_E_INVALID_PARAMETER && ulRet == 0xffffffff;
 837             ok(success, "pt= %d: Expected failure, got %d, ret=0x%08X\n",
 838                pt, ulRet, res);
 839         }
 840         else {
 841             success = res == S_OK && ulRet == exp;
 842             ok(success, "pt= %d: Expected %d, got %d, ret=0x%08X\n",
 843                pt, exp, ulRet, res);
 844         }
 845     }
 846
 847 }
 848
 849 static void test_ScCopyRelocProps(void)
 850 {
 851     static char szTestA[] = "Test";
 852     char buffer[512], buffer2[512], *lppszA[1];
 853     SPropValue pvProp, *lpResProp = (LPSPropValue)buffer;
 854     ULONG ulCount;
 855     SCODE sc;
 856
 857     if (!pScCopyProps || !pScRelocProps)
 858     {
 859         win_skip("SPropValue copy functions are not available\n");
 860         return;
 861     }
 862
 863     pvProp.ulPropTag = PROP_TAG(PT_MV_STRING8, 1u);
 864
 865     lppszA[0] = szTestA;
 866     pvProp.Value.MVszA.cValues = 1;
 867     pvProp.Value.MVszA.lppszA = lppszA;
 868     ulCount = 0;
 869
 870     sc = pScCopyProps(1, &pvProp, buffer, &ulCount);
 871     ok(sc == S_OK, "wrong ret %d\n", sc);
 872     if(sc == S_OK)
 873     {
 874         ok(lpResProp->ulPropTag == pvProp.ulPropTag, "wrong tag %x\n",lpResProp->ulPropTag);
 875         ok(lpResProp->Value.MVszA.cValues == 1, "wrong cValues %d\n", lpResProp->Value.MVszA.cValues);
 876         ok(lpResProp->Value.MVszA.lppszA[0] == buffer + sizeof(SPropValue) + sizeof(char*),
 877            "wrong lppszA[0] %p\n",lpResProp->Value.MVszA.lppszA[0]);
 878         ok(ulCount == sizeof(SPropValue) + sizeof(char*) + 5, "wrong count %d\n", ulCount);
 879         ok(!strcmp(lpResProp->Value.MVszA.lppszA[0], szTestA),
 880            "wrong string '%s'\n", lpResProp->Value.MVszA.lppszA[0]);
 881     }
 882
 883     memcpy(buffer2, buffer, sizeof(buffer));
 884
 885     /* Clear the data in the source buffer. Since pointers in the copied buffer
 886      * refer to the source buffer, this proves that native always assumes that
 887      * the copied buffers pointers are bad (needing to be relocated first).
 888      */
 889     memset(buffer, 0, sizeof(buffer));
 890     ulCount = 0;
 891
 892     sc = pScRelocProps(1, (LPSPropValue)buffer2, buffer, buffer2, &ulCount);
 893     lpResProp = (LPSPropValue)buffer2;
 894
 895     ok(sc == S_OK, "wrong ret %d\n", sc);
 896     if(sc == S_OK)
 897     {
 898         ok(lpResProp->ulPropTag == pvProp.ulPropTag, "wrong tag %x\n",lpResProp->ulPropTag);
 899         ok(lpResProp->Value.MVszA.cValues == 1, "wrong cValues %d\n", lpResProp->Value.MVszA.cValues);
 900         ok(lpResProp->Value.MVszA.lppszA[0] == buffer2 + sizeof(SPropValue) + sizeof(char*),
 901            "wrong lppszA[0] %p\n",lpResProp->Value.MVszA.lppszA[0]);
 902         /* Native has a bug whereby it calculates the size correctly when copying
 903          * but when relocating does not (presumably it uses UlPropSize() which
 904          * ignores multivalue pointers). Wine returns the correct value.
 905          */
 906         ok(ulCount == sizeof(SPropValue) + sizeof(char*) + 5 || ulCount == sizeof(SPropValue) + 5,
 907            "wrong count %d\n", ulCount);
 908         ok(!strcmp(lpResProp->Value.MVszA.lppszA[0], szTestA),
 909            "wrong string '%s'\n", lpResProp->Value.MVszA.lppszA[0]);
 910     }
 911
 912     /* Native crashes with lpNew or lpOld set to NULL so skip testing this */
 913 }
 914
 915 static void test_LpValFindProp(void)
 916 {
 917     SPropValue pvProp, *pRet;
 918     ULONG i;
 919
 920     if (!pLpValFindProp)
 921     {
 922         win_skip("LpValFindProp is not available\n");
 923         return;
 924     }
 925
 926     for (i = 0; i < sizeof(ptTypes)/sizeof(ptTypes[0]); i++)
 927     {
 928         pvProp.ulPropTag = PROP_TAG(ptTypes[i], 1u);
 929
 930         pRet = pLpValFindProp(PROP_TAG(ptTypes[i], 1u), 1u, &pvProp);
 931         ok(pRet == &pvProp,
 932            "LpValFindProp[%d]: Didn't find existing property id/type\n",
 933            ptTypes[i]);
 934
 935         pRet = pLpValFindProp(PROP_TAG(ptTypes[i], 0u), 1u, &pvProp);
 936         ok(pRet == NULL, "LpValFindProp[%d]: Found nonexistent property id\n",
 937            ptTypes[i]);
 938
 939         pRet = pLpValFindProp(PROP_TAG(PT_NULL, 0u), 1u, &pvProp);
 940         ok(pRet == NULL, "LpValFindProp[%d]: Found nonexistent property id/type\n",
 941            ptTypes[i]);
 942
 943         pRet = pLpValFindProp(PROP_TAG(PT_NULL, 1u), 1u, &pvProp);
 944         ok(pRet == &pvProp,
 945            "LpValFindProp[%d]: Didn't find existing property id\n",
 946            ptTypes[i]);
 947     }
 948 }
 949
 950 static void test_FBadRglpszA(void)
 951 {
 952     LPSTR lpStrs[4];
 953     static CHAR szString[] = "A String";
 954     BOOL bRet;
 955
 956     if (!pFBadRglpszA)
 957     {
 958         win_skip("FBadRglpszA is not available\n");
 959         return;
 960     }
 961
 962     bRet = pFBadRglpszA(NULL, 10);
 963     ok(bRet == TRUE, "FBadRglpszA(Null): expected TRUE, got FALSE\n");
 964
 965     lpStrs[0] = lpStrs[1] = lpStrs[2] = lpStrs[3] = NULL;
 966     bRet = pFBadRglpszA(lpStrs, 4);
 967     ok(bRet == TRUE, "FBadRglpszA(Nulls): expected TRUE, got FALSE\n");
 968
 969     lpStrs[0] = lpStrs[1] = lpStrs[2] = szString;
 970     bRet = pFBadRglpszA(lpStrs, 3);
 971     ok(bRet == FALSE, "FBadRglpszA(valid): expected FALSE, got TRUE\n");
 972
 973     bRet = pFBadRglpszA(lpStrs, 4);
 974     ok(bRet == TRUE, "FBadRglpszA(1 invalid): expected TRUE, got FALSE\n");
 975 }
 976
 977 static void test_FBadRglpszW(void)
 978 {
 979     LPWSTR lpStrs[4];
 980     static WCHAR szString[] = { 'A',' ','S','t','r','i','n','g','\0' };
 981     BOOL bRet;
 982
 983     if (!pFBadRglpszW)
 984     {
 985         win_skip("FBadRglpszW is not available\n");
 986         return;
 987     }
 988
 989     bRet = pFBadRglpszW(NULL, 10);
 990     ok(bRet == TRUE, "FBadRglpszW(Null): expected TRUE, got FALSE\n");
 991
 992     lpStrs[0] = lpStrs[1] = lpStrs[2] = lpStrs[3] = NULL;
 993     bRet = pFBadRglpszW(lpStrs, 4);
 994     ok(bRet == TRUE, "FBadRglpszW(Nulls): expected TRUE, got FALSE\n");
 995
 996     lpStrs[0] = lpStrs[1] = lpStrs[2] = szString;
 997     bRet = pFBadRglpszW(lpStrs, 3);
 998     ok(bRet == FALSE, "FBadRglpszW(valid): expected FALSE, got TRUE\n");
 999
1000     bRet = pFBadRglpszW(lpStrs, 4);
1001     ok(bRet == TRUE, "FBadRglpszW(1 invalid): expected TRUE, got FALSE\n");
1002 }
1003
1004 static void test_FBadRowSet(void)
1005 {
1006     ULONG ulRet;
1007
1008     if (!pFBadRowSet)
1009     {
1010         win_skip("FBadRowSet is not available\n");
1011         return;
1012     }
1013
1014     ulRet = pFBadRowSet(NULL);
1015     ok(ulRet != 0, "FBadRow(null): Expected non-zero, got 0\n");
1016
1017     /* FIXME */
1018 }
1019
1020 static void test_FBadPropTag(void)
1021 {
1022     ULONG pt, res;
1023
1024     if (!pFBadPropTag)
1025     {
1026         win_skip("FBadPropTag is not available\n");
1027         return;
1028     }
1029
1030     for (pt = 0; pt < PROP_ID_INVALID; pt++)
1031     {
1032         BOOL bBad = TRUE;
1033
1034         switch (pt & (~MV_FLAG & PROP_TYPE_MASK))
1035         {
1036         case PT_UNSPECIFIED:
1037         case PT_NULL: case PT_I2: case PT_I4: case PT_R4:
1038         case PT_R8: case PT_CURRENCY: case PT_APPTIME:
1039         case PT_ERROR: case PT_BOOLEAN: case PT_OBJECT:
1040         case PT_I8: case PT_STRING8: case PT_UNICODE:
1041         case PT_SYSTIME: case PT_CLSID: case PT_BINARY:
1042             bBad = FALSE;
1043         }
1044
1045         res = pFBadPropTag(pt);
1046         if (bBad)
1047             ok(res != 0, "pt= %d: Expected non-zero, got 0\n", pt);
1048         else
1049             ok(res == 0,
1050                "pt= %d: Expected zero, got %d\n", pt, res);
1051     }
1052 }
1053
1054 static void test_FBadRow(void)
1055 {
1056     ULONG ulRet;
1057
1058     if (!pFBadRow)
1059     {
1060         win_skip("FBadRow is not available\n");
1061         return;
1062     }
1063
1064     ulRet = pFBadRow(NULL);
1065     ok(ulRet != 0, "FBadRow(null): Expected non-zero, got 0\n");
1066
1067     /* FIXME */
1068 }
1069
1070 static void test_FBadProp(void)
1071 {
1072     static WCHAR szEmpty[] = { '\0' };
1073     GUID iid;
1074     ULONG pt, res;
1075     SPropValue pv;
1076
1077     if (!pFBadProp)
1078     {
1079         win_skip("FBadProp is not available\n");
1080         return;
1081     }
1082
1083     for (pt = 0; pt < PROP_ID_INVALID; pt++)
1084     {
1085         BOOL bBad = TRUE;
1086
1087         memset(&pv, 0, sizeof(pv));
1088         pv.ulPropTag = pt;
1089
1090         /* Note that MV values are valid below because their array count is 0,
1091          * so no pointers are validated.
1092          */
1093         switch (PROP_TYPE(pt))
1094         {
1095         case (MV_FLAG|PT_UNSPECIFIED):
1096         case PT_UNSPECIFIED:
1097         case (MV_FLAG|PT_NULL):
1098         case PT_NULL:
1099         case PT_MV_I2:
1100         case PT_I2:
1101         case PT_MV_I4:
1102         case PT_I4:
1103         case PT_MV_I8:
1104         case PT_I8:
1105         case PT_MV_R4:
1106         case PT_R4:
1107         case PT_MV_R8:
1108         case PT_R8:
1109         case PT_MV_CURRENCY:
1110         case PT_CURRENCY:
1111         case PT_MV_APPTIME:
1112         case PT_APPTIME:
1113         case (MV_FLAG|PT_ERROR):
1114         case PT_ERROR:
1115         case (MV_FLAG|PT_BOOLEAN):
1116         case PT_BOOLEAN:
1117         case (MV_FLAG|PT_OBJECT):
1118         case PT_OBJECT:
1119         case PT_MV_STRING8:
1120         case PT_MV_UNICODE:
1121         case PT_MV_SYSTIME:
1122         case PT_SYSTIME:
1123         case PT_MV_BINARY:
1124         case PT_BINARY:
1125         case PT_MV_CLSID:
1126             bBad = FALSE;
1127             break;
1128         case PT_STRING8:
1129         case PT_UNICODE:
1130             pv.Value.lpszW = szEmpty;
1131             bBad = FALSE;
1132             break;
1133         case PT_CLSID:
1134             pv.Value.lpguid = &iid;
1135             bBad = FALSE;
1136             break;
1137         }
1138
1139         res = pFBadProp(&pv);
1140         if (bBad)
1141             ok(res != 0, "pt= %d: Expected non-zero, got 0\n", pt);
1142         else
1143             ok(res == 0,
1144                "pt= %d: Expected zero, got %d\n", pt, res);
1145     }
1146 }
1147
1148 static void test_FBadColumnSet(void)
1149 {
1150     SPropTagArray pta;
1151     ULONG pt, res;
1152
1153     if (!pFBadColumnSet)
1154     {
1155         win_skip("FBadColumnSet is not available\n");
1156         return;
1157     }
1158
1159     res = pFBadColumnSet(NULL);
1160     ok(res != 0, "(null): Expected non-zero, got 0\n");
1161
1162     pta.cValues = 1;
1163
1164     for (pt = 0; pt < PROP_ID_INVALID; pt++)
1165     {
1166         BOOL bBad = TRUE;
1167
1168         pta.aulPropTag[0] = pt;
1169
1170         switch (pt & (~MV_FLAG & PROP_TYPE_MASK))
1171         {
1172         case PT_UNSPECIFIED:
1173         case PT_NULL:
1174         case PT_I2:
1175         case PT_I4:
1176         case PT_R4:
1177         case PT_R8:
1178         case PT_CURRENCY:
1179         case PT_APPTIME:
1180         case PT_BOOLEAN:
1181         case PT_OBJECT:
1182         case PT_I8:
1183         case PT_STRING8:
1184         case PT_UNICODE:
1185         case PT_SYSTIME:
1186         case PT_CLSID:
1187         case PT_BINARY:
1188             bBad = FALSE;
1189         }
1190         if (pt == (MV_FLAG|PT_ERROR))
1191             bBad = FALSE;
1192
1193         res = pFBadColumnSet(&pta);
1194         if (bBad)
1195             ok(res != 0, "pt= %d: Expected non-zero, got 0\n", pt);
1196         else
1197             ok(res == 0,
1198                "pt= %d: Expected zero, got %d\n", pt, res);
1199     }
1200 }
1201
1202
1203 static void test_IProp(void)
1204 {
1205     IPropData *lpIProp;
1206     LPMAPIERROR lpError;
1207     LPSPropProblemArray lpProbs;
1208     LPSPropValue lpProps;
1209     LPSPropTagArray lpTags;
1210     SPropValue pvs[2];
1211     SizedSPropTagArray(2,tags);
1212     ULONG access[2], count;
1213     SCODE sc;
1214
1215     if (!pCreateIProp)
1216     {
1217         win_skip("CreateIProp is not available\n");
1218         return;
1219     }
1220
1221     memset(&tags, 0 , sizeof(tags));
1222
1223     /* Create the object */
1224     lpIProp = NULL;
1225     sc = pCreateIProp(&IID_IMAPIPropData, (ALLOCATEBUFFER *)pMAPIAllocateBuffer, (ALLOCATEMORE*)pMAPIAllocateMore,
1226                       (FREEBUFFER *)pMAPIFreeBuffer, NULL, &lpIProp);
1227     ok(sc == S_OK && lpIProp,
1228        "CreateIProp: expected S_OK, non-null, got 0x%08X,%p\n", sc, lpIProp);
1229
1230     if (sc != S_OK || !lpIProp)
1231         return;
1232
1233     /* GetLastError - No errors set */
1234     lpError = NULL;
1235     IPropData_GetLastError(lpIProp, E_INVALIDARG, 0, &lpError);
1236     ok(sc == S_OK && !lpError,
1237        "GetLastError: Expected S_OK, null, got 0x%08X,%p\n", sc, lpError);
1238
1239     /* Get prop tags - succeeds returning 0 items */
1240     lpTags = NULL;
1241     sc = IPropData_GetPropList(lpIProp, 0, &lpTags);
1242     ok(sc == S_OK && lpTags && lpTags->cValues == 0,
1243        "GetPropList(empty): Expected S_OK, non-null, 0, got 0x%08X,%p,%d\n",
1244         sc, lpTags, lpTags ? lpTags->cValues : 0);
1245     if (lpTags)
1246         pMAPIFreeBuffer(lpTags);
1247
1248     /* Get props - succeeds returning 0 items */
1249     lpProps = NULL;
1250     count = 0;
1251     tags.cValues = 1;
1252     tags.aulPropTag[0] = PR_IMPORTANCE;
1253     sc = IPropData_GetProps(lpIProp, (LPSPropTagArray)&tags, 0, &count, &lpProps);
1254     ok(sc == MAPI_W_ERRORS_RETURNED && lpProps && count == 1,
1255        "GetProps(empty): Expected ERRORS_RETURNED, non-null, 1, got 0x%08X,%p,%d\n",
1256        sc, lpProps, count);
1257     if (lpProps && count > 0)
1258     {
1259         ok(lpProps[0].ulPropTag == CHANGE_PROP_TYPE(PR_IMPORTANCE,PT_ERROR),
1260            "GetProps(empty): Expected %x, got %x\n",
1261            CHANGE_PROP_TYPE(PR_IMPORTANCE,PT_ERROR), lpProps[0].ulPropTag);
1262
1263         pMAPIFreeBuffer(lpProps);
1264     }
1265
1266     /* Add (NULL) - Can't add NULLs */
1267     lpProbs = NULL;
1268     pvs[0].ulPropTag = PROP_TAG(PT_NULL,0x01);
1269     sc = IPropData_SetProps(lpIProp, 1, pvs, &lpProbs);
1270     ok(sc == MAPI_E_INVALID_PARAMETER && !lpProbs,
1271        "SetProps(): Expected INVALID_PARAMETER, null, got 0x%08X,%p\n",
1272        sc, lpProbs);
1273
1274     /* Add (OBJECT) - Can't add OBJECTs */
1275     lpProbs = NULL;
1276     pvs[0].ulPropTag = PROP_TAG(PT_OBJECT,0x01);
1277     sc = IPropData_SetProps(lpIProp, 1, pvs, &lpProbs);
1278     ok(sc == MAPI_E_INVALID_PARAMETER && !lpProbs,
1279        "SetProps(OBJECT): Expected INVALID_PARAMETER, null, got 0x%08X,%p\n",
1280        sc, lpProbs);
1281
1282     /* Add - Adds value */
1283     lpProbs = NULL;
1284     pvs[0].ulPropTag = PR_IMPORTANCE;
1285     sc = IPropData_SetProps(lpIProp, 1, pvs, &lpProbs);
1286     ok(sc == S_OK && !lpProbs,
1287        "SetProps(ERROR): Expected S_OK, null, got 0x%08X,%p\n", sc, lpProbs);
1288
1289     /* Get prop list - returns 1 item */
1290     lpTags = NULL;
1291     IPropData_GetPropList(lpIProp, 0, &lpTags);
1292     ok(sc == S_OK && lpTags && lpTags->cValues == 1,
1293        "GetPropList: Expected S_OK, non-null, 1, got 0x%08X,%p,%d\n",
1294         sc, lpTags, lpTags ? lpTags->cValues : 0);
1295     if (lpTags && lpTags->cValues > 0)
1296     {
1297         ok(lpTags->aulPropTag[0] == PR_IMPORTANCE,
1298            "GetPropList: Expected %x, got %x\n",
1299            PR_IMPORTANCE, lpTags->aulPropTag[0]);
1300         pMAPIFreeBuffer(lpTags);
1301     }
1302
1303     /* Set access to read and write */
1304     sc = IPropData_HrSetObjAccess(lpIProp, IPROP_READWRITE);
1305     ok(sc == S_OK, "SetObjAccess(WRITE): Expected S_OK got 0x%08X\n", sc);
1306
1307     tags.cValues = 1;
1308     tags.aulPropTag[0] = PR_IMPORTANCE;
1309
1310     /* Set item access (bad access) - Fails */
1311     access[0] = 0;
1312     sc = IPropData_HrSetPropAccess(lpIProp, (LPSPropTagArray)&tags, access);
1313     ok(sc == MAPI_E_INVALID_PARAMETER,
1314        "SetPropAccess(0): Expected INVALID_PARAMETER got 0x%08X\n",sc);
1315     access[0] = IPROP_READWRITE;
1316     sc = IPropData_HrSetPropAccess(lpIProp, (LPSPropTagArray)&tags, access);
1317     ok(sc == MAPI_E_INVALID_PARAMETER,
1318        "SetPropAccess(RW): Expected INVALID_PARAMETER got 0x%08X\n",sc);
1319     access[0] = IPROP_CLEAN;
1320     sc = IPropData_HrSetPropAccess(lpIProp, (LPSPropTagArray)&tags, access);
1321     ok(sc == MAPI_E_INVALID_PARAMETER,
1322        "SetPropAccess(C): Expected INVALID_PARAMETER got 0x%08X\n",sc);
1323
1324     /* Set item access to read/write/clean */
1325     tags.cValues = 1;
1326     tags.aulPropTag[0] = PR_IMPORTANCE;
1327     access[0] = IPROP_READWRITE|IPROP_CLEAN;
1328     sc = IPropData_HrSetPropAccess(lpIProp, (LPSPropTagArray)&tags, access);
1329     ok(sc == S_OK, "SetPropAccess(RW/C): Expected S_OK got 0x%08X\n",sc);
1330
1331     /* Set object access to read only */
1332     sc = IPropData_HrSetObjAccess(lpIProp, IPROP_READONLY);
1333     ok(sc == S_OK, "SetObjAccess(READ): Expected S_OK got 0x%08X\n", sc);
1334
1335     /* Set item access to read/write/dirty - doesn't care about RO object */
1336     access[0] = IPROP_READONLY|IPROP_DIRTY;
1337     sc = IPropData_HrSetPropAccess(lpIProp, (LPSPropTagArray)&tags, access);
1338     ok(sc == S_OK, "SetPropAccess(WRITE): Expected S_OK got 0x%08X\n", sc);
1339
1340     /* Delete any item when set to read only - Error */
1341     lpProbs = NULL;
1342     tags.aulPropTag[0] = PR_RESPONSE_REQUESTED;
1343     sc = IPropData_DeleteProps(lpIProp, (LPSPropTagArray)&tags, &lpProbs);
1344     ok(sc == E_ACCESSDENIED && !lpProbs,
1345        "DeleteProps(nonexistent): Expected E_ACCESSDENIED null got 0x%08X %p\n",
1346        sc, lpProbs);
1347
1348     /* Set access to read and write */
1349     sc = IPropData_HrSetObjAccess(lpIProp, IPROP_READWRITE);
1350     ok(sc == S_OK, "SetObjAccess(WRITE): Expected S_OK got 0x%08X\n", sc);
1351
1352     /* Delete nonexistent item - No error */
1353     lpProbs = NULL;
1354     tags.aulPropTag[0] = PR_RESPONSE_REQUESTED;
1355     sc = IPropData_DeleteProps(lpIProp, (LPSPropTagArray)&tags, &lpProbs);
1356     ok(sc == S_OK && !lpProbs,
1357        "DeleteProps(nonexistent): Expected S_OK null got 0x%08X %p\n",
1358        sc, lpProbs);
1359
1360     /* Delete existing item (r/o) - No error, but lpProbs populated */
1361     lpProbs = NULL;
1362     tags.aulPropTag[0] = PR_IMPORTANCE;
1363     sc = IPropData_DeleteProps(lpIProp, (LPSPropTagArray)&tags, &lpProbs);
1364     ok(sc == S_OK && lpProbs,
1365        "DeleteProps(RO): Expected S_OK non-null got 0x%08X %p\n", sc, lpProbs);
1366
1367     if (lpProbs && lpProbs->cProblem > 0)
1368     {
1369         ok(lpProbs->cProblem == 1 &&
1370            lpProbs->aProblem[0].ulIndex == 0 &&
1371            lpProbs->aProblem[0].ulPropTag == PR_IMPORTANCE &&
1372            lpProbs->aProblem[0].scode == E_ACCESSDENIED,
1373            "DeleteProps(RO): Expected (1,0,%x,%x) got (%d,%x,%x)\n",
1374             PR_IMPORTANCE, E_ACCESSDENIED,
1375             lpProbs->aProblem[0].ulIndex, lpProbs->aProblem[0].ulPropTag,
1376             lpProbs->aProblem[0].scode);
1377         pMAPIFreeBuffer(lpProbs);
1378     }
1379
1380     lpProbs = NULL;
1381     tags.cValues = 1;
1382     tags.aulPropTag[0] = PR_RESPONSE_REQUESTED;
1383     IPropData_HrAddObjProps(lpIProp, (LPSPropTagArray)&tags, &lpProbs);
1384     ok(sc == S_OK && !lpProbs,
1385        "AddObjProps(RO): Expected S_OK null got 0x%08X %p\n", sc, lpProbs);
1386
1387     /* Get prop list - returns 1 item */
1388     lpTags = NULL;
1389     IPropData_GetPropList(lpIProp, 0, &lpTags);
1390     ok(sc == S_OK && lpTags && lpTags->cValues == 1,
1391        "GetPropList: Expected S_OK, non-null, 1, got 0x%08X,%p,%d\n",
1392         sc, lpTags, lpTags ? lpTags->cValues : 0);
1393     if (lpTags && lpTags->cValues > 0)
1394     {
1395         ok(lpTags->aulPropTag[0] == PR_IMPORTANCE,
1396            "GetPropList: Expected %x, got %x\n",
1397            PR_IMPORTANCE, lpTags->aulPropTag[0]);
1398         pMAPIFreeBuffer(lpTags);
1399     }
1400
1401     /* Set item to r/w again */
1402     access[0] = IPROP_READWRITE|IPROP_DIRTY;
1403     sc = IPropData_HrSetPropAccess(lpIProp, (LPSPropTagArray)&tags, access);
1404     ok(sc == S_OK, "SetPropAccess(WRITE): Expected S_OK got 0x%08X\n", sc);
1405
1406     /* Delete existing item (r/w) - No error, no problems */
1407     lpProbs = NULL;
1408     sc = IPropData_DeleteProps(lpIProp, (LPSPropTagArray)&tags, &lpProbs);
1409     ok(sc == S_OK && !lpProbs,
1410        "DeleteProps(RO): Expected S_OK null got 0x%08X %p\n", sc, lpProbs);
1411
1412     /* Free the list */
1413     IPropData_Release(lpIProp);
1414 }
1415
1416 START_TEST(prop)
1417 {
1418     SCODE ret;
1419
1420     if (!HaveDefaultMailClient())
1421     {
1422         win_skip("No default mail client installed\n");
1423         return;
1424     }
1425
1426     if(!InitFuncPtrs())
1427     {
1428         win_skip("Needed functions are not available\n");
1429         return;
1430     }
1431
1432     SetLastError(0xdeadbeef);
1433     ret = pScInitMapiUtil(0);
1434     if ((ret != S_OK) && (GetLastError() == ERROR_PROC_NOT_FOUND))
1435     {
1436         win_skip("ScInitMapiUtil is not implemented\n");
1437         FreeLibrary(hMapi32);
1438         return;
1439     }
1440     else if ((ret == E_FAIL) && (GetLastError() == ERROR_INVALID_HANDLE))
1441     {
1442         win_skip("ScInitMapiUtil doesn't work on some Win98 and WinME systems\n");
1443         FreeLibrary(hMapi32);
1444         return;
1445     }
1446
1447     test_PropCopyMore();
1448     test_UlPropSize();
1449
1450     /* We call MAPIInitialize here for the benefit of native extended MAPI
1451      * providers which crash in the FPropContainsProp tests when MAPIInitialize
1452      * has not been called. Since MAPIInitialize is irrelevant for FPropContainsProp
1453      * on Wine, we do not care whether MAPIInitialize succeeds. */
1454     if (pMAPIInitialize)
1455         ret = pMAPIInitialize(NULL);
1456     test_FPropContainsProp();
1457     if (pMAPIUninitialize && ret == S_OK)
1458         pMAPIUninitialize();
1459
1460     test_FPropCompareProp();
1461     test_LPropCompareProp();
1462     test_PpropFindProp();
1463     test_ScCountProps();
1464     test_ScCopyRelocProps();
1465     test_LpValFindProp();
1466     test_FBadRglpszA();
1467     test_FBadRglpszW();
1468     test_FBadRowSet();
1469     test_FBadPropTag();
1470     test_FBadRow();
1471     test_FBadProp();
1472     test_FBadColumnSet();
1473
1474     test_IProp();
1475
1476     pDeinitMapiUtil();
1477     FreeLibrary(hMapi32);
1478 }