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