modules/rostests/winetests/shlwapi/clist.c

   1 /* Unit test suite for SHLWAPI Compact List and IStream ordinal functions
   2  *
   3  * Copyright 2002 Jon Griffiths
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #define COBJMACROS
  21 #include <stdarg.h>
  22
  23 #include "wine/test.h"
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "objbase.h"
  27
  28 typedef struct tagSHLWAPI_CLIST
  29 {
  30   ULONG ulSize;
  31   ULONG ulId;
  32 } SHLWAPI_CLIST, *LPSHLWAPI_CLIST;
  33
  34 typedef const SHLWAPI_CLIST* LPCSHLWAPI_CLIST;
  35
  36 /* Items to add */
  37 static const SHLWAPI_CLIST SHLWAPI_CLIST_items[] =
  38 {
  39   {4, 1},
  40   {8, 3},
  41   {12, 2},
  42   {16, 8},
  43   {20, 9},
  44   {3, 11},
  45   {9, 82},
  46   {33, 16},
  47   {32, 55},
  48   {24, 100},
  49   {39, 116},
  50   { 0, 0}
  51 };
  52
  53 /* Dummy IStream object for testing calls */
  54 struct dummystream
  55 {
  56   IStream IStream_iface;
  57   LONG  ref;
  58   int   readcalls;
  59   BOOL  failreadcall;
  60   BOOL  failreadsize;
  61   BOOL  readbeyondend;
  62   BOOL  readreturnlarge;
  63   int   writecalls;
  64   BOOL  failwritecall;
  65   BOOL  failwritesize;
  66   int   seekcalls;
  67   int   statcalls;
  68   BOOL  failstatcall;
  69   LPCSHLWAPI_CLIST item;
  70   ULARGE_INTEGER   pos;
  71 };
  72
  73 static inline struct dummystream *impl_from_IStream(IStream *iface)
  74 {
  75     return CONTAINING_RECORD(iface, struct dummystream, IStream_iface);
  76 }
  77
  78 static HRESULT WINAPI QueryInterface(IStream *iface, REFIID riid, void **ret_iface)
  79 {
  80     if (IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IStream, riid)) {
  81         *ret_iface = iface;
  82         IStream_AddRef(iface);
  83         return S_OK;
  84     }
  85     trace("Unexpected REFIID %s\n", wine_dbgstr_guid(riid));
  86     *ret_iface = NULL;
  87     return E_NOINTERFACE;
  88 }
  89
  90 static ULONG WINAPI AddRef(IStream *iface)
  91 {
  92     struct dummystream *This = impl_from_IStream(iface);
  93
  94     return InterlockedIncrement(&This->ref);
  95 }
  96
  97 static ULONG WINAPI Release(IStream *iface)
  98 {
  99     struct dummystream *This = impl_from_IStream(iface);
 100
 101     return InterlockedDecrement(&This->ref);
 102 }
 103
 104 static HRESULT WINAPI Read(IStream *iface, void *lpMem, ULONG ulSize, ULONG *lpRead)
 105 {
 106   struct dummystream *This = impl_from_IStream(iface);
 107   HRESULT hRet = S_OK;
 108
 109   ++This->readcalls;
 110   if (This->failreadcall)
 111   {
 112     return STG_E_ACCESSDENIED;
 113   }
 114   else if (This->failreadsize)
 115   {
 116     *lpRead = ulSize + 8;
 117     return S_OK;
 118   }
 119   else if (This->readreturnlarge)
 120   {
 121     *((ULONG*)lpMem) = 0xffff01;
 122     *lpRead = ulSize;
 123     This->readreturnlarge = FALSE;
 124     return S_OK;
 125   }
 126   if (ulSize == sizeof(ULONG))
 127   {
 128     /* Read size of item */
 129     *((ULONG*)lpMem) = This->item->ulSize ? This->item->ulSize + sizeof(SHLWAPI_CLIST) : 0;
 130     *lpRead = ulSize;
 131   }
 132   else
 133   {
 134     unsigned int i;
 135     char* buff = lpMem;
 136
 137     /* Read item data */
 138     if (!This->item->ulSize)
 139     {
 140       This->readbeyondend = TRUE;
 141       *lpRead = 0;
 142       return E_FAIL; /* Should never happen */
 143     }
 144     *((ULONG*)lpMem) = This->item->ulId;
 145     *lpRead = ulSize;
 146
 147     for (i = 0; i < This->item->ulSize; i++)
 148       buff[4+i] = i*2;
 149
 150     This->item++;
 151   }
 152   return hRet;
 153 }
 154
 155 static HRESULT WINAPI Write(IStream *iface, const void *lpMem, ULONG ulSize, ULONG *lpWritten)
 156 {
 157   struct dummystream *This = impl_from_IStream(iface);
 158   HRESULT hRet = S_OK;
 159
 160   ++This->writecalls;
 161   if (This->failwritecall)
 162   {
 163     return STG_E_ACCESSDENIED;
 164   }
 165   else if (This->failwritesize)
 166   {
 167     *lpWritten = 0;
 168   }
 169   else
 170     *lpWritten = ulSize;
 171   return hRet;
 172 }
 173
 174 static HRESULT WINAPI Seek(IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin,
 175         ULARGE_INTEGER *plibNewPosition)
 176 {
 177   struct dummystream *This = impl_from_IStream(iface);
 178
 179   ++This->seekcalls;
 180   This->pos.QuadPart = dlibMove.QuadPart;
 181   if (plibNewPosition)
 182     plibNewPosition->QuadPart = dlibMove.QuadPart;
 183   return S_OK;
 184 }
 185
 186 static HRESULT WINAPI Stat(IStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
 187 {
 188   struct dummystream *This = impl_from_IStream(iface);
 189
 190   ++This->statcalls;
 191   if (This->failstatcall)
 192     return E_FAIL;
 193   if (pstatstg)
 194     pstatstg->cbSize.QuadPart = This->pos.QuadPart;
 195   return S_OK;
 196 }
 197
 198 /* VTable */
 199 static IStreamVtbl iclvt =
 200 {
 201   QueryInterface,
 202   AddRef,
 203   Release,
 204   Read,
 205   Write,
 206   Seek,
 207   NULL, /* SetSize */
 208   NULL, /* CopyTo */
 209   NULL, /* Commit */
 210   NULL, /* Revert */
 211   NULL, /* LockRegion */
 212   NULL, /* UnlockRegion */
 213   Stat,
 214   NULL  /* Clone */
 215 };
 216
 217 /* Function ptrs for ordinal calls */
 218 static HMODULE SHLWAPI_hshlwapi = 0;
 219
 220 static VOID    (WINAPI *pSHLWAPI_19)(LPSHLWAPI_CLIST);
 221 static BOOL    (WINAPI *pSHLWAPI_20)(LPSHLWAPI_CLIST*,LPCSHLWAPI_CLIST);
 222 static BOOL    (WINAPI *pSHLWAPI_21)(LPSHLWAPI_CLIST*,ULONG);
 223 static LPSHLWAPI_CLIST (WINAPI *pSHLWAPI_22)(LPSHLWAPI_CLIST,ULONG);
 224 static HRESULT (WINAPI *pSHLWAPI_17)(IStream*, SHLWAPI_CLIST*);
 225 static HRESULT (WINAPI *pSHLWAPI_18)(IStream*, SHLWAPI_CLIST**);
 226
 227 static BOOL    (WINAPI *pSHLWAPI_166)(IStream*);
 228 static HRESULT (WINAPI *pSHLWAPI_184)(IStream*, void*, ULONG);
 229 static HRESULT (WINAPI *pSHLWAPI_212)(IStream*, const void*, ULONG);
 230 static HRESULT (WINAPI *pSHLWAPI_213)(IStream*);
 231 static HRESULT (WINAPI *pSHLWAPI_214)(IStream*, ULARGE_INTEGER*);
 232
 233
 234 static BOOL InitFunctionPtrs(void)
 235 {
 236   SHLWAPI_hshlwapi = GetModuleHandleA("shlwapi.dll");
 237
 238   /* SHCreateStreamOnFileEx was introduced in shlwapi v6.0 */
 239   if(!GetProcAddress(SHLWAPI_hshlwapi, "SHCreateStreamOnFileEx")){
 240       win_skip("Too old shlwapi version\n");
 241       return FALSE;
 242   }
 243
 244   pSHLWAPI_17 = (void *)GetProcAddress( SHLWAPI_hshlwapi, (LPSTR)17);
 245   ok(pSHLWAPI_17 != 0, "No Ordinal 17\n");
 246   pSHLWAPI_18 = (void *)GetProcAddress( SHLWAPI_hshlwapi, (LPSTR)18);
 247   ok(pSHLWAPI_18 != 0, "No Ordinal 18\n");
 248   pSHLWAPI_19 = (void *)GetProcAddress( SHLWAPI_hshlwapi, (LPSTR)19);
 249   ok(pSHLWAPI_19 != 0, "No Ordinal 19\n");
 250   pSHLWAPI_20 = (void *)GetProcAddress( SHLWAPI_hshlwapi, (LPSTR)20);
 251   ok(pSHLWAPI_20 != 0, "No Ordinal 20\n");
 252   pSHLWAPI_21 = (void *)GetProcAddress( SHLWAPI_hshlwapi, (LPSTR)21);
 253   ok(pSHLWAPI_21 != 0, "No Ordinal 21\n");
 254   pSHLWAPI_22 = (void *)GetProcAddress( SHLWAPI_hshlwapi, (LPSTR)22);
 255   ok(pSHLWAPI_22 != 0, "No Ordinal 22\n");
 256   pSHLWAPI_166 = (void *)GetProcAddress( SHLWAPI_hshlwapi, (LPSTR)166);
 257   ok(pSHLWAPI_166 != 0, "No Ordinal 166\n");
 258   pSHLWAPI_184 = (void *)GetProcAddress( SHLWAPI_hshlwapi, (LPSTR)184);
 259   ok(pSHLWAPI_184 != 0, "No Ordinal 184\n");
 260   pSHLWAPI_212 = (void *)GetProcAddress( SHLWAPI_hshlwapi, (LPSTR)212);
 261   ok(pSHLWAPI_212 != 0, "No Ordinal 212\n");
 262   pSHLWAPI_213 = (void *)GetProcAddress( SHLWAPI_hshlwapi, (LPSTR)213);
 263   ok(pSHLWAPI_213 != 0, "No Ordinal 213\n");
 264   pSHLWAPI_214 = (void *)GetProcAddress( SHLWAPI_hshlwapi, (LPSTR)214);
 265   ok(pSHLWAPI_214 != 0, "No Ordinal 214\n");
 266
 267   return TRUE;
 268 }
 269
 270 static void InitDummyStream(struct dummystream *obj)
 271 {
 272     obj->IStream_iface.lpVtbl = &iclvt;
 273     obj->ref = 1;
 274     obj->readcalls = 0;
 275     obj->failreadcall = FALSE;
 276     obj->failreadsize = FALSE;
 277     obj->readbeyondend = FALSE;
 278     obj->readreturnlarge = FALSE;
 279     obj->writecalls = 0;
 280     obj->failwritecall = FALSE;
 281     obj->failwritesize = FALSE;
 282     obj->seekcalls = 0;
 283     obj->statcalls = 0;
 284     obj->failstatcall = FALSE;
 285     obj->item = SHLWAPI_CLIST_items;
 286     obj->pos.QuadPart = 0;
 287 }
 288
 289
 290 static void test_CList(void)
 291 {
 292   struct dummystream streamobj;
 293   LPSHLWAPI_CLIST list = NULL;
 294   LPCSHLWAPI_CLIST item = SHLWAPI_CLIST_items;
 295   BOOL bRet;
 296   HRESULT hRet;
 297   LPSHLWAPI_CLIST inserted;
 298   BYTE buff[64];
 299   unsigned int i;
 300
 301   if (!pSHLWAPI_17 || !pSHLWAPI_18 || !pSHLWAPI_19 || !pSHLWAPI_20 ||
 302       !pSHLWAPI_21 || !pSHLWAPI_22)
 303     return;
 304
 305   /* Populate a list and test the items are added correctly */
 306   while (item->ulSize)
 307   {
 308     /* Create item and fill with data */
 309     inserted = (LPSHLWAPI_CLIST)buff;
 310     inserted->ulSize = item->ulSize + sizeof(SHLWAPI_CLIST);
 311     inserted->ulId = item->ulId;
 312     for (i = 0; i < item->ulSize; i++)
 313       buff[sizeof(SHLWAPI_CLIST)+i] = i*2;
 314
 315     /* Add it */
 316     bRet = pSHLWAPI_20(&list, inserted);
 317     ok(bRet == TRUE, "failed list add\n");
 318
 319     if (bRet == TRUE)
 320     {
 321       ok(list && list->ulSize, "item not added\n");
 322
 323       /* Find it */
 324       inserted = pSHLWAPI_22(list, item->ulId);
 325       ok(inserted != NULL, "lost after adding\n");
 326
 327       ok(!inserted || inserted->ulId != ~0U, "find returned a container\n");
 328
 329       /* Check size */
 330       if (inserted && inserted->ulSize & 0x3)
 331       {
 332         /* Contained */
 333         ok(inserted[-1].ulId == ~0U, "invalid size is not countained\n");
 334         ok(inserted[-1].ulSize > inserted->ulSize+sizeof(SHLWAPI_CLIST),
 335            "container too small\n");
 336       }
 337       else if (inserted)
 338       {
 339         ok(inserted->ulSize==item->ulSize+sizeof(SHLWAPI_CLIST),
 340            "id %d wrong size %d\n", inserted->ulId, inserted->ulSize);
 341       }
 342       if (inserted)
 343       {
 344         BOOL bDataOK = TRUE;
 345         LPBYTE bufftest = (LPBYTE)inserted;
 346
 347         for (i = 0; i < inserted->ulSize - sizeof(SHLWAPI_CLIST); i++)
 348           if (bufftest[sizeof(SHLWAPI_CLIST)+i] != i*2)
 349             bDataOK = FALSE;
 350
 351         ok(bDataOK == TRUE, "data corrupted on insert\n");
 352       }
 353       ok(!inserted || inserted->ulId==item->ulId, "find got wrong item\n");
 354     }
 355     item++;
 356   }
 357
 358   /* Write the list */
 359   InitDummyStream(&streamobj);
 360
 361   hRet = pSHLWAPI_17(&streamobj.IStream_iface, list);
 362   ok(hRet == S_OK, "write failed\n");
 363   if (hRet == S_OK)
 364   {
 365     /* 1 call for each element, + 1 for OK (use our null element for this) */
 366     ok(streamobj.writecalls == sizeof(SHLWAPI_CLIST_items)/sizeof(SHLWAPI_CLIST),
 367        "wrong call count\n");
 368     ok(streamobj.readcalls == 0,"called Read() in write\n");
 369     ok(streamobj.seekcalls == 0,"called Seek() in write\n");
 370   }
 371
 372   /* Failure cases for writing */
 373   InitDummyStream(&streamobj);
 374   streamobj.failwritecall = TRUE;
 375   hRet = pSHLWAPI_17(&streamobj.IStream_iface, list);
 376   ok(hRet == STG_E_ACCESSDENIED, "changed object failure return\n");
 377   ok(streamobj.writecalls == 1, "called object after failure\n");
 378   ok(streamobj.readcalls == 0,"called Read() after failure\n");
 379   ok(streamobj.seekcalls == 0,"called Seek() after failure\n");
 380
 381   InitDummyStream(&streamobj);
 382   streamobj.failwritesize = TRUE;
 383   hRet = pSHLWAPI_17(&streamobj.IStream_iface, list);
 384   ok(hRet == STG_E_MEDIUMFULL || broken(hRet == E_FAIL) /* Win7 */,
 385      "changed size failure return\n");
 386   ok(streamobj.writecalls == 1, "called object after size failure\n");
 387   ok(streamobj.readcalls == 0,"called Read() after failure\n");
 388   ok(streamobj.seekcalls == 0,"called Seek() after failure\n");
 389
 390   /* Invalid inputs for adding */
 391   inserted = (LPSHLWAPI_CLIST)buff;
 392   inserted->ulSize = sizeof(SHLWAPI_CLIST) -1;
 393   inserted->ulId = 33;
 394   bRet = pSHLWAPI_20(&list, inserted);
 395   ok(bRet == FALSE, "Expected failure\n");
 396
 397   inserted = pSHLWAPI_22(list, 33);
 398   ok(inserted == NULL, "inserted bad element size\n");
 399
 400   inserted = (LPSHLWAPI_CLIST)buff;
 401   inserted->ulSize = 44;
 402   inserted->ulId = ~0U;
 403   bRet = pSHLWAPI_20(&list, inserted);
 404   ok(bRet == FALSE, "Expected failure\n");
 405
 406   item = SHLWAPI_CLIST_items;
 407
 408   /* Look for nonexistent item in populated list */
 409   inserted = pSHLWAPI_22(list, 99999999);
 410   ok(inserted == NULL, "found a nonexistent item\n");
 411
 412   while (item->ulSize)
 413   {
 414     /* Delete items */
 415     BOOL bRet = pSHLWAPI_21(&list, item->ulId);
 416     ok(bRet == TRUE, "couldn't find item to delete\n");
 417     item++;
 418   }
 419
 420   /* Look for nonexistent item in empty list */
 421   inserted = pSHLWAPI_22(list, 99999999);
 422   ok(inserted == NULL, "found an item in empty list\n");
 423
 424   /* Create a list by reading in data */
 425   InitDummyStream(&streamobj);
 426
 427   hRet = pSHLWAPI_18(&streamobj.IStream_iface, &list);
 428   ok(hRet == S_OK, "failed create from Read()\n");
 429   if (hRet == S_OK)
 430   {
 431     ok(streamobj.readbeyondend == FALSE, "read beyond end\n");
 432     /* 2 calls per item, but only 1 for the terminator */
 433     ok(streamobj.readcalls == sizeof(SHLWAPI_CLIST_items)/sizeof(SHLWAPI_CLIST)*2-1,
 434        "wrong call count\n");
 435     ok(streamobj.writecalls == 0, "called Write() from create\n");
 436     ok(streamobj.seekcalls == 0,"called Seek() from create\n");
 437
 438     item = SHLWAPI_CLIST_items;
 439
 440     /* Check the items were added correctly */
 441     while (item->ulSize)
 442     {
 443       inserted = pSHLWAPI_22(list, item->ulId);
 444       ok(inserted != NULL, "lost after adding\n");
 445
 446       ok(!inserted || inserted->ulId != ~0U, "find returned a container\n");
 447
 448       /* Check size */
 449       if (inserted && inserted->ulSize & 0x3)
 450       {
 451         /* Contained */
 452         ok(inserted[-1].ulId == ~0U, "invalid size is not countained\n");
 453         ok(inserted[-1].ulSize > inserted->ulSize+sizeof(SHLWAPI_CLIST),
 454            "container too small\n");
 455       }
 456       else if (inserted)
 457       {
 458         ok(inserted->ulSize==item->ulSize+sizeof(SHLWAPI_CLIST),
 459            "id %d wrong size %d\n", inserted->ulId, inserted->ulSize);
 460       }
 461       ok(!inserted || inserted->ulId==item->ulId, "find got wrong item\n");
 462       if (inserted)
 463       {
 464         BOOL bDataOK = TRUE;
 465         LPBYTE bufftest = (LPBYTE)inserted;
 466
 467         for (i = 0; i < inserted->ulSize - sizeof(SHLWAPI_CLIST); i++)
 468           if (bufftest[sizeof(SHLWAPI_CLIST)+i] != i*2)
 469             bDataOK = FALSE;
 470
 471         ok(bDataOK == TRUE, "data corrupted on insert\n");
 472       }
 473       item++;
 474     }
 475   }
 476
 477   /* Failure cases for reading */
 478   InitDummyStream(&streamobj);
 479   streamobj.failreadcall = TRUE;
 480   hRet = pSHLWAPI_18(&streamobj.IStream_iface, &list);
 481   ok(hRet == STG_E_ACCESSDENIED, "changed object failure return\n");
 482   ok(streamobj.readbeyondend == FALSE, "read beyond end\n");
 483   ok(streamobj.readcalls == 1, "called object after read failure\n");
 484   ok(streamobj.writecalls == 0,"called Write() after read failure\n");
 485   ok(streamobj.seekcalls == 0,"called Seek() after read failure\n");
 486
 487   /* Read returns large object */
 488   InitDummyStream(&streamobj);
 489   streamobj.readreturnlarge = TRUE;
 490   hRet = pSHLWAPI_18(&streamobj.IStream_iface, &list);
 491   ok(hRet == S_OK, "failed create from Read() with large item\n");
 492   ok(streamobj.readbeyondend == FALSE, "read beyond end\n");
 493   ok(streamobj.readcalls == 1,"wrong call count\n");
 494   ok(streamobj.writecalls == 0,"called Write() after read failure\n");
 495   ok(streamobj.seekcalls == 2,"wrong Seek() call count (%d)\n", streamobj.seekcalls);
 496
 497   pSHLWAPI_19(list);
 498 }
 499
 500 static BOOL test_SHLWAPI_166(void)
 501 {
 502   struct dummystream streamobj;
 503   BOOL bRet;
 504
 505   if (!pSHLWAPI_166)
 506     return FALSE;
 507
 508   InitDummyStream(&streamobj);
 509   bRet = pSHLWAPI_166(&streamobj.IStream_iface);
 510
 511   if (bRet != TRUE)
 512     return FALSE; /* This version doesn't support stream ops on clists */
 513
 514   ok(streamobj.readcalls == 0, "called Read()\n");
 515   ok(streamobj.writecalls == 0, "called Write()\n");
 516   ok(streamobj.seekcalls == 0, "called Seek()\n");
 517   ok(streamobj.statcalls == 1, "wrong call count\n");
 518
 519   streamobj.statcalls = 0;
 520   streamobj.pos.QuadPart = 50001;
 521
 522   bRet = pSHLWAPI_166(&streamobj.IStream_iface);
 523
 524   ok(bRet == FALSE, "failed after seek adjusted\n");
 525   ok(streamobj.readcalls == 0, "called Read()\n");
 526   ok(streamobj.writecalls == 0, "called Write()\n");
 527   ok(streamobj.seekcalls == 0, "called Seek()\n");
 528   ok(streamobj.statcalls == 1, "wrong call count\n");
 529
 530   /* Failure cases */
 531   InitDummyStream(&streamobj);
 532   streamobj.pos.QuadPart = 50001;
 533   streamobj.failstatcall = TRUE; /* 1: Stat() Bad, Read() OK */
 534   bRet = pSHLWAPI_166(&streamobj.IStream_iface);
 535   ok(bRet == FALSE, "should be FALSE after read is OK\n");
 536   ok(streamobj.readcalls == 1, "wrong call count\n");
 537   ok(streamobj.writecalls == 0, "called Write()\n");
 538   ok(streamobj.seekcalls == 1, "wrong call count\n");
 539   ok(streamobj.statcalls == 1, "wrong call count\n");
 540   ok(streamobj.pos.QuadPart == 0, "Didn't seek to start\n");
 541
 542   InitDummyStream(&streamobj);
 543   streamobj.pos.QuadPart = 50001;
 544   streamobj.failstatcall = TRUE;
 545   streamobj.failreadcall = TRUE; /* 2: Stat() Bad, Read() Bad Also */
 546   bRet = pSHLWAPI_166(&streamobj.IStream_iface);
 547   ok(bRet == TRUE, "Should be true after read fails\n");
 548   ok(streamobj.readcalls == 1, "wrong call count\n");
 549   ok(streamobj.writecalls == 0, "called Write()\n");
 550   ok(streamobj.seekcalls == 0, "Called Seek()\n");
 551   ok(streamobj.statcalls == 1, "wrong call count\n");
 552   ok(streamobj.pos.QuadPart == 50001, "called Seek() after read failed\n");
 553   return TRUE;
 554 }
 555
 556 static void test_SHLWAPI_184(void)
 557 {
 558   struct dummystream streamobj;
 559   char buff[256];
 560   HRESULT hRet;
 561
 562   if (!pSHLWAPI_184)
 563     return;
 564
 565   InitDummyStream(&streamobj);
 566   hRet = pSHLWAPI_184(&streamobj.IStream_iface, buff, sizeof(buff));
 567
 568   ok(hRet == S_OK, "failed Read()\n");
 569   ok(streamobj.readcalls == 1, "wrong call count\n");
 570   ok(streamobj.writecalls == 0, "called Write()\n");
 571   ok(streamobj.seekcalls == 0, "called Seek()\n");
 572 }
 573
 574 static void test_SHLWAPI_212(void)
 575 {
 576   struct dummystream streamobj;
 577   char buff[256];
 578   HRESULT hRet;
 579
 580   if (!pSHLWAPI_212)
 581     return;
 582
 583   InitDummyStream(&streamobj);
 584   hRet = pSHLWAPI_212(&streamobj.IStream_iface, buff, sizeof(buff));
 585
 586   ok(hRet == S_OK, "failed Write()\n");
 587   ok(streamobj.readcalls == 0, "called Read()\n");
 588   ok(streamobj.writecalls == 1, "wrong call count\n");
 589   ok(streamobj.seekcalls == 0, "called Seek()\n");
 590 }
 591
 592 static void test_SHLWAPI_213(void)
 593 {
 594   struct dummystream streamobj;
 595   ULARGE_INTEGER ul;
 596   LARGE_INTEGER ll;
 597   HRESULT hRet;
 598
 599   if (!pSHLWAPI_213 || !pSHLWAPI_214)
 600     return;
 601
 602   InitDummyStream(&streamobj);
 603   ll.QuadPart = 5000l;
 604   Seek(&streamobj.IStream_iface, ll, 0, NULL); /* Seek to 5000l */
 605
 606   streamobj.seekcalls = 0;
 607   pSHLWAPI_213(&streamobj.IStream_iface); /* Should rewind */
 608   ok(streamobj.statcalls == 0, "called Stat()\n");
 609   ok(streamobj.readcalls == 0, "called Read()\n");
 610   ok(streamobj.writecalls == 0, "called Write()\n");
 611   ok(streamobj.seekcalls == 1, "wrong call count\n");
 612
 613   ul.QuadPart = 50001;
 614   hRet = pSHLWAPI_214(&streamobj.IStream_iface, &ul);
 615   ok(hRet == S_OK, "failed Stat()\n");
 616   ok(ul.QuadPart == 0, "213 didn't rewind stream\n");
 617 }
 618
 619 static void test_SHLWAPI_214(void)
 620 {
 621   struct dummystream streamobj;
 622   ULARGE_INTEGER ul;
 623   LARGE_INTEGER ll;
 624   HRESULT hRet;
 625
 626   if (!pSHLWAPI_214)
 627     return;
 628
 629   InitDummyStream(&streamobj);
 630   ll.QuadPart = 5000l;
 631   Seek(&streamobj.IStream_iface, ll, 0, NULL);
 632   ul.QuadPart = 0;
 633   streamobj.seekcalls = 0;
 634   hRet = pSHLWAPI_214(&streamobj.IStream_iface, &ul);
 635
 636   ok(hRet == S_OK, "failed Stat()\n");
 637   ok(streamobj.statcalls == 1, "wrong call count\n");
 638   ok(streamobj.readcalls == 0, "called Read()\n");
 639   ok(streamobj.writecalls == 0, "called Write()\n");
 640   ok(streamobj.seekcalls == 0, "called Seek()\n");
 641   ok(ul.QuadPart == 5000l, "Stat gave wrong size\n");
 642 }
 643
 644 START_TEST(clist)
 645 {
 646   if(!InitFunctionPtrs())
 647     return;
 648
 649   test_CList();
 650
 651   /* Test streaming if this version supports it */
 652   if (test_SHLWAPI_166())
 653   {
 654     test_SHLWAPI_184();
 655     test_SHLWAPI_212();
 656     test_SHLWAPI_213();
 657     test_SHLWAPI_214();
 658   }
 659 }