dlls/urlmon/tests/stream.c

   1 /*
   2  * Copyright 2007 Robert Shearman for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20 #define CONST_VTABLE
  21
  22 #include <wine/test.h>
  23 #include <stdarg.h>
  24 #include <stddef.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ole2.h"
  29 #include "urlmon.h"
  30 #include "wininet.h"
  31
  32 #define DEFINE_EXPECT(func) \
  33     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  34
  35 #define SET_EXPECT(func) \
  36     expect_ ## func = TRUE
  37
  38 #define CHECK_EXPECT(func) \
  39     do { \
  40         ok(expect_ ##func, "unexpected call " #func "\n"); \
  41         expect_ ## func = FALSE; \
  42         called_ ## func = TRUE; \
  43     }while(0)
  44
  45 #define CHECK_EXPECT2(func) \
  46     do { \
  47         ok(expect_ ##func, "unexpected call " #func "\n"); \
  48         called_ ## func = TRUE; \
  49     }while(0)
  50
  51 #define CHECK_CALLED(func) \
  52     do { \
  53         ok(called_ ## func, "expected " #func "\n"); \
  54         expect_ ## func = called_ ## func = FALSE; \
  55     }while(0)
  56
  57 #define CHECK_NOT_CALLED(func) \
  58     do { \
  59         ok(!called_ ## func, "unexpected " #func "\n"); \
  60         expect_ ## func = called_ ## func = FALSE; \
  61     }while(0)
  62
  63 #define CLEAR_CALLED(func) \
  64     expect_ ## func = called_ ## func = FALSE
  65
  66 DEFINE_EXPECT(QueryInterface_IServiceProvider);
  67 DEFINE_EXPECT(OnStartBinding);
  68 DEFINE_EXPECT(OnProgress_FINDINGRESOURCE);
  69 DEFINE_EXPECT(OnProgress_CONNECTING);
  70 DEFINE_EXPECT(OnProgress_SENDINGREQUEST);
  71 DEFINE_EXPECT(OnProgress_MIMETYPEAVAILABLE);
  72 DEFINE_EXPECT(OnProgress_BEGINDOWNLOADDATA);
  73 DEFINE_EXPECT(OnProgress_DOWNLOADINGDATA);
  74 DEFINE_EXPECT(OnProgress_ENDDOWNLOADDATA);
  75 DEFINE_EXPECT(OnStopBinding);
  76 DEFINE_EXPECT(OnDataAvailable);
  77 DEFINE_EXPECT(GetBindInfo);
  78
  79 static const CHAR wszIndexHtmlA[] = "index.html";
  80 static WCHAR INDEX_HTML[MAX_PATH];
  81 static const char szHtmlDoc[] = "<HTML></HTML>";
  82
  83 static HRESULT WINAPI statusclb_QueryInterface(IBindStatusCallback *iface, REFIID riid, void **ppv)
  84 {
  85     if (IsEqualGUID(&IID_IBindStatusCallback, riid) ||
  86         IsEqualGUID(&IID_IUnknown, riid))
  87     {
  88         *ppv = iface;
  89         return S_OK;
  90     }
  91     else if (IsEqualGUID(&IID_IServiceProvider, riid))
  92     {
  93         CHECK_EXPECT(QueryInterface_IServiceProvider);
  94     }
  95
  96     return E_NOINTERFACE;
  97 }
  98
  99 static ULONG WINAPI statusclb_AddRef(IBindStatusCallback *iface)
 100 {
 101     return 2;
 102 }
 103
 104 static ULONG WINAPI statusclb_Release(IBindStatusCallback *iface)
 105 {
 106     return 1;
 107 }
 108
 109 static HRESULT WINAPI statusclb_OnStartBinding(IBindStatusCallback *iface, DWORD dwReserved,
 110                                                IBinding *pib)
 111 {
 112     HRESULT hres;
 113     IMoniker *mon;
 114
 115     CHECK_EXPECT(OnStartBinding);
 116
 117     ok(pib != NULL, "pib should not be NULL\n");
 118
 119     hres = IBinding_QueryInterface(pib, &IID_IMoniker, (void**)&mon);
 120     ok(hres == E_NOINTERFACE, "IBinding should not have IMoniker interface\n");
 121     if(SUCCEEDED(hres))
 122         IMoniker_Release(mon);
 123
 124     return S_OK;
 125 }
 126
 127 static HRESULT WINAPI statusclb_GetPriority(IBindStatusCallback *iface, LONG *pnPriority)
 128 {
 129     ok(0, "unexpected call\n");
 130     return E_NOTIMPL;
 131 }
 132
 133 static HRESULT WINAPI statusclb_OnLowResource(IBindStatusCallback *iface, DWORD reserved)
 134 {
 135     ok(0, "unexpected call\n");
 136     return E_NOTIMPL;
 137 }
 138
 139 static HRESULT WINAPI statusclb_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
 140                                            ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
 141 {
 142     switch(ulStatusCode) {
 143         case BINDSTATUS_FINDINGRESOURCE:
 144             CHECK_EXPECT(OnProgress_FINDINGRESOURCE);
 145             break;
 146         case BINDSTATUS_CONNECTING:
 147             CHECK_EXPECT(OnProgress_CONNECTING);
 148             break;
 149         case BINDSTATUS_SENDINGREQUEST:
 150             CHECK_EXPECT(OnProgress_SENDINGREQUEST);
 151             break;
 152         case BINDSTATUS_MIMETYPEAVAILABLE:
 153             CHECK_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 154             break;
 155         case BINDSTATUS_BEGINDOWNLOADDATA:
 156             CHECK_EXPECT(OnProgress_BEGINDOWNLOADDATA);
 157             ok(szStatusText != NULL, "szStatusText == NULL\n");
 158             break;
 159         case BINDSTATUS_DOWNLOADINGDATA:
 160             CHECK_EXPECT2(OnProgress_DOWNLOADINGDATA);
 161             break;
 162         case BINDSTATUS_ENDDOWNLOADDATA:
 163             CHECK_EXPECT(OnProgress_ENDDOWNLOADDATA);
 164             ok(szStatusText != NULL, "szStatusText == NULL\n");
 165             break;
 166         case BINDSTATUS_CACHEFILENAMEAVAILABLE:
 167             ok(szStatusText != NULL, "szStatusText == NULL\n");
 168             break;
 169         default:
 170             todo_wine { ok(0, "unexpected code %d\n", ulStatusCode); }
 171     };
 172     return S_OK;
 173 }
 174
 175 static HRESULT WINAPI statusclb_OnStopBinding(IBindStatusCallback *iface, HRESULT hresult, LPCWSTR szError)
 176 {
 177     CHECK_EXPECT(OnStopBinding);
 178
 179     /* ignore DNS failure */
 180     if (hresult != HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
 181     {
 182         ok(SUCCEEDED(hresult), "Download failed: %08x\n", hresult);
 183         ok(szError == NULL, "szError should be NULL\n");
 184     }
 185
 186     return S_OK;
 187 }
 188
 189 static HRESULT WINAPI statusclb_GetBindInfo(IBindStatusCallback *iface, DWORD *grfBINDF, BINDINFO *pbindinfo)
 190 {
 191     DWORD cbSize;
 192
 193     CHECK_EXPECT(GetBindInfo);
 194
 195     *grfBINDF = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
 196     cbSize = pbindinfo->cbSize;
 197     memset(pbindinfo, 0, cbSize);
 198     pbindinfo->cbSize = cbSize;
 199
 200     return S_OK;
 201 }
 202
 203 static HRESULT WINAPI statusclb_OnDataAvailable(IBindStatusCallback *iface, DWORD grfBSCF,
 204                                                 DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed)
 205 {
 206     HRESULT hres;
 207     DWORD read;
 208     BYTE buf[512];
 209
 210     CHECK_EXPECT2(OnDataAvailable);
 211
 212     if (0)
 213     {
 214         /* FIXME: Uncomment after removing BindToStorage hack. */
 215         ok(pformatetc != NULL, "pformatetx == NULL\n");
 216         if(pformatetc) {
 217             ok(pformatetc->cfFormat == 0xc02d, "clipformat=%x\n", pformatetc->cfFormat);
 218             ok(pformatetc->ptd == NULL, "ptd = %p\n", pformatetc->ptd);
 219             ok(pformatetc->dwAspect == 1, "dwAspect=%u\n", pformatetc->dwAspect);
 220             ok(pformatetc->lindex == -1, "lindex=%d\n", pformatetc->lindex);
 221             ok(pformatetc->tymed == TYMED_ISTREAM, "tymed=%u\n", pformatetc->tymed);
 222         }
 223
 224         ok(pstgmed != NULL, "stgmeg == NULL\n");
 225         if(pstgmed) {
 226             ok(pstgmed->tymed == TYMED_ISTREAM, "tymed=%u\n", pstgmed->tymed);
 227             ok(U(*pstgmed).pstm != NULL, "pstm == NULL\n");
 228             ok(pstgmed->pUnkForRelease != NULL, "pUnkForRelease == NULL\n");
 229         }
 230     }
 231
 232     if(U(*pstgmed).pstm) {
 233         do hres = IStream_Read(U(*pstgmed).pstm, buf, 512, &read);
 234         while(hres == S_OK);
 235         ok(hres == S_FALSE || hres == E_PENDING, "IStream_Read returned %08x\n", hres);
 236     }
 237
 238     return S_OK;
 239 }
 240
 241 static HRESULT WINAPI statusclb_OnObjectAvailable(IBindStatusCallback *iface, REFIID riid, IUnknown *punk)
 242 {
 243     ok(0, "unexpected call\n");
 244     return E_NOTIMPL;
 245 }
 246
 247 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
 248     statusclb_QueryInterface,
 249     statusclb_AddRef,
 250     statusclb_Release,
 251     statusclb_OnStartBinding,
 252     statusclb_GetPriority,
 253     statusclb_OnLowResource,
 254     statusclb_OnProgress,
 255     statusclb_OnStopBinding,
 256     statusclb_GetBindInfo,
 257     statusclb_OnDataAvailable,
 258     statusclb_OnObjectAvailable
 259 };
 260
 261 static IBindStatusCallback BindStatusCallback = { &BindStatusCallbackVtbl };
 262
 263 static void set_file_url(char *path)
 264 {
 265     char INDEX_HTML_A[MAX_PATH];
 266
 267     lstrcpyA(INDEX_HTML_A, "file:///");
 268     lstrcatA(INDEX_HTML_A, path);
 269     MultiByteToWideChar(CP_ACP, 0, INDEX_HTML_A, -1, INDEX_HTML, MAX_PATH);
 270 }
 271
 272 static void create_file(void)
 273 {
 274     HANDLE file;
 275     DWORD size;
 276     CHAR path[MAX_PATH];
 277
 278     file = CreateFileA(wszIndexHtmlA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 279                        FILE_ATTRIBUTE_NORMAL, NULL);
 280     ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
 281     if(file == INVALID_HANDLE_VALUE)
 282         return;
 283
 284     WriteFile(file, szHtmlDoc, sizeof(szHtmlDoc)-1, &size, NULL);
 285     CloseHandle(file);
 286
 287     GetCurrentDirectoryA(MAX_PATH, path);
 288     lstrcatA(path, "\\");
 289     lstrcatA(path, wszIndexHtmlA);
 290     set_file_url(path);
 291 }
 292
 293 static void test_URLOpenBlockingStreamW(void)
 294 {
 295     HRESULT hr;
 296     IStream *pStream = NULL;
 297     char buffer[256];
 298
 299     hr = URLOpenBlockingStreamW(NULL, NULL, &pStream, 0, &BindStatusCallback);
 300     ok(hr == E_INVALIDARG, "URLOpenBlockingStreamW should have failed with E_INVALIDARG instead of 0x%08x\n", hr);
 301     if (0)  /* crashes on Win2k */
 302     {
 303         hr = URLOpenBlockingStreamW(NULL, INDEX_HTML, NULL, 0, &BindStatusCallback);
 304         ok(hr == E_INVALIDARG, "URLOpenBlockingStreamW should have failed with E_INVALIDARG instead of 0x%08x\n", hr);
 305     }
 306
 307     SET_EXPECT(GetBindInfo);
 308     SET_EXPECT(QueryInterface_IServiceProvider);
 309     SET_EXPECT(OnStartBinding);
 310     SET_EXPECT(OnProgress_SENDINGREQUEST);
 311     SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 312     SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
 313     SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
 314     SET_EXPECT(OnStopBinding);
 315
 316     hr = URLOpenBlockingStreamW(NULL, INDEX_HTML, &pStream, 0, &BindStatusCallback);
 317     ok(hr == S_OK, "URLOpenBlockingStreamW failed with error 0x%08x\n", hr);
 318
 319     CHECK_CALLED(GetBindInfo);
 320     todo_wine CHECK_CALLED(QueryInterface_IServiceProvider);
 321     CHECK_CALLED(OnStartBinding);
 322     CHECK_CALLED(OnProgress_SENDINGREQUEST);
 323     CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
 324     CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
 325     CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
 326     CHECK_CALLED(OnStopBinding);
 327
 328     ok(pStream != NULL, "pStream is NULL\n");
 329     if(pStream)
 330     {
 331         buffer[0] = 0;
 332         hr = IStream_Read(pStream, buffer, sizeof(buffer), NULL);
 333         ok(hr == S_OK, "IStream_Read failed with error 0x%08x\n", hr);
 334         ok(!memcmp(buffer, szHtmlDoc, sizeof(szHtmlDoc)-1), "read data differs from file\n");
 335
 336         IStream_Release(pStream);
 337     }
 338
 339     hr = URLOpenBlockingStreamW(NULL, INDEX_HTML, &pStream, 0, NULL);
 340     ok(hr == S_OK, "URLOpenBlockingStreamW failed with error 0x%08x\n", hr);
 341
 342     ok(pStream != NULL, "pStream is NULL\n");
 343     if(pStream)
 344     {
 345         buffer[0] = 0;
 346         hr = IStream_Read(pStream, buffer, sizeof(buffer), NULL);
 347         ok(hr == S_OK, "IStream_Read failed with error 0x%08x\n", hr);
 348         ok(!memcmp(buffer, szHtmlDoc, sizeof(szHtmlDoc)-1), "read data differs from file\n");
 349
 350         IStream_Release(pStream);
 351     }
 352 }
 353
 354 static void test_URLOpenStreamW(void)
 355 {
 356     HRESULT hr;
 357
 358     hr = URLOpenStreamW(NULL, NULL, 0, &BindStatusCallback);
 359     ok(hr == E_INVALIDARG, "URLOpenStreamW should have failed with E_INVALIDARG instead of 0x%08x\n", hr);
 360
 361     SET_EXPECT(GetBindInfo);
 362     SET_EXPECT(QueryInterface_IServiceProvider);
 363     SET_EXPECT(OnStartBinding);
 364     SET_EXPECT(OnProgress_SENDINGREQUEST);
 365     SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
 366     SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
 367     SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
 368     SET_EXPECT(OnDataAvailable);
 369     SET_EXPECT(OnStopBinding);
 370
 371     hr = URLOpenStreamW(NULL, INDEX_HTML, 0, &BindStatusCallback);
 372     ok(hr == S_OK, "URLOpenStreamW failed with error 0x%08x\n", hr);
 373
 374     CHECK_CALLED(GetBindInfo);
 375     todo_wine CHECK_CALLED(QueryInterface_IServiceProvider);
 376     CHECK_CALLED(OnStartBinding);
 377     CHECK_CALLED(OnProgress_SENDINGREQUEST);
 378     CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
 379     CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
 380     CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
 381     CHECK_CALLED(OnDataAvailable);
 382     CHECK_CALLED(OnStopBinding);
 383
 384     hr = URLOpenStreamW(NULL, INDEX_HTML, 0, NULL);
 385     ok(hr == S_OK, "URLOpenStreamW failed with error 0x%08x\n", hr);
 386 }
 387
 388 START_TEST(stream)
 389 {
 390     if(!GetProcAddress(GetModuleHandleA("urlmon.dll"), "CompareSecurityIds")) {
 391         win_skip("Too old IE\n");
 392         return;
 393     }
 394
 395     create_file();
 396     test_URLOpenBlockingStreamW();
 397     test_URLOpenStreamW();
 398     DeleteFileA(wszIndexHtmlA);
 399 }