--- /dev/null
--- /dev/null
--- /dev/null
- ok(ret, "BitBlt failed to blank the bitmap!\n");
+++/*
+++ * PROJECT: ReactOS api tests
+++ * LICENSE: GPL - See COPYING in the top level directory
+++ * PURPOSE: Test for Rectangle
+++ * PROGRAMMERS: Jérôme Gardou
+++ */
+++
+++#include <stdio.h>
+++#include <wine/test.h>
+++#include <windows.h>
+++
+++void Test_Rectangle(void)
+++{
+++ HDC hdc;
+++ HBITMAP hBmp;
+++ BOOL ret;
+++ HBRUSH hBrush;
++++ HPEN hPen;
+++ COLORREF color;
+++
+++ hdc = CreateCompatibleDC(NULL);
+++ ok(hdc != NULL, "Failed to create the DC!\n");
+++ hBmp = CreateCompatibleBitmap(hdc, 4, 4);
+++ ok(hBmp != NULL, "Failed to create the Bitmap!\n");
+++ hBmp = SelectObject(hdc, hBmp);
+++ ok(hBmp != NULL, "Failed to select the Bitmap!\n");
+++
+++ hBrush = CreateSolidBrush(RGB(0, 0, 0));
+++ ok(hBrush != NULL, "Failed to create a solid brush!\n");
+++ hBrush = SelectObject(hdc, hBrush);
+++ ok(hBrush != NULL, "Failed to select the brush!\n");
+++
+++ /* Blank the bitmap */
+++ ret = BitBlt(hdc, 0, 0, 4, 4, NULL, 0, 0, WHITENESS);
+++ ok(ret, "BitBlt failed to blank the bitmap!\n");
+++
+++ /* Try inverted rectangle coordinates */
+++ ret = Rectangle(hdc, 0, 2, 2, 0);
+++ ok(ret, "Rectangle failed!");
+++ color = GetPixel(hdc, 0, 0);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 2, 2);
+++ ok( color == RGB(255, 255, 255), "Expected 0x00FFFFFF, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 0, 2);
+++ ok( color == RGB(255, 255, 255), "Expected 0x00FFFFFF, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 2, 0);
+++ ok( color == RGB(255, 255, 255), "Expected 0x00FFFFFF, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 1, 1);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++
+++ ret = BitBlt(hdc, 0, 0, 4, 4, NULL, 0, 0, WHITENESS);
++++ ok(ret, "BitBlt failed to blank the bitmap!\n");
+++ /* Try well ordered rectangle coordinates */
+++ ret = Rectangle(hdc, 0, 0, 2, 2);
+++ ok(ret, "Rectangle failed!");
+++ color = GetPixel(hdc, 0, 0);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 2, 2);
+++ ok( color == RGB(255, 255, 255), "Expected 0x00FFFFFF, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 0, 2);
+++ ok( color == RGB(255, 255, 255), "Expected 0x00FFFFFF, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 2, 0);
+++ ok( color == RGB(255, 255, 255), "Expected 0x00FFFFFF, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 1, 1);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++
++++ /* tests with NULL pen */
++++ hPen = SelectObject(hdc, GetStockObject(NULL_PEN));
++++
++++ /* Blank the bitmap */
++++ ret = BitBlt(hdc, 0, 0, 4, 4, NULL, 0, 0, WHITENESS);
++++ ok(ret, "BitBlt failed to blank the bitmap!\n");
++++
++++ ret = Rectangle(hdc, 0, 0, 3, 3);
++++ ok(ret, "Rectangle failed!");
++++ color = GetPixel(hdc, 0, 0);
++++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
++++ color = GetPixel(hdc, 2, 2);
++++ ok( color == RGB(255, 255, 255), "Expected 0x00FFFFFF, got 0x%08x\n", (UINT)color);
++++ color = GetPixel(hdc, 0, 2);
++++ ok( color == RGB(255, 255, 255), "Expected 0x00FFFFFF, got 0x%08x\n", (UINT)color);
++++ color = GetPixel(hdc, 2, 0);
++++ ok( color == RGB(255, 255, 255), "Expected 0x00FFFFFF, got 0x%08x\n", (UINT)color);
++++ color = GetPixel(hdc, 1, 1);
++++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
++++
++++ SelectObject(hdc, hPen);
++++
+++ /* Same tests with GM_ADVANCED */
+++ ok(SetGraphicsMode(hdc, GM_ADVANCED) == GM_COMPATIBLE, "Default mode for the DC is not GM_COMPATIBLE.\n");
+++
+++ /* Blank the bitmap */
+++ ret = BitBlt(hdc, 0, 0, 4, 4, NULL, 0, 0, WHITENESS);
+++ ok(ret, "BitBlt failed to blank the bitmap!\n");
+++
+++ /* Try inverted rectangle coordinates */
+++ ret = Rectangle(hdc, 0, 2, 2, 0);
+++ ok(ret, "Rectangle failed!");
+++ color = GetPixel(hdc, 0, 0);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 2, 2);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 0, 2);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 2, 0);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 1, 1);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++
+++ ret = BitBlt(hdc, 0, 0, 4, 4, NULL, 0, 0, WHITENESS);
+++ ok(ret, "BitBlt failed to blank the bitmap!\n");
+++ /* Try well ordered rectangle coordinates */
+++ ret = Rectangle(hdc, 0, 0, 2, 2);
+++ ok(ret, "Rectangle failed!");
+++ color = GetPixel(hdc, 0, 0);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 2, 2);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 0, 2);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 2, 0);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++ color = GetPixel(hdc, 1, 1);
+++ ok( color == RGB(0, 0, 0), "Expected 0, got 0x%08x\n", (UINT)color);
+++
+++
+++ hBmp = SelectObject(hdc, hBmp);
+++ hBrush = SelectObject(hdc, hBrush);
+++ DeleteObject(hBmp);
+++ DeleteObject(hBrush);
+++ DeleteDC(hdc);
+++}
+++
+++
+++START_TEST(Rectangle)
+++{
+++ Test_Rectangle();
+++}
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
- ok (iResult == NULLREGION, "\n");
+++/*
+++ * PROJECT: ReactOS api tests
+++ * LICENSE: GPL - See COPYING in the top level directory
+++ * PURPOSE: Test for ScrollDC
+++ * PROGRAMMERS: Timo Kreuzer
+++ */
+++
+++#include <stdio.h>
+++#include <wine/test.h>
+++#include <windows.h>
+++
+++void Test_ScrollDC()
+++{
+++ HWND hWnd, hWnd2;
+++ HDC hDC;
+++ HRGN hrgn;
+++ RECT rcClip;
+++ int iResult;
+++
+++ /* Create a window */
+++ hWnd = CreateWindowW(L"BUTTON", L"TestWindow", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
+++ 100, 100, 100, 100,
+++ NULL, NULL, 0, 0);
+++ UpdateWindow(hWnd);
+++ hDC = GetDC(hWnd);
+++
+++ /* Test that no update region is there */
+++ hrgn = CreateRectRgn(0,0,0,0);
+++ iResult = GetUpdateRgn(hWnd, hrgn, FALSE);
- ok(ScrollDC(hDC, 0, 0, NULL, NULL, hrgn, NULL) == TRUE, "\n");
++++ ok (iResult == NULLREGION, "Expected NULLREGION, got %d\n", iResult);
+++
+++ /* Test normal scrolling */
- ok(ScrollDC(hDC, 50, 0, NULL, NULL, hrgn, NULL) == FALSE, "\n");
++++ ok(ScrollDC(hDC, 0, 0, NULL, NULL, hrgn, NULL) == TRUE, "ScrollDC failed\n");
+++
+++ /* Scroll with invalid update region */
+++ DeleteObject(hrgn);
- ok(GetUpdateRgn(hWnd, hrgn, FALSE) == NULLREGION, "\n");
++++ ok(ScrollDC(hDC, 50, 0, NULL, NULL, (HRGN)0x12345678, NULL) == FALSE, "ScrollDC successed\n");
++++ ok(ScrollDC(hDC, 50, 0, NULL, NULL, hrgn, NULL) == FALSE, "ScrollDC successed\n");
+++ hrgn = CreateRectRgn(0,0,0,0);
- ok(ScrollDC(hDC, 50, 0, NULL, NULL, NULL, (PRECT)1) == 0, "\n");
- ok(GetUpdateRgn(hWnd, hrgn, FALSE) == NULLREGION, "\n");
++++ iResult = GetUpdateRgn(hWnd, hrgn, FALSE);
++++ ok(iResult == NULLREGION, "Expected NULLREGION, got %d\n", iResult);
+++
+++ /* Scroll with invalid update rect pointer */
- ok(ScrollDC(hDC, 50, 0, NULL, &rcClip, hrgn, NULL) == TRUE, "\n");
- ok(GetUpdateRgn(hWnd, hrgn, FALSE) == NULLREGION, "\n");
++++ ok(ScrollDC(hDC, 50, 0, NULL, NULL, NULL, (PRECT)1) == FALSE, "ScrollDC failed\n");
++++ iResult = GetUpdateRgn(hWnd, hrgn, FALSE);
++++ ok(iResult == NULLREGION, "Expected NULLREGION, got %d\n", iResult);
+++
+++ /* Scroll with a clip rect */
+++ rcClip.left = 50; rcClip.top = 0; rcClip.right = 100; rcClip.bottom = 100;
- ok(ScrollDC(hDC, 50, 50, NULL, &rcClip, hrgn, NULL) == TRUE, "\n");
- ok(GetUpdateRgn(hWnd, hrgn, FALSE) == NULLREGION, "\n");
++++ ok(ScrollDC(hDC, 50, 0, NULL, &rcClip, hrgn, NULL) == TRUE, "ScrollDC failed\n");
++++ iResult = GetUpdateRgn(hWnd, hrgn, FALSE);
++++ ok(iResult == NULLREGION, "Expected NULLREGION, got %d\n", iResult);
+++
+++ /* Scroll with a clip rect */
+++ rcClip.left = 50; rcClip.top = 0; rcClip.right = 100; rcClip.bottom = 100;
++++ ok(ScrollDC(hDC, 50, 50, NULL, &rcClip, hrgn, NULL) == TRUE, "ScrollDC failed\n");
++++ iResult = GetUpdateRgn(hWnd, hrgn, FALSE);
++++ ok(iResult == NULLREGION, "Expected NULLREGION, got %d\n", iResult);
+++
+++ /* Overlap with another window */
+++ hWnd2 = CreateWindowW(L"BUTTON", L"TestWindow", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
+++ 30, 160, 100, 100,
+++ NULL, NULL, 0, 0);
+++ UpdateWindow(hWnd2);
+++
+++ /* Cleanup */
+++ ReleaseDC(hWnd, hDC);
+++ DestroyWindow(hWnd);
+++ DestroyWindow(hWnd2);
+++
+++}
+++
+++START_TEST(ScrollDC)
+++{
+++ Test_ScrollDC();
+++}
+++
--- /dev/null
- BOOL InitOsVersion();
+ #ifndef _W32KNAPI_H
+ #define _W32KNAPI_H
+
+ /* SDK/NDK Headers */
+ #define NTOS_MODE_USER
+ #define WIN32_NO_STATUS
+ #include <windows.h>
+ #include <winuser.h>
+ #include <windowsx.h>
+ #include <winnls32.h>
+ #include <ndk/ntndk.h>
+ #include <wingdi.h>
+ #include <winddi.h>
+ #include <ddrawi.h>
+ #include <d3dnthal.h>
+ #include <prntfont.h>
+
+ /* Public Win32K Headers */
+ #include <win32k/ntusrtyp.h>
+ #include <win32k/ntuser.h>
+ #include <win32k/callback.h>
+ #include <win32k/ntgdityp.h>
+ #include <ntgdi.h>
+ #include <win32k/ntgdihdl.h>
+
+ #include "../apitest.h"
+ #include "resource.h"
+
+ typedef struct
+ {
+ LPWSTR lpszFunction;
+ INT nSyscallNum;
+ INT nParams;
+ } SYCALL_ENTRY, *PSYSCALL_ENTRY;
+
+ extern HINSTANCE g_hInstance;
+ extern HMODULE g_hModule;
+ extern PGDI_TABLE_ENTRY GdiHandleTable;
+
+ BOOL IsHandleValid(HGDIOBJ hobj);
+ PVOID GetHandleUserData(HGDIOBJ hobj);
+ DWORD Syscall(LPWSTR lpszFunction, int cParams, void* pParams);
+ + BOOL InitOsVersion(VOID);
+ extern UINT g_OsIdx;
+
+ typedef UINT ASPI[5];
+ extern ASPI gNOPARAM_ROUTINE_CREATEMENU;
+ extern ASPI gNOPARAM_ROUTINE_CREATEMENUPOPUP;
+ extern ASPI gNOPARAM_ROUTINE_LOADUSERAPIHOOK;
+ extern ASPI gONEPARAM_ROUTINE_CREATEEMPTYCUROBJECT;
+ extern ASPI gONEPARAM_ROUTINE_MAPDEKTOPOBJECT;
+ extern ASPI gONEPARAM_ROUTINE_SWAPMOUSEBUTTON;
+ extern ASPI gHWND_ROUTINE_DEREGISTERSHELLHOOKWINDOW;
+ extern ASPI gHWND_ROUTINE_GETWNDCONTEXTHLPID;
+ extern ASPI gHWNDPARAM_ROUTINE_SETWNDCONTEXTHLPID;
+
+ #define _NOPARAM_ROUTINE_CREATEMENU gNOPARAM_ROUTINE_CREATEMENU[g_OsIdx]
+ #define _NOPARAM_ROUTINE_CREATEMENUPOPUP gNOPARAM_ROUTINE_CREATEMENUPOPUP[g_OsIdx]
+ #define _NOPARAM_ROUTINE_LOADUSERAPIHOOK gNOPARAM_ROUTINE_LOADUSERAPIHOOK[g_OsIdx]
+ #define _ONEPARAM_ROUTINE_CREATEEMPTYCUROBJECT gONEPARAM_ROUTINE_CREATEEMPTYCUROBJECT[g_OsIdx]
+ #define _ONEPARAM_ROUTINE_MAPDEKTOPOBJECT gONEPARAM_ROUTINE_MAPDEKTOPOBJECT[g_OsIdx]
+ #define _ONEPARAM_ROUTINE_SWAPMOUSEBUTTON gONEPARAM_ROUTINE_SWAPMOUSEBUTTON[g_OsIdx]
+ #define _HWND_ROUTINE_DEREGISTERSHELLHOOKWINDOW gHWND_ROUTINE_DEREGISTERSHELLHOOKWINDOW[g_OsIdx]
+ #define _HWND_ROUTINE_GETWNDCONTEXTHLPID gHWND_ROUTINE_GETWNDCONTEXTHLPID[g_OsIdx]
+ #define _HWNDPARAM_ROUTINE_SETWNDCONTEXTHLPID gHWNDPARAM_ROUTINE_SETWNDCONTEXTHLPID[g_OsIdx]
+
+
+
+ #endif /* _W32KNAPI_H */
--- /dev/null
- VOID StartTest();
+ #ifndef KMTEST_H
+ #define KMTEST_H
+
+ #include <stdio.h>
+ #include <stdarg.h>
+ #include <string.h>
+ #include "ntddk.h"
+
+
+ /*
+ Some macros, structs, and vars are based or inspired from the great
+ Wine regression tests Copyright (C) 2002 Alexandre Julliard.
+ Everything else is done by Aleksey Bragin based on PnPTest by Filip Navara
+ */
+
+ extern LONG successes; /* number of successful tests */
+ extern LONG failures; /* number of failures */
+ //static ULONG todo_successes; /* number of successful tests inside todo block */
+ //static ULONG todo_failures; /* number of failures inside todo block */
+
+ // We don't do multithreading, so we just keep this struct in a global var
+ typedef struct
+ {
+ const char* current_file; /* file of current check */
+ int current_line; /* line of current check */
+ int todo_level; /* current todo nesting level */
+ int todo_do_loop;
+ } tls_data;
+
+ extern tls_data glob_data;
+
+ + VOID StartTest(VOID);
+ VOID FinishTest(HANDLE KeyHandle, LPWSTR TestName);
+ void kmtest_set_location(const char* file, int line);
+
+ #ifdef __GNUC__
+
+ extern int kmtest_ok( int condition, const char *msg, ... ) __attribute__((format (printf,2,3) ));
+
+ #else /* __GNUC__ */
+
+ extern int kmtest_ok( int condition, const char *msg, ... );
+
+ #endif /* __GNUC__ */
+
+
+ #define ok_(file, line) (kmtest_set_location(file, line), 0) ? (void)0 : kmtest_ok
+ #define ok ok_(__FILE__, __LINE__)
+
+ PDEVICE_OBJECT AttachDeviceObject;
+ PDEVICE_OBJECT MainDeviceObject;
+ PDRIVER_OBJECT ThisDriverObject;
+
+ #endif /* KMTEST_H */
--- /dev/null
- HANDLE test_NtGdiDdCreateDirectDrawObject();
+
+
- void test_NtGdiDdQueryDirectDrawObject( HANDLE hDirectDrawLocal);
+ + HANDLE test_NtGdiDdCreateDirectDrawObject(void);
+ void test_NtGdiDdDeleteDirectDrawObject(HANDLE hDirectDrawLocal);
+ + void test_NtGdiDdQueryDirectDrawObject(HANDLE hDirectDrawLocal);
+ void test_NtGdiDdGetScanLine(HANDLE hDirectDrawLocal);
+ void test_NtGdiDdWaitForVerticalBlank(HANDLE hDirectDrawLocal);
+ void test_NtGdiDdCanCreateSurface(HANDLE hDirectDrawLocal);
+
+
+ void dump_halinfo(DD_HALINFO *pHalInfo, char *text);
+ void dump_CallBackFlags(DWORD *pCallBackFlags, char *text);
+ void dump_D3dCallbacks(D3DNTHAL_CALLBACKS *puD3dCallbacks, char *text);
+ void dump_D3dDriverData(D3DNTHAL_GLOBALDRIVERDATA *puD3dDriverData, char *text);
+ void dump_D3dBufferCallbacks(DD_D3DBUFCALLBACKS *puD3dCallbacks, char *text);
+ void dump_D3dTextureFormats(DDSURFACEDESC *puD3dTextureFormats, int dwNum, char *text);
+
+
+
+
+
+
+
+ #define testing_eq(input,value,counter,text) \
+ if (input == value) \
+ { \
+ counter++; \
+ printf("FAIL ret=%s, %d != %d )\n",text,(int)input,(int)value); \
+ }
+
+
+ #define testing_noteq(input,value,counter,text) \
+ if (input != value) \
+ { \
+ counter++; \
+ printf("FAIL ret=%s, %d == %d )\n",text,(int)input,(int)value); \
+ }
+
+
+ #define show_status(counter, text) \
+ if (counter == 0) \
+ { \
+ printf("End testing of %s Status : ok\n\n",text); \
+ } \
+ else \
+ { \
+ printf("End testing of %s Status : fail\n\n",text); \
+ }
+
+
+ #if !defined(__REACTOS__)
+
+ #define win_syscall(inValue,outValue,syscallid) \
+ __asm { mov eax, syscallid }; \
+ __asm { lea edx, [inValue] }; \
+ __asm { int 0x2E }; \
+ __asm { mov outValue,eax};
+
+
+
+ #endif
--- /dev/null
- int StartupHAL ();
+ #include <windows.h>
+ #include <ddrawi.h>
+ #include <d3dhal.h>
+
+
+ + int StartupHAL (VOID);
+ extern HDC hdc;
+ extern DDRAWI_DIRECTDRAW_GBL mDDrawGlobal;
+ extern DDRAWI_DIRECTDRAW_LCL mDDrawLocal;
+ extern DDHALINFO mHALInfo;
+
+ extern DDHAL_CALLBACKS mCallbacks;
+ extern DDHAL_DDEXEBUFCALLBACKS mD3dBufferCallbacks;
+ extern D3DHAL_CALLBACKS mD3dCallbacks;
+ extern D3DHAL_GLOBALDRIVERDATA mD3dDriverData;
+
+ extern UINT mcModeInfos;
+ extern DDHALMODEINFO *mpModeInfos;
+
+ extern UINT mcvmList;
+ extern VIDMEM *mpvmList;
+
+ extern UINT mcFourCC;
+ extern DWORD *mpFourCC;
+
+ extern UINT mcTextures;
+ extern DDSURFACEDESC *mpTextures;
+
+
+
+ BOOL (APIENTRY *DdCreateDirectDrawObject) (
+ LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
+ HDC hdc
+ );
+
+ BOOL (APIENTRY *DdQueryDirectDrawObject) (
+ LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
+ LPDDHALINFO pHalInfo,
+ LPDDHAL_DDCALLBACKS pDDCallbacks,
+ LPDDHAL_DDSURFACECALLBACKS pDDSurfaceCallbacks,
+ LPDDHAL_DDPALETTECALLBACKS pDDPaletteCallbacks,
+ LPD3DHAL_CALLBACKS pD3dCallbacks,
+ LPD3DHAL_GLOBALDRIVERDATA pD3dDriverData,
+ LPDDHAL_DDEXEBUFCALLBACKS pD3dBufferCallbacks,
+ LPDDSURFACEDESC pD3dTextureFormats,
+ LPDWORD pdwFourCC,
+ LPVIDMEM pvmList
+ );
+
+ BOOL
+ APIENTRY
+ DdDeleteDirectDrawObject(
+ LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal
+ );
+
+ BOOL
+ APIENTRY
+ DdCreateSurfaceObject(
+ LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
+ BOOL bPrimarySurface
+ );
+
+ BOOL
+ APIENTRY
+ DdDeleteSurfaceObject(
+ LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal
+ );
+
+ //BOOL
+ //APIENTRY
+ //DdResetVisrgn(
+ // LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
+ // HWND hWnd
+ //);
+ BOOL (APIENTRY *DdResetVisrgn) (
+ LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
+ HWND hWnd
+ );
+
+ HDC
+ APIENTRY
+ DdGetDC(
+ LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
+ LPPALETTEENTRY pColorTable
+ );
+
+ BOOL
+ APIENTRY
+ DdReleaseDC(
+ LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal
+ );
+
+ HBITMAP
+ APIENTRY
+ DdCreateDIBSection(
+ HDC hdc,
+ CONST BITMAPINFO *pbmi,
+ UINT iUsage,
+ VOID **ppvBits,
+ HANDLE hSectionApp,
+ DWORD dwOffset
+ );
+
+ BOOL
+ APIENTRY
+ DdReenableDirectDrawObject(
+ LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
+ BOOL *pbNewMode
+ );
+
+ //BOOL
+ //APIENTRY
+ //DdAttachSurface(
+ // LPDDRAWI_DDRAWSURFACE_LCL pSurfaceFrom,
+ // LPDDRAWI_DDRAWSURFACE_LCL pSurfaceTo
+ //);
+
+ BOOL (APIENTRY *DdAttachSurface) (
+ LPDDRAWI_DDRAWSURFACE_LCL pSurfaceFrom,
+ LPDDRAWI_DDRAWSURFACE_LCL pSurfaceTo
+ );
+
+ VOID
+ APIENTRY
+ DdUnattachSurface(
+ LPDDRAWI_DDRAWSURFACE_LCL pSurface,
+ LPDDRAWI_DDRAWSURFACE_LCL pSurfaceAttached
+ );
+
+ ULONG
+ APIENTRY
+ DdQueryDisplaySettingsUniqueness(VOID);
+
+ HANDLE
+ APIENTRY
+ DdGetDxHandle(
+ LPDDRAWI_DIRECTDRAW_LCL pDDraw,
+ LPDDRAWI_DDRAWSURFACE_LCL pSurface,
+ BOOL bRelease
+ );
+
+ BOOL
+ APIENTRY
+ DdSetGammaRamp(
+ LPDDRAWI_DIRECTDRAW_LCL pDDraw,
+ HDC hdc,
+ LPVOID lpGammaRamp
+ );
+
+ DWORD
+ APIENTRY
+ DdSwapTextureHandles(
+ LPDDRAWI_DIRECTDRAW_LCL pDDraw,
+ LPDDRAWI_DDRAWSURFACE_LCL pDDSLcl1,
+ LPDDRAWI_DDRAWSURFACE_LCL pDDSLcl2
+ );
+
+ char* DDErrorString (HRESULT hr)
+ {
+ switch (hr)
+ {
+ case DD_OK: return "DD_OK";
+ case DDERR_ALREADYINITIALIZED: return "DDERR_ALREADYINITIALIZED";
+ case DDERR_CANNOTATTACHSURFACE: return "DDERR_CANNOTATTACHSURFACE";
+ case DDERR_CANNOTDETACHSURFACE: return "DDERR_CANNOTDETACHSURFACE";
+ case DDERR_CURRENTLYNOTAVAIL: return "DDERR_CURRENTLYNOTAVAIL";
+ case DDERR_EXCEPTION: return "DDERR_EXCEPTION";
+ case DDERR_GENERIC: return "DDERR_GENERIC";
+ case DDERR_HEIGHTALIGN: return "DDERR_HEIGHTALIGN";
+ case DDERR_INCOMPATIBLEPRIMARY: return "DDERR_INCOMPATIBLEPRIMARY";
+ case DDERR_INVALIDCAPS: return "DDERR_INVALIDCAPS";
+ case DDERR_INVALIDCLIPLIST: return "DDERR_INVALIDCLIPLIST";
+ case DDERR_INVALIDMODE: return "DDERR_INVALIDMODE";
+ case DDERR_INVALIDOBJECT: return "DDERR_INVALIDOBJECT";
+ case DDERR_INVALIDPARAMS: return "DDERR_INVALIDPARAMS";
+ case DDERR_INVALIDPIXELFORMAT: return "DDERR_INVALIDPIXELFORMAT";
+ case DDERR_INVALIDRECT: return "DDERR_INVALIDRECT";
+ case DDERR_LOCKEDSURFACES: return "DDERR_LOCKEDSURFACES";
+ case DDERR_NO3D: return "DDERR_NO3D";
+ case DDERR_NOALPHAHW: return "DDERR_NOALPHAHW";
+ case DDERR_NOCLIPLIST: return "DDERR_NOCLIPLIST";
+ case DDERR_NOCOLORCONVHW: return "DDERR_NOCOLORCONVHW";
+ case DDERR_NOCOOPERATIVELEVELSET: return "DDERR_NOCOOPERATIVELEVELSET";
+ case DDERR_NOCOLORKEY: return "DDERR_NOCOLORKEY";
+ case DDERR_NOCOLORKEYHW: return "DDERR_NOCOLORKEYHW";
+ case DDERR_NODIRECTDRAWSUPPORT: return "DDERR_NODIRECTDRAWSUPPORT";
+ case DDERR_NOEXCLUSIVEMODE: return "DDERR_NOEXCLUSIVEMODE";
+ case DDERR_NOFLIPHW: return "DDERR_NOFLIPHW";
+ case DDERR_NOGDI: return "DDERR_NOGDI";
+ case DDERR_NOMIRRORHW: return "DDERR_NOMIRRORHW";
+ case DDERR_NOTFOUND: return "DDERR_NOTFOUND";
+ case DDERR_NOOVERLAYHW: return "DDERR_NOOVERLAYHW";
+ case DDERR_NORASTEROPHW: return "DDERR_NORASTEROPHW";
+ case DDERR_NOROTATIONHW: return "DDERR_NOROTATIONHW";
+ case DDERR_NOSTRETCHHW: return "DDERR_NOSTRETCHHW";
+ case DDERR_NOT4BITCOLOR: return "DDERR_NOT4BITCOLOR";
+ case DDERR_NOT4BITCOLORINDEX: return "DDERR_NOT4BITCOLORINDEX";
+ case DDERR_NOT8BITCOLOR: return "DDERR_NOT8BITCOLOR";
+ case DDERR_NOTEXTUREHW: return "DDERR_NOTEXTUREHW";
+ case DDERR_NOVSYNCHW: return "DDERR_NOVSYNCHW";
+ case DDERR_NOZBUFFERHW: return "DDERR_NOZBUFFERHW";
+ case DDERR_NOZOVERLAYHW: return "DDERR_NOZOVERLAYHW";
+ case DDERR_OUTOFCAPS: return "DDERR_OUTOFCAPS";
+ case DDERR_OUTOFMEMORY: return "DDERR_OUTOFMEMORY";
+ case DDERR_OUTOFVIDEOMEMORY: return "DDERR_OUTOFVIDEOMEMORY";
+ case DDERR_OVERLAYCANTCLIP: return "DDERR_OVERLAYCANTCLIP";
+ case DDERR_OVERLAYCOLORKEYONLYONEACTIVE: return "DDERR_OVERLAYCOLORKEYONLYONEACTIVE";
+ case DDERR_PALETTEBUSY: return "DDERR_PALETTEBUSY";
+ case DDERR_COLORKEYNOTSET: return "DDERR_COLORKEYNOTSET";
+ case DDERR_SURFACEALREADYATTACHED: return "DDERR_SURFACEALREADYATTACHED";
+ case DDERR_SURFACEALREADYDEPENDENT: return "DDERR_SURFACEALREADYDEPENDENT";
+ case DDERR_SURFACEBUSY: return "DDERR_SURFACEBUSY";
+ case DDERR_CANTLOCKSURFACE: return "DDERR_CANTLOCKSURFACE";
+ case DDERR_SURFACEISOBSCURED: return "DDERR_SURFACEISOBSCURED";
+ case DDERR_SURFACELOST: return "DDERR_SURFACELOST";
+ case DDERR_SURFACENOTATTACHED: return "DDERR_SURFACENOTATTACHED";
+ case DDERR_TOOBIGHEIGHT: return "DDERR_TOOBIGHEIGHT";
+ case DDERR_TOOBIGSIZE: return "DDERR_TOOBIGSIZE";
+ case DDERR_TOOBIGWIDTH: return "DDERR_TOOBIGWIDTH";
+ case DDERR_UNSUPPORTED: return "DDERR_UNSUPPORTED";
+ case DDERR_UNSUPPORTEDFORMAT: return "DDERR_UNSUPPORTEDFORMAT";
+ case DDERR_UNSUPPORTEDMASK: return "DDERR_UNSUPPORTEDMASK";
+ case DDERR_VERTICALBLANKINPROGRESS: return "DDERR_VERTICALBLANKINPROGRESS";
+ case DDERR_WASSTILLDRAWING: return "DDERR_WASSTILLDRAWING";
+ case DDERR_XALIGN: return "DDERR_XALIGN";
+ case DDERR_INVALIDDIRECTDRAWGUID: return "DDERR_INVALIDDIRECTDRAWGUID";
+ case DDERR_DIRECTDRAWALREADYCREATED: return "DDERR_DIRECTDRAWALREADYCREATED";
+ case DDERR_NODIRECTDRAWHW: return "DDERR_NODIRECTDRAWHW";
+ case DDERR_PRIMARYSURFACEALREADYEXISTS: return "DDERR_PRIMARYSURFACEALREADYEXISTS";
+ case DDERR_NOEMULATION: return "DDERR_NOEMULATION";
+ case DDERR_REGIONTOOSMALL: return "DDERR_REGIONTOOSMALL";
+ case DDERR_CLIPPERISUSINGHWND: return "DDERR_CLIPPERISUSINGHWND";
+ case DDERR_NOCLIPPERATTACHED: return "DDERR_NOCLIPPERATTACHED";
+ case DDERR_NOHWND: return "DDERR_NOHWND";
+ case DDERR_HWNDSUBCLASSED: return "DDERR_HWNDSUBCLASSED";
+ case DDERR_HWNDALREADYSET: return "DDERR_HWNDALREADYSET";
+ case DDERR_NOPALETTEATTACHED: return "DDERR_NOPALETTEATTACHED";
+ case DDERR_NOPALETTEHW: return "DDERR_NOPALETTEHW";
+ case DDERR_BLTFASTCANTCLIP: return "DDERR_BLTFASTCANTCLIP";
+ case DDERR_NOBLTHW: return "DDERR_NOBLTHW";
+ case DDERR_NODDROPSHW: return "DDERR_NODDROPSHW";
+ case DDERR_OVERLAYNOTVISIBLE: return "DDERR_OVERLAYNOTVISIBLE";
+ case DDERR_NOOVERLAYDEST: return "DDERR_NOOVERLAYDEST";
+ case DDERR_INVALIDPOSITION: return "DDERR_INVALIDPOSITION";
+ case DDERR_NOTAOVERLAYSURFACE: return "DDERR_NOTAOVERLAYSURFACE";
+ case DDERR_EXCLUSIVEMODEALREADYSET: return "DDERR_EXCLUSIVEMODEALREADYSET";
+ case DDERR_NOTFLIPPABLE: return "DDERR_NOTFLIPPABLE";
+ case DDERR_CANTDUPLICATE: return "DDERR_CANTDUPLICATE";
+ case DDERR_NOTLOCKED: return "DDERR_NOTLOCKED";
+ case DDERR_CANTCREATEDC: return "DDERR_CANTCREATEDC";
+ case DDERR_NODC: return "DDERR_NODC";
+ case DDERR_WRONGMODE: return "DDERR_WRONGMODE";
+ case DDERR_IMPLICITLYCREATED: return "DDERR_IMPLICITLYCREATED";
+ case DDERR_NOTPALETTIZED: return "DDERR_NOTPALETTIZED";
+ case DDERR_UNSUPPORTEDMODE: return "DDERR_UNSUPPORTEDMODE";
+ case DDERR_NOMIPMAPHW: return "DDERR_NOMIPMAPHW";
+ case DDERR_INVALIDSURFACETYPE: return "DDERR_INVALIDSURFACETYPE";
+ case DDERR_DCALREADYCREATED: return "DDERR_DCALREADYCREATED";
+ case DDERR_CANTPAGELOCK: return "DDERR_CANTPAGELOCK";
+ case DDERR_CANTPAGEUNLOCK: return "DDERR_CANTPAGEUNLOCK";
+ case DDERR_NOTPAGELOCKED: return "DDERR_NOTPAGELOCKED";
+ case DDERR_NOTINITIALIZED: return "DDERR_NOTINITIALIZED";
+ }
+
+ return "Unknown Error ";
+ }
+
--- /dev/null
+
+ add_definitions(-D__ROS_LONG64__)
+
+ add_subdirectory(advapi32)
+ add_subdirectory(advpack)
+ add_subdirectory(amstream)
+ add_subdirectory(atl)
+ add_subdirectory(avifil32)
+ add_subdirectory(browseui)
+ add_subdirectory(cabinet)
+ add_subdirectory(comcat)
+ add_subdirectory(comctl32)
+ add_subdirectory(comdlg32)
+ add_subdirectory(credui)
+ add_subdirectory(crypt32)
+ add_subdirectory(cryptnet)
+ add_subdirectory(cryptui)
+ add_subdirectory(dnsapi)
+ add_subdirectory(dsound)
+ add_subdirectory(fusion)
+ add_subdirectory(gdi32)
+ add_subdirectory(gdiplus)
+ add_subdirectory(hlink)
+ add_subdirectory(icmp)
+ + add_subdirectory(imagehlp)
+ add_subdirectory(imm32)
+ add_subdirectory(inetcomm)
+ add_subdirectory(inetmib1)
+ add_subdirectory(iphlpapi)
+ add_subdirectory(itss)
+ add_subdirectory(jscript)
+ add_subdirectory(kernel32)
+ add_subdirectory(localspl)
+ add_subdirectory(localui)
+ add_subdirectory(lz32)
+ add_subdirectory(mapi32)
+ add_subdirectory(mlang)
+ add_subdirectory(msacm32)
+ add_subdirectory(mscms)
+ add_subdirectory(msctf)
+ add_subdirectory(mshtml)
+ add_subdirectory(msi)
+ add_subdirectory(mstask)
+ add_subdirectory(msvcrt)
+ add_subdirectory(msvcrtd)
+ add_subdirectory(msvfw32)
+ add_subdirectory(msxml3)
+ add_subdirectory(netapi32)
+ add_subdirectory(ntdll)
+ add_subdirectory(ntdsapi)
+ add_subdirectory(ntprint)
+ add_subdirectory(odbccp32)
+ add_subdirectory(ole32)
+ add_subdirectory(oleacc)
+ add_subdirectory(oleaut32)
+ add_subdirectory(opengl32)
+ add_subdirectory(pdh)
+ add_subdirectory(powrprof)
+ add_subdirectory(psapi)
+ add_subdirectory(qmgr)
+ add_subdirectory(quartz)
+ add_subdirectory(rasapi32)
+ add_subdirectory(riched20)
+ add_subdirectory(riched32)
+ add_subdirectory(rpcrt4)
+ add_subdirectory(rsabase)
+ add_subdirectory(rsaenh)
+ add_subdirectory(schannel)
+ add_subdirectory(secur32)
+ add_subdirectory(serialui)
+ add_subdirectory(setupapi)
+ add_subdirectory(shdocvw)
+ add_subdirectory(shell32)
+ add_subdirectory(shlwapi)
+ add_subdirectory(snmpapi)
+ add_subdirectory(spoolss)
+ add_subdirectory(twain_32)
+ add_subdirectory(urlmon)
+ add_subdirectory(user32)
+ add_subdirectory(userenv)
+ add_subdirectory(usp10)
+ add_subdirectory(uxtheme)
+ add_subdirectory(version)
+ add_subdirectory(winhttp)
+ add_subdirectory(wininet)
+ add_subdirectory(winmm)
+ add_subdirectory(wintrust)
+ add_subdirectory(wlanapi)
+ add_subdirectory(wldap32)
+ add_subdirectory(ws2_32)
+ add_subdirectory(xmllite)
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
--- /dev/null
-
+++/*
+++ * Copyright 2005-2006 Jacek Caban for CodeWeavers
+++ *
+++ * This library is free software; you can redistribute it and/or
+++ * modify it under the terms of the GNU Lesser General Public
+++ * License as published by the Free Software Foundation; either
+++ * version 2.1 of the License, or (at your option) any later version.
+++ *
+++ * This library is distributed in the hope that it will be useful,
+++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+++ * Lesser General Public License for more details.
+++ *
+++ * You should have received a copy of the GNU Lesser General Public
+++ * License along with this library; if not, write to the Free Software
+++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+++ */
+++
+++#define COBJMACROS
+++#define CONST_VTABLE
+++#define NONAMELESSUNION
+++
+++#include <wine/test.h>
+++#include <stdarg.h>
+++#include <stddef.h>
+++
+++#include "windef.h"
+++#include "winbase.h"
+++#include "ole2.h"
+++#include "urlmon.h"
+++
+++#include "initguid.h"
+++
+++DEFINE_GUID(CLSID_AboutProtocol, 0x3050F406, 0x98B5, 0x11CF, 0xBB,0x82, 0x00,0xAA,0x00,0xBD,0xCE,0x0B);
+++
+++#define DEFINE_EXPECT(func) \
+++ static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
+++
+++#define SET_EXPECT(func) \
+++ expect_ ## func = TRUE
+++
+++#define CHECK_EXPECT(func) \
+++ do { \
+++ ok(expect_ ##func, "unexpected call " #func "\n"); \
+++ expect_ ## func = FALSE; \
+++ called_ ## func = TRUE; \
+++ }while(0)
+++
+++#define CHECK_EXPECT2(func) \
+++ do { \
+++ ok(expect_ ##func, "unexpected call " #func "\n"); \
+++ called_ ## func = TRUE; \
+++ }while(0)
+++
+++#define CHECK_CALLED(func) \
+++ do { \
+++ ok(called_ ## func, "expected " #func "\n"); \
+++ expect_ ## func = called_ ## func = FALSE; \
+++ }while(0)
+++
+++DEFINE_EXPECT(ParseUrl);
+++DEFINE_EXPECT(QI_IInternetProtocolInfo);
+++DEFINE_EXPECT(CreateInstance);
+++DEFINE_EXPECT(unk_Release);
+++
+++static HRESULT (WINAPI *pCoInternetCompareUrl)(LPCWSTR, LPCWSTR, DWORD);
+++static HRESULT (WINAPI *pCoInternetGetSecurityUrl)(LPCWSTR, LPWSTR*, PSUACTION, DWORD);
+++static HRESULT (WINAPI *pCoInternetGetSession)(DWORD, IInternetSession **, DWORD);
+++static HRESULT (WINAPI *pCoInternetParseUrl)(LPCWSTR, PARSEACTION, DWORD, LPWSTR, DWORD, DWORD *, DWORD);
+++static HRESULT (WINAPI *pCoInternetQueryInfo)(LPCWSTR, QUERYOPTION, DWORD, LPVOID, DWORD, DWORD *, DWORD);
+++static HRESULT (WINAPI *pCopyStgMedium)(const STGMEDIUM *, STGMEDIUM *);
+++static HRESULT (WINAPI *pFindMimeFromData)(LPBC, LPCWSTR, LPVOID, DWORD, LPCWSTR,
+++ DWORD, LPWSTR*, DWORD);
+++static HRESULT (WINAPI *pObtainUserAgentString)(DWORD, LPSTR, DWORD*);
+++static HRESULT (WINAPI *pReleaseBindInfo)(BINDINFO*);
+++static HRESULT (WINAPI *pUrlMkGetSessionOption)(DWORD, LPVOID, DWORD, DWORD *, DWORD);
-
++++static HRESULT (WINAPI *pCompareSecurityIds)(BYTE*,DWORD,BYTE*,DWORD,DWORD);
++++static HRESULT (WINAPI *pCoInternetIsFeatureEnabled)(INTERNETFEATURELIST,DWORD);
++++static HRESULT (WINAPI *pCoInternetSetFeatureEnabled)(INTERNETFEATURELIST,DWORD,BOOL);
++++static HRESULT (WINAPI *pIEInstallScope)(DWORD*);
+++
+++static void test_CreateFormatEnum(void)
+++{
+++ IEnumFORMATETC *fenum = NULL, *fenum2 = NULL;
+++ FORMATETC fetc[5];
+++ ULONG ul;
+++ HRESULT hres;
+++
+++ static DVTARGETDEVICE dev = {sizeof(dev),0,0,0,0,{0}};
+++ static FORMATETC formatetc[] = {
+++ {0,&dev,0,0,0},
+++ {0,&dev,0,1,0},
+++ {0,NULL,0,2,0},
+++ {0,NULL,0,3,0},
+++ {0,NULL,0,4,0}
+++ };
+++
+++ hres = CreateFormatEnumerator(0, formatetc, &fenum);
+++ ok(hres == E_FAIL, "CreateFormatEnumerator failed: %08x, expected E_FAIL\n", hres);
+++ hres = CreateFormatEnumerator(0, formatetc, NULL);
+++ ok(hres == E_INVALIDARG, "CreateFormatEnumerator failed: %08x, expected E_INVALIDARG\n", hres);
+++ hres = CreateFormatEnumerator(5, formatetc, NULL);
+++ ok(hres == E_INVALIDARG, "CreateFormatEnumerator failed: %08x, expected E_INVALIDARG\n", hres);
+++
+++
+++ hres = CreateFormatEnumerator(5, formatetc, &fenum);
+++ ok(hres == S_OK, "CreateFormatEnumerator failed: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = IEnumFORMATETC_Next(fenum, 2, NULL, &ul);
+++ ok(hres == E_INVALIDARG, "Next failed: %08x, expected E_INVALIDARG\n", hres);
+++ ul = 100;
+++ hres = IEnumFORMATETC_Next(fenum, 0, fetc, &ul);
+++ ok(hres == S_OK, "Next failed: %08x\n", hres);
+++ ok(ul == 0, "ul=%d, expected 0\n", ul);
+++
+++ hres = IEnumFORMATETC_Next(fenum, 2, fetc, &ul);
+++ ok(hres == S_OK, "Next failed: %08x\n", hres);
+++ ok(fetc[0].lindex == 0, "fetc[0].lindex=%d, expected 0\n", fetc[0].lindex);
+++ ok(fetc[1].lindex == 1, "fetc[1].lindex=%d, expected 1\n", fetc[1].lindex);
+++ ok(fetc[0].ptd == &dev, "fetc[0].ptd=%p, expected %p\n", fetc[0].ptd, &dev);
+++ ok(ul == 2, "ul=%d, expected 2\n", ul);
+++
+++ hres = IEnumFORMATETC_Skip(fenum, 1);
+++ ok(hres == S_OK, "Skip failed: %08x\n", hres);
+++
+++ hres = IEnumFORMATETC_Next(fenum, 4, fetc, &ul);
+++ ok(hres == S_FALSE, "Next failed: %08x, expected S_FALSE\n", hres);
+++ ok(fetc[0].lindex == 3, "fetc[0].lindex=%d, expected 3\n", fetc[0].lindex);
+++ ok(fetc[1].lindex == 4, "fetc[1].lindex=%d, expected 4\n", fetc[1].lindex);
+++ ok(fetc[0].ptd == NULL, "fetc[0].ptd=%p, expected NULL\n", fetc[0].ptd);
+++ ok(ul == 2, "ul=%d, expected 2\n", ul);
+++
+++ hres = IEnumFORMATETC_Next(fenum, 4, fetc, &ul);
+++ ok(hres == S_FALSE, "Next failed: %08x, expected S_FALSE\n", hres);
+++ ok(ul == 0, "ul=%d, expected 0\n", ul);
+++ ul = 100;
+++ hres = IEnumFORMATETC_Next(fenum, 0, fetc, &ul);
+++ ok(hres == S_OK, "Next failed: %08x\n", hres);
+++ ok(ul == 0, "ul=%d, expected 0\n", ul);
+++
+++ hres = IEnumFORMATETC_Skip(fenum, 3);
+++ ok(hres == S_FALSE, "Skip failed: %08x, expected S_FALSE\n", hres);
+++
+++ hres = IEnumFORMATETC_Reset(fenum);
+++ ok(hres == S_OK, "Reset failed: %08x\n", hres);
+++
+++ hres = IEnumFORMATETC_Next(fenum, 5, fetc, NULL);
+++ ok(hres == S_OK, "Next failed: %08x\n", hres);
+++ ok(fetc[0].lindex == 0, "fetc[0].lindex=%d, expected 0\n", fetc[0].lindex);
+++
+++ hres = IEnumFORMATETC_Reset(fenum);
+++ ok(hres == S_OK, "Reset failed: %08x\n", hres);
+++
+++ hres = IEnumFORMATETC_Skip(fenum, 2);
+++ ok(hres == S_OK, "Skip failed: %08x\n", hres);
+++
+++ hres = IEnumFORMATETC_Clone(fenum, NULL);
+++ ok(hres == E_INVALIDARG, "Clone failed: %08x, expected E_INVALIDARG\n", hres);
+++
+++ hres = IEnumFORMATETC_Clone(fenum, &fenum2);
+++ ok(hres == S_OK, "Clone failed: %08x\n", hres);
+++
+++ if(SUCCEEDED(hres)) {
+++ ok(fenum != fenum2, "fenum == fenum2\n");
+++
+++ hres = IEnumFORMATETC_Next(fenum2, 2, fetc, &ul);
+++ ok(hres == S_OK, "Next failed: %08x\n", hres);
+++ ok(fetc[0].lindex == 2, "fetc[0].lindex=%d, expected 2\n", fetc[0].lindex);
+++
+++ IEnumFORMATETC_Release(fenum2);
+++ }
+++
+++ hres = IEnumFORMATETC_Next(fenum, 2, fetc, &ul);
+++ ok(hres == S_OK, "Next failed: %08x\n", hres);
+++ ok(fetc[0].lindex == 2, "fetc[0].lindex=%d, expected 2\n", fetc[0].lindex);
+++
+++ hres = IEnumFORMATETC_Skip(fenum, 1);
+++ ok(hres == S_OK, "Skip failed: %08x\n", hres);
+++
+++ IEnumFORMATETC_Release(fenum);
+++}
+++
+++static void test_RegisterFormatEnumerator(void)
+++{
+++ IBindCtx *bctx = NULL;
+++ IEnumFORMATETC *format = NULL, *format2 = NULL;
+++ IUnknown *unk = NULL;
+++ HRESULT hres;
+++
+++ static FORMATETC formatetc = {0,NULL,0,0,0};
+++ static WCHAR wszEnumFORMATETC[] =
+++ {'_','E','n','u','m','F','O','R','M','A','T','E','T','C','_',0};
+++
+++ CreateBindCtx(0, &bctx);
+++
+++ hres = CreateFormatEnumerator(1, &formatetc, &format);
+++ ok(hres == S_OK, "CreateFormatEnumerator failed: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = RegisterFormatEnumerator(NULL, format, 0);
+++ ok(hres == E_INVALIDARG,
+++ "RegisterFormatEnumerator failed: %08x, expected E_INVALIDARG\n", hres);
+++ hres = RegisterFormatEnumerator(bctx, NULL, 0);
+++ ok(hres == E_INVALIDARG,
+++ "RegisterFormatEnumerator failed: %08x, expected E_INVALIDARG\n", hres);
+++
+++ hres = RegisterFormatEnumerator(bctx, format, 0);
+++ ok(hres == S_OK, "RegisterFormatEnumerator failed: %08x\n", hres);
+++
+++ hres = IBindCtx_GetObjectParam(bctx, wszEnumFORMATETC, &unk);
+++ ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
+++ ok(unk == (IUnknown*)format, "unk != format\n");
+++
+++ hres = RevokeFormatEnumerator(NULL, format);
+++ ok(hres == E_INVALIDARG,
+++ "RevokeFormatEnumerator failed: %08x, expected E_INVALIDARG\n", hres);
+++
+++ hres = RevokeFormatEnumerator(bctx, format);
+++ ok(hres == S_OK, "RevokeFormatEnumerator failed: %08x\n", hres);
+++
+++ hres = RevokeFormatEnumerator(bctx, format);
+++ ok(hres == E_FAIL, "RevokeFormatEnumerator failed: %08x, expected E_FAIL\n", hres);
+++
+++ hres = IBindCtx_GetObjectParam(bctx, wszEnumFORMATETC, &unk);
+++ ok(hres == E_FAIL, "GetObjectParam failed: %08x, expected E_FAIL\n", hres);
+++
+++ hres = RegisterFormatEnumerator(bctx, format, 0);
+++ ok(hres == S_OK, "RegisterFormatEnumerator failed: %08x\n", hres);
+++
+++ hres = CreateFormatEnumerator(1, &formatetc, &format2);
+++ ok(hres == S_OK, "CreateFormatEnumerator failed: %08x\n", hres);
+++
+++ if(SUCCEEDED(hres)) {
+++ hres = RevokeFormatEnumerator(bctx, format);
+++ ok(hres == S_OK, "RevokeFormatEnumerator failed: %08x\n", hres);
+++
+++ IEnumFORMATETC_Release(format2);
+++ }
+++
+++ hres = IBindCtx_GetObjectParam(bctx, wszEnumFORMATETC, &unk);
+++ ok(hres == E_FAIL, "GetObjectParam failed: %08x, expected E_FAIL\n", hres);
+++
+++ IEnumFORMATETC_Release(format);
+++
+++ hres = RegisterFormatEnumerator(bctx, format, 0);
+++ ok(hres == S_OK, "RegisterFormatEnumerator failed: %08x\n", hres);
+++ hres = RevokeFormatEnumerator(bctx, NULL);
+++ ok(hres == S_OK, "RevokeFormatEnumerator failed: %08x\n", hres);
+++ hres = IBindCtx_GetObjectParam(bctx, wszEnumFORMATETC, &unk);
+++ ok(hres == E_FAIL, "GetObjectParam failed: %08x, expected E_FAIL\n", hres);
+++
+++ IEnumFORMATETC_Release(format);
+++ IBindCtx_Release(bctx);
+++}
+++
+++static const WCHAR url1[] = {'r','e','s',':','/','/','m','s','h','t','m','l','.','d','l','l',
+++ '/','b','l','a','n','k','.','h','t','m',0};
+++static const WCHAR url2[] = {'i','n','d','e','x','.','h','t','m',0};
+++static const WCHAR url3[] = {'f','i','l','e',':','/','/','c',':','\\','I','n','d','e','x','.','h','t','m',0};
+++static const WCHAR url4[] = {'f','i','l','e',':','s','o','m','e','%','2','0','f','i','l','e',
+++ '%','2','e','j','p','g',0};
+++static const WCHAR url5[] = {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q',
+++ '.','o','r','g',0};
+++static const WCHAR url6[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
+++static const WCHAR url7[] = {'f','t','p',':','/','/','w','i','n','e','h','q','.','o','r','g','/',
+++ 'f','i','l','e','.','t','e','s','t',0};
+++static const WCHAR url8[] = {'t','e','s','t',':','1','2','3','a','b','c',0};
+++static const WCHAR url9[] =
+++ {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.','o','r','g',
+++ '/','s','i','t','e','/','a','b','o','u','t',0};
+++static const WCHAR url10[] = {'f','i','l','e',':','/','/','s','o','m','e','%','2','0','f','i','l','e',
+++ '.','j','p','g',0};
- if (!pCoInternetParseUrl) {
- return;
- }
-
++++static const WCHAR url11[] = {'h','t','t','p',':','/','/','g','o','o','g','l','e','.','*','.',
++++ 'c','o','m',0};
+++static const WCHAR url4e[] = {'f','i','l','e',':','s','o','m','e',' ','f','i','l','e',
+++ '.','j','p','g',0};
+++
+++static const WCHAR path3[] = {'c',':','\\','I','n','d','e','x','.','h','t','m',0};
+++static const WCHAR path4[] = {'s','o','m','e',' ','f','i','l','e','.','j','p','g',0};
+++
+++static const WCHAR wszRes[] = {'r','e','s',0};
+++static const WCHAR wszFile[] = {'f','i','l','e',0};
+++static const WCHAR wszHttp[] = {'h','t','t','p',0};
+++static const WCHAR wszAbout[] = {'a','b','o','u','t',0};
+++static const WCHAR wszEmpty[] = {0};
++++static const WCHAR wszGoogle[] = {'g','o','o','g','l','e','.','*','.','c','o','m',0};
+++
+++static const WCHAR wszWineHQ[] = {'w','w','w','.','w','i','n','e','h','q','.','o','r','g',0};
+++static const WCHAR wszHttpWineHQ[] = {'h','t','t','p',':','/','/','w','w','w','.',
+++ 'w','i','n','e','h','q','.','o','r','g',0};
++++static const WCHAR wszHttpGoogle[] = {'h','t','t','p',':','/','/','g','o','o','g','l','e',
++++ '.','*','.','c','o','m',0};
+++
+++struct parse_test {
+++ LPCWSTR url;
+++ HRESULT secur_hres;
+++ LPCWSTR encoded_url;
+++ HRESULT path_hres;
+++ LPCWSTR path;
+++ LPCWSTR schema;
+++ LPCWSTR domain;
+++ HRESULT domain_hres;
+++ LPCWSTR rootdocument;
+++ HRESULT rootdocument_hres;
+++};
+++
+++static const struct parse_test parse_tests[] = {
+++ {url1, S_OK, url1, E_INVALIDARG, NULL, wszRes, NULL, E_FAIL, NULL, E_FAIL},
+++ {url2, E_FAIL, url2, E_INVALIDARG, NULL, wszEmpty, NULL, E_FAIL, NULL, E_FAIL},
+++ {url3, E_FAIL, url3, S_OK, path3, wszFile, wszEmpty, S_OK, NULL, E_FAIL},
+++ {url4, E_FAIL, url4e, S_OK, path4, wszFile, wszEmpty, S_OK, NULL, E_FAIL},
+++ {url5, E_FAIL, url5, E_INVALIDARG, NULL, wszHttp, wszWineHQ, S_OK, wszHttpWineHQ, S_OK},
+++ {url6, S_OK, url6, E_INVALIDARG, NULL, wszAbout, NULL, E_FAIL, NULL, E_FAIL},
++++ {url11, E_FAIL, url11, E_INVALIDARG, NULL, wszHttp, wszGoogle, S_OK, wszHttpGoogle, S_OK}
+++};
+++
+++static void test_CoInternetParseUrl(void)
+++{
+++ HRESULT hres;
+++ DWORD size;
+++ int i;
+++
+++ static WCHAR buf[4096];
+++
- if (!pCoInternetCompareUrl) {
- return;
- }
-
+++ memset(buf, 0xf0, sizeof(buf));
+++ hres = pCoInternetParseUrl(parse_tests[0].url, PARSE_SCHEMA, 0, buf,
+++ 3, &size, 0);
+++ ok(hres == E_POINTER, "schema failed: %08x, expected E_POINTER\n", hres);
+++
+++ for(i=0; i < sizeof(parse_tests)/sizeof(parse_tests[0]); i++) {
+++ memset(buf, 0xf0, sizeof(buf));
+++ hres = pCoInternetParseUrl(parse_tests[i].url, PARSE_SECURITY_URL, 0, buf,
+++ sizeof(buf)/sizeof(WCHAR), &size, 0);
+++ ok(hres == parse_tests[i].secur_hres, "[%d] security url failed: %08x, expected %08x\n",
+++ i, hres, parse_tests[i].secur_hres);
+++
+++ memset(buf, 0xf0, sizeof(buf));
+++ hres = pCoInternetParseUrl(parse_tests[i].url, PARSE_ENCODE, 0, buf,
+++ sizeof(buf)/sizeof(WCHAR), &size, 0);
+++ ok(hres == S_OK, "[%d] encoding failed: %08x\n", i, hres);
+++ ok(size == lstrlenW(parse_tests[i].encoded_url), "[%d] wrong size\n", i);
+++ ok(!lstrcmpW(parse_tests[i].encoded_url, buf), "[%d] wrong encoded url\n", i);
+++
+++ memset(buf, 0xf0, sizeof(buf));
+++ hres = pCoInternetParseUrl(parse_tests[i].url, PARSE_PATH_FROM_URL, 0, buf,
+++ sizeof(buf)/sizeof(WCHAR), &size, 0);
+++ ok(hres == parse_tests[i].path_hres, "[%d] path failed: %08x, expected %08x\n",
+++ i, hres, parse_tests[i].path_hres);
+++ if(parse_tests[i].path) {
+++ ok(size == lstrlenW(parse_tests[i].path), "[%d] wrong size\n", i);
+++ ok(!lstrcmpW(parse_tests[i].path, buf), "[%d] wrong path\n", i);
+++ }
+++
+++ memset(buf, 0xf0, sizeof(buf));
+++ hres = pCoInternetParseUrl(parse_tests[i].url, PARSE_SCHEMA, 0, buf,
+++ sizeof(buf)/sizeof(WCHAR), &size, 0);
+++ ok(hres == S_OK, "[%d] schema failed: %08x\n", i, hres);
+++ ok(size == lstrlenW(parse_tests[i].schema), "[%d] wrong size\n", i);
+++ ok(!lstrcmpW(parse_tests[i].schema, buf), "[%d] wrong schema\n", i);
+++
+++ if(memcmp(parse_tests[i].url, wszRes, 3*sizeof(WCHAR))
+++ && memcmp(parse_tests[i].url, wszAbout, 5*sizeof(WCHAR))) {
+++ memset(buf, 0xf0, sizeof(buf));
+++ hres = pCoInternetParseUrl(parse_tests[i].url, PARSE_DOMAIN, 0, buf,
+++ sizeof(buf)/sizeof(WCHAR), &size, 0);
+++ ok(hres == parse_tests[i].domain_hres, "[%d] domain failed: %08x\n", i, hres);
+++ if(parse_tests[i].domain)
+++ ok(!lstrcmpW(parse_tests[i].domain, buf), "[%d] wrong domain, received %s\n", i, wine_dbgstr_w(buf));
+++ }
+++
+++ memset(buf, 0xf0, sizeof(buf));
+++ hres = pCoInternetParseUrl(parse_tests[i].url, PARSE_ROOTDOCUMENT, 0, buf,
+++ sizeof(buf)/sizeof(WCHAR), &size, 0);
+++ ok(hres == parse_tests[i].rootdocument_hres, "[%d] rootdocument failed: %08x\n", i, hres);
+++ if(parse_tests[i].rootdocument)
+++ ok(!lstrcmpW(parse_tests[i].rootdocument, buf), "[%d] wrong rootdocument, received %s\n", i, wine_dbgstr_w(buf));
+++ }
+++}
+++
+++static void test_CoInternetCompareUrl(void)
+++{
+++ HRESULT hres;
+++
- if (!pCoInternetQueryInfo) {
- return;
- }
-
+++ hres = pCoInternetCompareUrl(url1, url1, 0);
+++ ok(hres == S_OK, "CoInternetCompareUrl failed: %08x\n", hres);
+++
+++ hres = pCoInternetCompareUrl(url1, url3, 0);
+++ ok(hres == S_FALSE, "CoInternetCompareUrl failed: %08x\n", hres);
+++
+++ hres = pCoInternetCompareUrl(url3, url1, 0);
+++ ok(hres == S_FALSE, "CoInternetCompareUrl failed: %08x\n", hres);
+++}
+++
+++static const struct {
+++ LPCWSTR url;
+++ DWORD uses_net;
+++} query_info_tests[] = {
+++ {url1, 0},
+++ {url2, 0},
+++ {url3, 0},
+++ {url4, 0},
+++ {url5, 0},
+++ {url6, 0},
+++ {url7, 0},
+++ {url8, 0}
+++};
+++
+++static void test_CoInternetQueryInfo(void)
+++{
+++ BYTE buf[100];
+++ DWORD cb, i;
+++ HRESULT hres;
+++
- if (!pFindMimeFromData) {
- return;
- }
-
+++ for(i=0; i < sizeof(query_info_tests)/sizeof(query_info_tests[0]); i++) {
+++ cb = 0xdeadbeef;
+++ memset(buf, '?', sizeof(buf));
+++ hres = pCoInternetQueryInfo(query_info_tests[0].url, QUERY_USES_NETWORK, 0, buf, sizeof(buf), &cb, 0);
+++ ok(hres == S_OK, "[%d] CoInternetQueryInfo failed: %08x\n", i, hres);
+++ ok(cb == sizeof(DWORD), "[%d] cb = %d\n", i, cb);
+++ ok(*(DWORD*)buf == query_info_tests[i].uses_net, "[%d] ret %x, expected %x\n",
+++ i, *(DWORD*)buf, query_info_tests[i].uses_net);
+++
+++ hres = pCoInternetQueryInfo(query_info_tests[0].url, QUERY_USES_NETWORK, 0, buf, 3, &cb, 0);
+++ ok(hres == E_FAIL, "[%d] CoInternetQueryInfo failed: %08x, expected E_FAIL\n", i, hres);
+++ hres = pCoInternetQueryInfo(query_info_tests[0].url, QUERY_USES_NETWORK, 0, NULL, sizeof(buf), &cb, 0);
+++ ok(hres == E_FAIL, "[%d] CoInternetQueryInfo failed: %08x, expected E_FAIL\n", i, hres);
+++
+++ memset(buf, '?', sizeof(buf));
+++ hres = pCoInternetQueryInfo(query_info_tests[0].url, QUERY_USES_NETWORK, 0, buf, sizeof(buf), NULL, 0);
+++ ok(hres == S_OK, "[%d] CoInternetQueryInfo failed: %08x\n", i, hres);
+++ ok(*(DWORD*)buf == query_info_tests[i].uses_net, "[%d] ret %x, expected %x\n",
+++ i, *(DWORD*)buf, query_info_tests[i].uses_net);
+++ }
+++}
+++
+++static const WCHAR mimeTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};
+++static const WCHAR mimeTextPlain[] = {'t','e','x','t','/','p','l','a','i','n',0};
+++static const WCHAR mimeTextRichtext[] = {'t','e','x','t','/','r','i','c','h','t','e','x','t',0};
+++static const WCHAR mimeAppOctetStream[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
+++ 'o','c','t','e','t','-','s','t','r','e','a','m',0};
+++static const WCHAR mimeImagePjpeg[] = {'i','m','a','g','e','/','p','j','p','e','g',0};
+++static const WCHAR mimeImageGif[] = {'i','m','a','g','e','/','g','i','f',0};
+++static const WCHAR mimeImageBmp[] = {'i','m','a','g','e','/','b','m','p',0};
+++static const WCHAR mimeImageXPng[] = {'i','m','a','g','e','/','x','-','p','n','g',0};
+++static const WCHAR mimeImageTiff[] = {'i','m','a','g','e','/','t','i','f','f',0};
+++static const WCHAR mimeVideoAvi[] = {'v','i','d','e','o','/','a','v','i',0};
+++static const WCHAR mimeVideoMpeg[] = {'v','i','d','e','o','/','m','p','e','g',0};
+++static const WCHAR mimeAppPostscript[] =
+++ {'a','p','p','l','i','c','a','t','i','o','n','/','p','o','s','t','s','c','r','i','p','t',0};
+++static const WCHAR mimeAppXCompressed[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
+++ 'x','-','c','o','m','p','r','e','s','s','e','d',0};
+++static const WCHAR mimeAppXZip[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
+++ 'x','-','z','i','p','-','c','o','m','p','r','e','s','s','e','d',0};
+++static const WCHAR mimeAppXGzip[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
+++ 'x','-','g','z','i','p','-','c','o','m','p','r','e','s','s','e','d',0};
+++static const WCHAR mimeAppJava[] = {'a','p','p','l','i','c','a','t','i','o','n','/','j','a','v','a',0};
+++static const WCHAR mimeAppPdf[] = {'a','p','p','l','i','c','a','t','i','o','n','/','p','d','f',0};
+++static const WCHAR mimeAppXMSDownload[] =
+++ {'a','p','p','l','i','c','a','t','i','o','n','/','x','-','m','s','d','o','w','n','l','o','a','d',0};
+++static const WCHAR mimeAudioWav[] = {'a','u','d','i','o','/','w','a','v',0};
+++static const WCHAR mimeAudioBasic[] = {'a','u','d','i','o','/','b','a','s','i','c',0};
+++
+++static const struct {
+++ LPCWSTR url;
+++ LPCWSTR mime;
+++ HRESULT hres;
+++} mime_tests[] = {
+++ {url1, mimeTextHtml, S_OK},
+++ {url2, mimeTextHtml, S_OK},
+++ {url3, mimeTextHtml, S_OK},
+++ {url4, NULL, E_FAIL},
+++ {url5, NULL, __HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)},
+++ {url6, NULL, E_FAIL},
+++ {url7, NULL, __HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)}
+++};
+++
+++static BYTE data1[] = "test data\n";
+++static BYTE data2[] = {31,'t','e','s',0xfa,'t',' ','d','a','t','a','\n',0};
+++static BYTE data3[] = {0,0,0};
+++static BYTE data4[] = {'t','e','s',0xfa,'t',' ','d','a','t','a','\n',0,0};
+++static BYTE data5[] = {0xa,0xa,0xa,'x',32,'x',0};
+++static BYTE data6[] = {0xfa,0xfa,0xfa,0xfa,'\n','\r','\t','x','x','x',1};
+++static BYTE data7[] = "<html>blahblah";
+++static BYTE data8[] = {'t','e','s',0xfa,'t',' ','<','h','t','m','l','>','d','a','t','a','\n',0,0};
+++static BYTE data9[] = {'t','e',0,'s',0xfa,'t',' ','<','h','t','m','l','>','d','a','t','a','\n',0,0};
+++static BYTE data10[] = "<HtmL>blahblah";
+++static BYTE data11[] = "blah<HTML>blahblah";
+++static BYTE data12[] = "blah<HTMLblahblah";
+++static BYTE data13[] = "blahHTML>blahblah";
+++static BYTE data14[] = "blah<HTMblahblah";
+++static BYTE data15[] = {0xff,0xd8};
+++static BYTE data16[] = {0xff,0xd8,'h'};
+++static BYTE data17[] = {0,0xff,0xd8};
+++static BYTE data18[] = {0xff,0xd8,'<','h','t','m','l','>'};
+++static BYTE data19[] = {'G','I','F','8','7','a'};
+++static BYTE data20[] = {'G','I','F','8','9','a'};
+++static BYTE data21[] = {'G','I','F','8','7'};
+++static BYTE data22[] = {'G','i','F','8','7','a'};
+++static BYTE data23[] = {'G','i','F','8','8','a'};
+++static BYTE data24[] = {'g','i','f','8','7','a'};
+++static BYTE data25[] = {'G','i','F','8','7','A'};
+++static BYTE data26[] = {'G','i','F','8','7','a','<','h','t','m','l','>'};
+++static BYTE data27[] = {0x30,'G','i','F','8','7','A'};
+++static BYTE data28[] = {0x42,0x4d,0x6e,0x42,0x1c,0x00,0x00,0x00,0x00,0x00,0x36,0x00,0x00,0x00};
+++static BYTE data29[] = {0x42,0x4d,'x','x','x','x',0x00,0x00,0x00,0x00,'x','x','x','x'};
+++static BYTE data30[] = {0x42,0x4d,'x','x','x','x',0x00,0x01,0x00,0x00,'x','x','x','x'};
+++static BYTE data31[] = {0x42,0x4d,'x','x','x','x',0x00,0x00,0x00,0x00,'<','h','t','m','l','>'};
+++static BYTE data32[] = {0x42,0x4d,'x','x','x','x',0x00,0x00,0x00,0x00,'x','x','x'};
+++static BYTE data33[] = {0x00,0x42,0x4d,'x','x','x','x',0x00,0x00,0x00,0x00,'x','x','x'};
+++static BYTE data34[] = {0x89,'P','N','G',0x0d,0x0a,0x1a,0x0a,'x'};
+++static BYTE data35[] = {0x89,'P','N','G',0x0d,0x0a,0x1a,0x0a,'x','x','x','x',0};
+++static BYTE data36[] = {0x89,'P','N','G',0x0d,0x0a,0x1a,'x','x'};
+++static BYTE data37[] = {0x89,'P','N','G',0x0d,0x0a,0x1a,0x0a,'<','h','t','m','l','>'};
+++static BYTE data38[] = {0x00,0x89,'P','N','G',0x0d,0x0a,0x1a,0x0a,'x'};
+++static BYTE data39[] = {0x4d,0x4d,0x00,0x2a};
+++static BYTE data40[] = {0x4d,0x4d,0x00,0x2a,'<','h','t','m','l','>',0};
+++static BYTE data41[] = {0x4d,0x4d,0xff};
+++static BYTE data42[] = {0x4d,0x4d};
+++static BYTE data43[] = {0x00,0x4d,0x4d,0x00};
+++static BYTE data44[] = {'R','I','F','F',0xff,0xff,0xff,0xff,'A','V','I',0x20,0xff};
+++static BYTE data45[] = {'R','I','F','f',0xff,0xff,0xff,0xff,'A','V','I',0x20,0xff};
+++static BYTE data46[] = {'R','I','F','F',0xff,0xff,0xff,0xff,'A','V','I',0x20};
+++static BYTE data47[] = {'R','I','F','F',0xff,0xff,0xff,0xff,'A','V','I',0x21,0xff};
+++static BYTE data48[] = {'R','I','F','F',0xff,0xff,0xff,0xff,'A','V','I',0x20,'<','h','t','m','l','>'};
+++static BYTE data49[] = {'R','I','F','F',0x0f,0x0f,0xf0,0xf0,'A','V','I',0x20,0xf0,0x00};
+++static BYTE data50[] = {0x00,0x00,0x01,0xb3,0xff};
+++static BYTE data51[] = {0x00,0x00,0x01,0xba,0xff};
+++static BYTE data52[] = {0x00,0x00,0x01,0xb8,0xff};
+++static BYTE data53[] = {0x00,0x00,0x01,0xba};
+++static BYTE data54[] = {0x00,0x00,0x01,0xba,'<','h','t','m','l','>'};
+++static BYTE data55[] = {0x1f,0x8b,'x'};
+++static BYTE data56[] = {0x1f};
+++static BYTE data57[] = {0x1f,0x8b,'<','h','t','m','l','>','t','e','s','t',0};
+++static BYTE data58[] = {0x1f,0x8b};
+++static BYTE data59[] = {0x50,0x4b,'x'};
+++static BYTE data60[] = {0x50,0x4b};
+++static BYTE data61[] = {0x50,0x4b,'<','h','t','m','l','>',0};
+++static BYTE data62[] = {0xca,0xfe,0xba,0xbe,'x'};
+++static BYTE data63[] = {0xca,0xfe,0xba,0xbe};
+++static BYTE data64[] = {0xca,0xfe,0xba,0xbe,'<','h','t','m','l','>',0};
+++static BYTE data65[] = {0x25,0x50,0x44,0x46,'x'};
+++static BYTE data66[] = {0x25,0x50,0x44,0x46};
+++static BYTE data67[] = {0x25,0x50,0x44,0x46,'x','<','h','t','m','l','>'};
+++static BYTE data68[] = {'M','Z','x'};
+++static BYTE data69[] = {'M','Z'};
+++static BYTE data70[] = {'M','Z','<','h','t','m','l','>',0xff};
+++static BYTE data71[] = {'{','\\','r','t','f',0};
+++static BYTE data72[] = {'{','\\','r','t','f'};
+++static BYTE data73[] = {' ','{','\\','r','t','f',' '};
+++static BYTE data74[] = {'{','\\','r','t','f','<','h','t','m','l','>',' '};
+++static BYTE data75[] = {'R','I','F','F',0xff,0xff,0xff,0xff,'W','A','V','E',0xff};
+++static BYTE data76[] = {'R','I','F','F',0xff,0xff,0xff,0xff,'W','A','V','E'};
+++static BYTE data77[] = {'R','I','F','F',0xff,0xff,0xff,0xff,'W','A','V',0xff,0xff};
+++static BYTE data78[] = {'R','I','F','F',0xff,0xff,0xff,0xff,'<','h','t','m','l','>',0xff};
+++static BYTE data79[] = {'%','!',0xff};
+++static BYTE data80[] = {'%','!'};
+++static BYTE data81[] = {'%','!','P','S','<','h','t','m','l','>'};
+++static BYTE data82[] = {'.','s','n','d',0};
+++static BYTE data83[] = {'.','s','n','d'};
+++static BYTE data84[] = {'.','s','n','d',0,'<','h','t','m','l','>',1,1};
+++static BYTE data85[] = {'.','S','N','D',0};
+++
+++static const struct {
+++ BYTE *data;
+++ DWORD size;
+++ LPCWSTR mime, mime_alt;
+++} mime_tests2[] = {
+++ {data1, sizeof(data1), mimeTextPlain},
+++ {data2, sizeof(data2), mimeAppOctetStream},
+++ {data3, sizeof(data3), mimeAppOctetStream},
+++ {data4, sizeof(data4), mimeAppOctetStream},
+++ {data5, sizeof(data5), mimeTextPlain},
+++ {data6, sizeof(data6), mimeTextPlain},
+++ {data7, sizeof(data7), mimeTextHtml, mimeTextPlain /* IE8 */},
+++ {data8, sizeof(data8), mimeTextHtml, mimeTextPlain /* IE8 */},
+++ {data9, sizeof(data9), mimeTextHtml, mimeImagePjpeg /* IE8 */},
+++ {data10, sizeof(data10), mimeTextHtml, mimeTextPlain /* IE8 */},
+++ {data11, sizeof(data11), mimeTextHtml, mimeTextPlain /* IE8 */},
+++ {data12, sizeof(data12), mimeTextHtml, mimeTextPlain /* IE8 */},
+++ {data13, sizeof(data13), mimeTextPlain},
+++ {data14, sizeof(data14), mimeTextPlain},
+++ {data15, sizeof(data15), mimeTextPlain},
+++ {data16, sizeof(data16), mimeImagePjpeg},
+++ {data17, sizeof(data17), mimeAppOctetStream},
+++ {data18, sizeof(data18), mimeTextHtml},
+++ {data19, sizeof(data19), mimeImageGif},
+++ {data20, sizeof(data20), mimeImageGif},
+++ {data21, sizeof(data21), mimeTextPlain},
+++ {data22, sizeof(data22), mimeImageGif},
+++ {data23, sizeof(data23), mimeTextPlain},
+++ {data24, sizeof(data24), mimeImageGif},
+++ {data25, sizeof(data25), mimeImageGif},
+++ {data26, sizeof(data26), mimeTextHtml, mimeImageGif /* IE8 */},
+++ {data27, sizeof(data27), mimeTextPlain},
+++ {data28, sizeof(data28), mimeImageBmp},
+++ {data29, sizeof(data29), mimeImageBmp},
+++ {data30, sizeof(data30), mimeAppOctetStream},
+++ {data31, sizeof(data31), mimeTextHtml, mimeImageBmp /* IE8 */},
+++ {data32, sizeof(data32), mimeAppOctetStream},
+++ {data33, sizeof(data33), mimeAppOctetStream},
+++ {data34, sizeof(data34), mimeImageXPng},
+++ {data35, sizeof(data35), mimeImageXPng},
+++ {data36, sizeof(data36), mimeAppOctetStream},
+++ {data37, sizeof(data37), mimeTextHtml, mimeImageXPng /* IE8 */},
+++ {data38, sizeof(data38), mimeAppOctetStream},
+++ {data39, sizeof(data39), mimeImageTiff},
+++ {data40, sizeof(data40), mimeTextHtml, mimeImageTiff /* IE8 */},
+++ {data41, sizeof(data41), mimeImageTiff},
+++ {data42, sizeof(data42), mimeTextPlain},
+++ {data43, sizeof(data43), mimeAppOctetStream},
+++ {data44, sizeof(data44), mimeVideoAvi},
+++ {data45, sizeof(data45), mimeTextPlain},
+++ {data46, sizeof(data46), mimeTextPlain},
+++ {data47, sizeof(data47), mimeTextPlain},
+++ {data48, sizeof(data48), mimeTextHtml, mimeVideoAvi /* IE8 */},
+++ {data49, sizeof(data49), mimeVideoAvi},
+++ {data50, sizeof(data50), mimeVideoMpeg},
+++ {data51, sizeof(data51), mimeVideoMpeg},
+++ {data52, sizeof(data52), mimeAppOctetStream},
+++ {data53, sizeof(data53), mimeAppOctetStream},
+++ {data54, sizeof(data54), mimeTextHtml, mimeVideoMpeg /* IE8 */},
+++ {data55, sizeof(data55), mimeAppXGzip},
+++ {data56, sizeof(data56), mimeTextPlain},
+++ {data57, sizeof(data57), mimeTextHtml, mimeAppXGzip /* IE8 */},
+++ {data58, sizeof(data58), mimeAppOctetStream},
+++ {data59, sizeof(data59), mimeAppXZip},
+++ {data60, sizeof(data60), mimeTextPlain},
+++ {data61, sizeof(data61), mimeTextHtml, mimeAppXZip /* IE8 */},
+++ {data62, sizeof(data62), mimeAppJava},
+++ {data63, sizeof(data63), mimeTextPlain},
+++ {data64, sizeof(data64), mimeTextHtml, mimeAppJava /* IE8 */},
+++ {data65, sizeof(data65), mimeAppPdf},
+++ {data66, sizeof(data66), mimeTextPlain},
+++ {data67, sizeof(data67), mimeTextHtml, mimeAppPdf /* IE8 */},
+++ {data68, sizeof(data68), mimeAppXMSDownload},
+++ {data69, sizeof(data69), mimeTextPlain},
+++ {data70, sizeof(data70), mimeTextHtml, mimeAppXMSDownload /* IE8 */},
+++ {data71, sizeof(data71), mimeTextRichtext},
+++ {data72, sizeof(data72), mimeTextPlain},
+++ {data73, sizeof(data73), mimeTextPlain},
+++ {data74, sizeof(data74), mimeTextHtml, mimeTextRichtext /* IE8 */},
+++ {data75, sizeof(data75), mimeAudioWav},
+++ {data76, sizeof(data76), mimeTextPlain},
+++ {data77, sizeof(data77), mimeTextPlain},
+++ {data78, sizeof(data78), mimeTextHtml, mimeTextPlain /* IE8 */},
+++ {data79, sizeof(data79), mimeAppPostscript},
+++ {data80, sizeof(data80), mimeTextPlain},
+++ {data81, sizeof(data81), mimeTextHtml, mimeAppPostscript /* IE8 */},
+++ {data82, sizeof(data82), mimeAudioBasic},
+++ {data83, sizeof(data83), mimeTextPlain},
+++ {data84, sizeof(data84), mimeTextHtml, mimeAudioBasic /* IE8 */},
+++ {data85, sizeof(data85), mimeTextPlain}
+++};
+++
+++static void test_FindMimeFromData(void)
+++{
+++ HRESULT hres;
+++ LPWSTR mime;
+++ int i;
+++
- if (!pCoInternetGetSession) {
- return;
- }
-
+++ for(i=0; i<sizeof(mime_tests)/sizeof(mime_tests[0]); i++) {
+++ mime = (LPWSTR)0xf0f0f0f0;
+++ hres = pFindMimeFromData(NULL, mime_tests[i].url, NULL, 0, NULL, 0, &mime, 0);
+++ if(mime_tests[i].mime) {
+++ ok(hres == S_OK, "[%d] FindMimeFromData failed: %08x\n", i, hres);
+++ ok(!lstrcmpW(mime, mime_tests[i].mime), "[%d] wrong mime\n", i);
+++ CoTaskMemFree(mime);
+++ }else {
+++ ok(hres == E_FAIL || hres == mime_tests[i].hres,
+++ "[%d] FindMimeFromData failed: %08x, expected %08x\n",
+++ i, hres, mime_tests[i].hres);
+++ ok(mime == (LPWSTR)0xf0f0f0f0, "[%d] mime != 0xf0f0f0f0\n", i);
+++ }
+++
+++ mime = (LPWSTR)0xf0f0f0f0;
+++ hres = pFindMimeFromData(NULL, mime_tests[i].url, NULL, 0, mimeTextPlain, 0, &mime, 0);
+++ ok(hres == S_OK, "[%d] FindMimeFromData failed: %08x\n", i, hres);
+++ ok(!lstrcmpW(mime, mimeTextPlain), "[%d] wrong mime\n", i);
+++ CoTaskMemFree(mime);
+++
+++ mime = (LPWSTR)0xf0f0f0f0;
+++ hres = pFindMimeFromData(NULL, mime_tests[i].url, NULL, 0, mimeAppOctetStream, 0, &mime, 0);
+++ ok(hres == S_OK, "[%d] FindMimeFromData failed: %08x\n", i, hres);
+++ ok(!lstrcmpW(mime, mimeAppOctetStream), "[%d] wrong mime\n", i);
+++ CoTaskMemFree(mime);
+++ }
+++
+++ for(i=0; i < sizeof(mime_tests2)/sizeof(mime_tests2[0]); i++) {
+++ hres = pFindMimeFromData(NULL, NULL, mime_tests2[i].data, mime_tests2[i].size,
+++ NULL, 0, &mime, 0);
+++ ok(hres == S_OK, "[%d] FindMimeFromData failed: %08x\n", i, hres);
+++ ok(!lstrcmpW(mime, mime_tests2[i].mime), "[%d] wrong mime: %s\n", i, wine_dbgstr_w(mime));
+++ CoTaskMemFree(mime);
+++
+++ hres = pFindMimeFromData(NULL, NULL, mime_tests2[i].data, mime_tests2[i].size,
+++ mimeTextHtml, 0, &mime, 0);
+++ ok(hres == S_OK, "[%d] FindMimeFromData failed: %08x\n", i, hres);
+++ if(!lstrcmpW(mimeAppOctetStream, mime_tests2[i].mime)
+++ || !lstrcmpW(mimeTextPlain, mime_tests2[i].mime))
+++ ok(!lstrcmpW(mime, mimeTextHtml), "[%d] wrong mime\n", i);
+++ else
+++ ok(!lstrcmpW(mime, mime_tests2[i].mime), "[%d] wrong mime\n", i);
+++ CoTaskMemFree(mime);
+++
+++ hres = pFindMimeFromData(NULL, NULL, mime_tests2[i].data, mime_tests2[i].size,
+++ mimeImagePjpeg, 0, &mime, 0);
+++ ok(hres == S_OK, "[%d] FindMimeFromData failed: %08x\n", i, hres);
+++ if(!lstrcmpW(mimeAppOctetStream, mime_tests2[i].mime) || i == 17)
+++ ok(!lstrcmpW(mime, mimeImagePjpeg), "[%d] wrong mime\n", i);
+++ else
+++ ok(!lstrcmpW(mime, mime_tests2[i].mime) ||
+++ (mime_tests2[i].mime_alt && !lstrcmpW(mime, mime_tests2[i].mime_alt)),
+++ "[%d] wrong mime, got %s\n", i, wine_dbgstr_w(mime));
+++
+++ CoTaskMemFree(mime);
+++ }
+++
+++ hres = pFindMimeFromData(NULL, url1, data1, sizeof(data1), NULL, 0, &mime, 0);
+++ ok(hres == S_OK, "FindMimeFromData failed: %08x\n", hres);
+++ ok(!lstrcmpW(mime, mimeTextPlain), "wrong mime\n");
+++ CoTaskMemFree(mime);
+++
+++ hres = pFindMimeFromData(NULL, url1, data1, sizeof(data1), mimeAppOctetStream, 0, &mime, 0);
+++ ok(hres == S_OK, "FindMimeFromData failed: %08x\n", hres);
+++ ok(!lstrcmpW(mime, mimeTextPlain), "wrong mime\n");
+++ CoTaskMemFree(mime);
+++
+++ hres = pFindMimeFromData(NULL, url4, data1, sizeof(data1), mimeAppOctetStream, 0, &mime, 0);
+++ ok(hres == S_OK, "FindMimeFromData failed: %08x\n", hres);
+++ ok(!lstrcmpW(mime, mimeTextPlain), "wrong mime\n");
+++ CoTaskMemFree(mime);
+++
+++ hres = pFindMimeFromData(NULL, NULL, NULL, 0, NULL, 0, &mime, 0);
+++ ok(hres == E_INVALIDARG, "FindMimeFromData failed: %08x, excepted E_INVALIDARG\n", hres);
+++
+++ hres = pFindMimeFromData(NULL, NULL, NULL, 0, mimeTextPlain, 0, &mime, 0);
+++ ok(hres == E_INVALIDARG, "FindMimeFromData failed: %08x, expected E_INVALIDARG\n", hres);
+++
+++ hres = pFindMimeFromData(NULL, NULL, data1, 0, NULL, 0, &mime, 0);
+++ ok(hres == E_FAIL, "FindMimeFromData failed: %08x, expected E_FAIL\n", hres);
+++
+++ hres = pFindMimeFromData(NULL, url1, data1, 0, NULL, 0, &mime, 0);
+++ ok(hres == E_FAIL, "FindMimeFromData failed: %08x, expected E_FAIL\n", hres);
+++
+++ hres = pFindMimeFromData(NULL, NULL, data1, 0, mimeTextPlain, 0, &mime, 0);
+++ ok(hres == S_OK, "FindMimeFromData failed: %08x\n", hres);
+++ ok(!lstrcmpW(mime, mimeTextPlain), "wrong mime\n");
+++ CoTaskMemFree(mime);
+++
+++ hres = pFindMimeFromData(NULL, NULL, data1, 0, mimeTextPlain, 0, NULL, 0);
+++ ok(hres == E_INVALIDARG, "FindMimeFromData failed: %08x, expected E_INVALIDARG\n", hres);
+++}
+++
+++static void register_protocols(void)
+++{
+++ IInternetSession *session;
+++ IClassFactory *factory;
+++ HRESULT hres;
+++
+++ static const WCHAR wszAbout[] = {'a','b','o','u','t',0};
+++
- if (!pCoInternetGetSession || !pCoInternetParseUrl) {
- return;
- }
-
+++ hres = pCoInternetGetSession(0, &session, 0);
+++ ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = CoGetClassObject(&CLSID_AboutProtocol, CLSCTX_INPROC_SERVER, NULL,
+++ &IID_IClassFactory, (void**)&factory);
+++ ok(hres == S_OK, "Coud not get AboutProtocol factory: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ IInternetSession_RegisterNameSpace(session, factory, &CLSID_AboutProtocol,
+++ wszAbout, 0, NULL, 0);
+++ IClassFactory_Release(factory);
+++
+++ IInternetSession_Release(session);
+++}
+++
+++static HRESULT WINAPI InternetProtocolInfo_QueryInterface(IInternetProtocolInfo *iface,
+++ REFIID riid, void **ppv)
+++{
+++ ok(0, "unexpected call\n");
+++ return E_NOINTERFACE;
+++}
+++
+++static ULONG WINAPI InternetProtocolInfo_AddRef(IInternetProtocolInfo *iface)
+++{
+++ return 2;
+++}
+++
+++static ULONG WINAPI InternetProtocolInfo_Release(IInternetProtocolInfo *iface)
+++{
+++ return 1;
+++}
+++
+++static HRESULT WINAPI InternetProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
+++ PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
+++ DWORD *pcchResult, DWORD dwReserved)
+++{
+++ CHECK_EXPECT2(ParseUrl);
+++
+++ if(ParseAction == PARSE_SECURITY_URL) {
+++ if(pcchResult)
+++ *pcchResult = sizeof(url1)/sizeof(WCHAR);
+++
+++ if(cchResult<sizeof(url1)/sizeof(WCHAR))
+++ return S_FALSE;
+++
+++ memcpy(pwzResult, url1, sizeof(url1));
+++ return S_OK;
+++ }
+++
+++ return E_NOTIMPL;
+++}
+++
+++static HRESULT WINAPI InternetProtocolInfo_CombineUrl(IInternetProtocolInfo *iface,
+++ LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags,
+++ LPWSTR pwzResult, DWORD cchResult, DWORD *pcchResult, DWORD dwReserved)
+++{
+++ ok(0, "unexpected call\n");
+++ return E_NOTIMPL;
+++}
+++
+++static HRESULT WINAPI InternetProtocolInfo_CompareUrl(IInternetProtocolInfo *iface,
+++ LPCWSTR pwzUrl1, LPCWSTR pwzUrl2, DWORD dwCompareFlags)
+++{
+++ ok(0, "unexpected call\n");
+++ return E_NOTIMPL;
+++}
+++
+++static HRESULT WINAPI InternetProtocolInfo_QueryInfo(IInternetProtocolInfo *iface,
+++ LPCWSTR pwzUrl, QUERYOPTION OueryOption, DWORD dwQueryFlags, LPVOID pBuffer,
+++ DWORD cbBuffer, DWORD *pcbBuf, DWORD dwReserved)
+++{
+++ ok(0, "unexpected call\n");
+++ return E_NOTIMPL;
+++}
+++
+++static const IInternetProtocolInfoVtbl InternetProtocolInfoVtbl = {
+++ InternetProtocolInfo_QueryInterface,
+++ InternetProtocolInfo_AddRef,
+++ InternetProtocolInfo_Release,
+++ InternetProtocolInfo_ParseUrl,
+++ InternetProtocolInfo_CombineUrl,
+++ InternetProtocolInfo_CompareUrl,
+++ InternetProtocolInfo_QueryInfo
+++};
+++
+++static IInternetProtocolInfo protocol_info = { &InternetProtocolInfoVtbl };
+++
+++static HRESULT qiret;
+++static IClassFactory *expect_cf;
+++
+++static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
+++{
+++ if(IsEqualGUID(&IID_IInternetProtocolInfo, riid)) {
+++ CHECK_EXPECT2(QI_IInternetProtocolInfo);
+++ ok(iface == expect_cf, "unexpected iface\n");
+++ *ppv = &protocol_info;
+++ return qiret;
+++ }
+++
+++ ok(0, "unexpected call\n");
+++ return E_NOINTERFACE;
+++}
+++
+++static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
+++{
+++ return 2;
+++}
+++
+++static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
+++{
+++ return 1;
+++}
+++
+++static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
+++ REFIID riid, void **ppv)
+++{
+++ ok(0, "unexpected call\n");
+++ return E_NOTIMPL;
+++}
+++
+++static HRESULT WINAPI ProtocolCF_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
+++ REFIID riid, void **ppv)
+++{
+++ CHECK_EXPECT(CreateInstance);
+++
+++ ok(iface == expect_cf, "unexpected iface\n");
+++ ok(pOuter == NULL, "pOuter = %p\n", pOuter);
+++ ok(IsEqualGUID(&IID_IInternetProtocolInfo, riid), "unexpected riid\n");
+++ ok(ppv != NULL, "ppv == NULL\n");
+++
+++ *ppv = &protocol_info;
+++ return S_OK;
+++}
+++
+++static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
+++{
+++ ok(0, "unexpected call\n");
+++ return S_OK;
+++}
+++
+++static const IClassFactoryVtbl ClassFactoryVtbl = {
+++ ClassFactory_QueryInterface,
+++ ClassFactory_AddRef,
+++ ClassFactory_Release,
+++ ClassFactory_CreateInstance,
+++ ClassFactory_LockServer
+++};
+++
+++static const IClassFactoryVtbl ProtocolCFVtbl = {
+++ ClassFactory_QueryInterface,
+++ ClassFactory_AddRef,
+++ ClassFactory_Release,
+++ ProtocolCF_CreateInstance,
+++ ClassFactory_LockServer
+++};
+++
+++static IClassFactory test_protocol_cf = { &ProtocolCFVtbl };
+++static IClassFactory test_protocol_cf2 = { &ProtocolCFVtbl };
+++static IClassFactory test_cf = { &ClassFactoryVtbl };
+++
+++static void test_NameSpace(void)
+++{
+++ IInternetSession *session;
+++ WCHAR buf[200];
+++ LPWSTR sec_url;
+++ DWORD size;
+++ HRESULT hres;
+++
+++ static const WCHAR wszTest[] = {'t','e','s','t',0};
+++
- if (!pCoInternetGetSession) {
- return;
- }
-
+++ hres = pCoInternetGetSession(0, &session, 0);
+++ ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = IInternetSession_RegisterNameSpace(session, NULL, &IID_NULL,
+++ wszTest, 0, NULL, 0);
+++ ok(hres == E_INVALIDARG, "RegisterNameSpace failed: %08x\n", hres);
+++
+++ hres = IInternetSession_RegisterNameSpace(session, &test_protocol_cf, &IID_NULL,
+++ NULL, 0, NULL, 0);
+++ ok(hres == E_INVALIDARG, "RegisterNameSpace failed: %08x\n", hres);
+++
+++ hres = IInternetSession_RegisterNameSpace(session, &test_protocol_cf, &IID_NULL,
+++ wszTest, 0, NULL, 0);
+++ ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
+++
+++ qiret = E_NOINTERFACE;
+++ expect_cf = &test_protocol_cf;
+++ SET_EXPECT(QI_IInternetProtocolInfo);
+++ SET_EXPECT(CreateInstance);
+++ SET_EXPECT(ParseUrl);
+++
+++ hres = pCoInternetParseUrl(url8, PARSE_ENCODE, 0, buf, sizeof(buf)/sizeof(WCHAR),
+++ &size, 0);
+++ ok(hres == S_OK, "CoInternetParseUrl failed: %08x\n", hres);
+++
+++ CHECK_CALLED(QI_IInternetProtocolInfo);
+++ CHECK_CALLED(CreateInstance);
+++ CHECK_CALLED(ParseUrl);
+++
+++ qiret = S_OK;
+++ SET_EXPECT(QI_IInternetProtocolInfo);
+++ SET_EXPECT(ParseUrl);
+++
+++ hres = pCoInternetParseUrl(url8, PARSE_ENCODE, 0, buf, sizeof(buf)/sizeof(WCHAR),
+++ &size, 0);
+++ ok(hres == S_OK, "CoInternetParseUrl failed: %08x\n", hres);
+++
+++ CHECK_CALLED(QI_IInternetProtocolInfo);
+++ CHECK_CALLED(ParseUrl);
+++
+++ SET_EXPECT(QI_IInternetProtocolInfo);
+++ SET_EXPECT(ParseUrl);
+++
+++ hres = pCoInternetParseUrl(url8, PARSE_SECURITY_URL, 0, buf,
+++ sizeof(buf)/sizeof(WCHAR), &size, 0);
+++ ok(hres == S_OK, "CoInternetParseUrl failed: %08x\n", hres);
+++ ok(size == sizeof(url1)/sizeof(WCHAR), "Size = %d\n", size);
+++ if(size == sizeof(url1)/sizeof(WCHAR))
+++ ok(!memcmp(buf, url1, sizeof(url1)), "Encoded url = %s\n", wine_dbgstr_w(buf));
+++
+++ CHECK_CALLED(QI_IInternetProtocolInfo);
+++ CHECK_CALLED(ParseUrl);
+++
+++ SET_EXPECT(QI_IInternetProtocolInfo);
+++ SET_EXPECT(ParseUrl);
+++
+++ if (pCoInternetGetSecurityUrl) {
+++ hres = pCoInternetGetSecurityUrl(url8, &sec_url, PSU_SECURITY_URL_ONLY, 0);
+++ ok(hres == S_OK, "CoInternetGetSecurityUrl failed: %08x\n", hres);
+++ if(hres == S_OK) {
+++ ok(lstrlenW(sec_url)>sizeof(wszFile)/sizeof(WCHAR) &&
+++ !memcmp(sec_url, wszFile, sizeof(wszFile)-sizeof(WCHAR)),
+++ "Encoded url = %s\n", wine_dbgstr_w(sec_url));
+++ CoTaskMemFree(sec_url);
+++ }
+++
+++ CHECK_CALLED(QI_IInternetProtocolInfo);
+++ CHECK_CALLED(ParseUrl);
+++ }
+++
+++ hres = IInternetSession_UnregisterNameSpace(session, &test_protocol_cf, wszTest);
+++ ok(hres == S_OK, "UnregisterNameSpace failed: %08x\n", hres);
+++
+++ hres = pCoInternetParseUrl(url8, PARSE_ENCODE, 0, buf, sizeof(buf)/sizeof(WCHAR),
+++ &size, 0);
+++ ok(hres == S_OK, "CoInternetParseUrl failed: %08x\n", hres);
+++
+++ hres = IInternetSession_RegisterNameSpace(session, &test_protocol_cf2, &IID_NULL,
+++ wszTest, 0, NULL, 0);
+++ ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
+++
+++ hres = IInternetSession_RegisterNameSpace(session, &test_protocol_cf, &IID_NULL,
+++ wszTest, 0, NULL, 0);
+++ ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
+++
+++ hres = IInternetSession_RegisterNameSpace(session, &test_protocol_cf, &IID_NULL,
+++ wszTest, 0, NULL, 0);
+++ ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
+++
+++ SET_EXPECT(QI_IInternetProtocolInfo);
+++ SET_EXPECT(ParseUrl);
+++
+++ hres = pCoInternetParseUrl(url8, PARSE_ENCODE, 0, buf, sizeof(buf)/sizeof(WCHAR),
+++ &size, 0);
+++ ok(hres == S_OK, "CoInternetParseUrl failed: %08x\n", hres);
+++
+++ CHECK_CALLED(QI_IInternetProtocolInfo);
+++ CHECK_CALLED(ParseUrl);
+++
+++ hres = IInternetSession_UnregisterNameSpace(session, &test_protocol_cf, wszTest);
+++ ok(hres == S_OK, "UnregisterNameSpace failed: %08x\n", hres);
+++
+++ SET_EXPECT(QI_IInternetProtocolInfo);
+++ SET_EXPECT(ParseUrl);
+++
+++ hres = pCoInternetParseUrl(url8, PARSE_ENCODE, 0, buf, sizeof(buf)/sizeof(WCHAR),
+++ &size, 0);
+++ ok(hres == S_OK, "CoInternetParseUrl failed: %08x\n", hres);
+++
+++ CHECK_CALLED(QI_IInternetProtocolInfo);
+++ CHECK_CALLED(ParseUrl);
+++
+++ hres = IInternetSession_UnregisterNameSpace(session, &test_protocol_cf, wszTest);
+++ ok(hres == S_OK, "UnregisterNameSpace failed: %08x\n", hres);
+++
+++ expect_cf = &test_protocol_cf2;
+++ SET_EXPECT(QI_IInternetProtocolInfo);
+++ SET_EXPECT(ParseUrl);
+++
+++ hres = pCoInternetParseUrl(url8, PARSE_ENCODE, 0, buf, sizeof(buf)/sizeof(WCHAR),
+++ &size, 0);
+++ ok(hres == S_OK, "CoInternetParseUrl failed: %08x\n", hres);
+++
+++ CHECK_CALLED(QI_IInternetProtocolInfo);
+++ CHECK_CALLED(ParseUrl);
+++
+++ hres = IInternetSession_UnregisterNameSpace(session, &test_protocol_cf, wszTest);
+++ ok(hres == S_OK, "UnregisterNameSpace failed: %08x\n", hres);
+++ hres = IInternetSession_UnregisterNameSpace(session, &test_protocol_cf, wszTest);
+++ ok(hres == S_OK, "UnregisterNameSpace failed: %08x\n", hres);
+++ hres = IInternetSession_UnregisterNameSpace(session, &test_protocol_cf, NULL);
+++ ok(hres == E_INVALIDARG, "UnregisterNameSpace failed: %08x\n", hres);
+++ hres = IInternetSession_UnregisterNameSpace(session, NULL, wszTest);
+++ ok(hres == E_INVALIDARG, "UnregisterNameSpace failed: %08x\n", hres);
+++
+++ hres = IInternetSession_UnregisterNameSpace(session, &test_protocol_cf2, wszTest);
+++ ok(hres == S_OK, "UnregisterNameSpace failed: %08x\n", hres);
+++
+++ hres = pCoInternetParseUrl(url8, PARSE_ENCODE, 0, buf, sizeof(buf)/sizeof(WCHAR),
+++ &size, 0);
+++ ok(hres == S_OK, "CoInternetParseUrl failed: %08x\n", hres);
+++
+++ IInternetSession_Release(session);
+++}
+++
+++static void test_MimeFilter(void)
+++{
+++ IInternetSession *session;
+++ HRESULT hres;
+++
+++ static const WCHAR mimeW[] = {'t','e','s','t','/','m','i','m','e',0};
+++
- if (!pReleaseBindInfo) {
- return;
- }
-
+++ hres = pCoInternetGetSession(0, &session, 0);
+++ ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = IInternetSession_RegisterMimeFilter(session, &test_cf, &IID_NULL, mimeW);
+++ ok(hres == S_OK, "RegisterMimeFilter failed: %08x\n", hres);
+++
+++ hres = IInternetSession_UnregisterMimeFilter(session, &test_cf, mimeW);
+++ ok(hres == S_OK, "UnregisterMimeFilter failed: %08x\n", hres);
+++
+++ hres = IInternetSession_UnregisterMimeFilter(session, &test_cf, mimeW);
+++ ok(hres == S_OK, "UnregisterMimeFilter failed: %08x\n", hres);
+++
+++ hres = IInternetSession_UnregisterMimeFilter(session, (void*)0xdeadbeef, mimeW);
+++ ok(hres == S_OK, "UnregisterMimeFilter failed: %08x\n", hres);
+++
+++ IInternetSession_Release(session);
+++}
+++
+++static ULONG WINAPI unk_Release(IUnknown *iface)
+++{
+++ CHECK_EXPECT(unk_Release);
+++ return 0;
+++}
+++
+++static const IUnknownVtbl unk_vtbl = {
+++ (void*)0xdeadbeef,
+++ (void*)0xdeadbeef,
+++ unk_Release
+++};
+++
+++static void test_ReleaseBindInfo(void)
+++{
+++ BINDINFO bi;
+++ IUnknown unk = { &unk_vtbl };
+++
- if (!pCopyStgMedium) {
- return;
- }
-
-
+++ pReleaseBindInfo(NULL); /* shouldn't crash */
+++
+++ memset(&bi, 0, sizeof(bi));
+++ bi.cbSize = sizeof(BINDINFO);
+++ bi.pUnk = &unk;
+++ SET_EXPECT(unk_Release);
+++ pReleaseBindInfo(&bi);
+++ ok(bi.cbSize == sizeof(BINDINFO), "bi.cbSize=%d\n", bi.cbSize);
+++ ok(bi.pUnk == NULL, "bi.pUnk=%p, expected NULL\n", bi.pUnk);
+++ CHECK_CALLED(unk_Release);
+++
+++ memset(&bi, 0, sizeof(bi));
+++ bi.cbSize = offsetof(BINDINFO, pUnk);
+++ bi.pUnk = &unk;
+++ pReleaseBindInfo(&bi);
+++ ok(bi.cbSize == offsetof(BINDINFO, pUnk), "bi.cbSize=%d\n", bi.cbSize);
+++ ok(bi.pUnk == &unk, "bi.pUnk=%p, expected %p\n", bi.pUnk, &unk);
+++
+++ memset(&bi, 0, sizeof(bi));
+++ bi.pUnk = &unk;
+++ pReleaseBindInfo(&bi);
+++ ok(!bi.cbSize, "bi.cbSize=%d, expected 0\n", bi.cbSize);
+++ ok(bi.pUnk == &unk, "bi.pUnk=%p, expected %p\n", bi.pUnk, &unk);
+++}
+++
+++static void test_CopyStgMedium(void)
+++{
+++ STGMEDIUM src, dst;
+++ HGLOBAL empty;
+++ HRESULT hres;
+++
+++ static WCHAR fileW[] = {'f','i','l','e',0};
+++
-
- if (!pUrlMkGetSessionOption) {
- return;
- }
-
+++ memset(&src, 0xf0, sizeof(src));
+++ memset(&dst, 0xe0, sizeof(dst));
+++ memset(&empty, 0xf0, sizeof(empty));
+++ src.tymed = TYMED_NULL;
+++ src.pUnkForRelease = NULL;
+++ hres = pCopyStgMedium(&src, &dst);
+++ ok(hres == S_OK, "CopyStgMedium failed: %08x\n", hres);
+++ ok(dst.tymed == TYMED_NULL, "tymed=%d\n", dst.tymed);
+++ ok(dst.u.hGlobal == empty, "u=%p\n", dst.u.hGlobal);
+++ ok(!dst.pUnkForRelease, "pUnkForRelease=%p, expected NULL\n", dst.pUnkForRelease);
+++
+++ memset(&dst, 0xe0, sizeof(dst));
+++ src.tymed = TYMED_ISTREAM;
+++ src.u.pstm = NULL;
+++ src.pUnkForRelease = NULL;
+++ hres = pCopyStgMedium(&src, &dst);
+++ ok(hres == S_OK, "CopyStgMedium failed: %08x\n", hres);
+++ ok(dst.tymed == TYMED_ISTREAM, "tymed=%d\n", dst.tymed);
+++ ok(!dst.u.pstm, "pstm=%p\n", dst.u.pstm);
+++ ok(!dst.pUnkForRelease, "pUnkForRelease=%p, expected NULL\n", dst.pUnkForRelease);
+++
+++ memset(&dst, 0xe0, sizeof(dst));
+++ src.tymed = TYMED_FILE;
+++ src.u.lpszFileName = fileW;
+++ src.pUnkForRelease = NULL;
+++ hres = pCopyStgMedium(&src, &dst);
+++ ok(hres == S_OK, "CopyStgMedium failed: %08x\n", hres);
+++ ok(dst.tymed == TYMED_FILE, "tymed=%d\n", dst.tymed);
+++ ok(dst.u.lpszFileName && dst.u.lpszFileName != fileW, "lpszFileName=%p\n", dst.u.lpszFileName);
+++ ok(!lstrcmpW(dst.u.lpszFileName, fileW), "wrong file name\n");
+++ ok(!dst.pUnkForRelease, "pUnkForRelease=%p, expected NULL\n", dst.pUnkForRelease);
++++ ReleaseStgMedium(&dst);
+++
+++ hres = pCopyStgMedium(&src, NULL);
+++ ok(hres == E_POINTER, "CopyStgMedium failed: %08x, expected E_POINTER\n", hres);
+++ hres = pCopyStgMedium(NULL, &dst);
+++ ok(hres == E_POINTER, "CopyStgMedium failed: %08x, expected E_POINTER\n", hres);
+++}
+++
+++static void test_UrlMkGetSessionOption(void)
+++{
+++ DWORD encoding, size;
+++ HRESULT hres;
+++
- if (!pObtainUserAgentString || !pUrlMkGetSessionOption) {
- return;
- }
-
+++ size = encoding = 0xdeadbeef;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_URL_ENCODING, &encoding,
+++ sizeof(encoding), &size, 0);
+++ ok(hres == S_OK, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(encoding != 0xdeadbeef, "encoding not changed\n");
+++ ok(size == sizeof(encoding), "size=%d\n", size);
+++
+++ size = encoding = 0xdeadbeef;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_URL_ENCODING, &encoding,
+++ sizeof(encoding)+1, &size, 0);
+++ ok(hres == S_OK, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(encoding != 0xdeadbeef, "encoding not changed\n");
+++ ok(size == sizeof(encoding), "size=%d\n", size);
+++
+++ size = encoding = 0xdeadbeef;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_URL_ENCODING, &encoding,
+++ sizeof(encoding)-1, &size, 0);
+++ ok(hres == E_INVALIDARG, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(encoding == 0xdeadbeef, "encoding = %08x, exepcted 0xdeadbeef\n", encoding);
+++ ok(size == 0xdeadbeef, "size=%d\n", size);
+++
+++ size = encoding = 0xdeadbeef;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_URL_ENCODING, NULL,
+++ sizeof(encoding)-1, &size, 0);
+++ ok(hres == E_INVALIDARG, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(encoding == 0xdeadbeef, "encoding = %08x, exepcted 0xdeadbeef\n", encoding);
+++ ok(size == 0xdeadbeef, "size=%d\n", size);
+++
+++ encoding = 0xdeadbeef;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_URL_ENCODING, &encoding,
+++ sizeof(encoding)-1, NULL, 0);
+++ ok(hres == E_INVALIDARG, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(encoding == 0xdeadbeef, "encoding = %08x, exepcted 0xdeadbeef\n", encoding);
+++}
+++
+++static void test_user_agent(void)
+++{
+++ static const CHAR expected[] = "Mozilla/4.0 (compatible; MSIE ";
+++ static char test_str[] = "test";
+++ static char test2_str[] = "test\0test";
+++ static CHAR str[3];
+++ LPSTR str2 = NULL;
+++ HRESULT hres;
+++ DWORD size, saved;
+++
- OleInitialize(NULL);
-
+++ hres = pObtainUserAgentString(0, NULL, NULL);
+++ ok(hres == E_INVALIDARG, "ObtainUserAgentString failed: %08x\n", hres);
+++
+++ size = 100;
+++ hres = pObtainUserAgentString(0, NULL, &size);
+++ ok(hres == E_INVALIDARG, "ObtainUserAgentString failed: %08x\n", hres);
+++ ok(size == 100, "size=%d, expected %d\n", size, 100);
+++
+++ size = 0;
+++ hres = pObtainUserAgentString(0, str, &size);
+++ ok(hres == E_OUTOFMEMORY, "ObtainUserAgentString failed: %08x\n", hres);
+++ ok(size > 0, "size=%d, expected non-zero\n", size);
+++
+++ size = 2;
+++ str[0] = 'a';
+++ hres = pObtainUserAgentString(0, str, &size);
+++ ok(hres == E_OUTOFMEMORY, "ObtainUserAgentString failed: %08x\n", hres);
+++ ok(size > 0, "size=%d, expected non-zero\n", size);
+++ ok(str[0] == 'a', "str[0]=%c, expected 'a'\n", str[0]);
+++
+++ size = 0;
+++ hres = pObtainUserAgentString(1, str, &size);
+++ ok(hres == E_OUTOFMEMORY, "ObtainUserAgentString failed: %08x\n", hres);
+++ ok(size > 0, "size=%d, expected non-zero\n", size);
+++
+++ str2 = HeapAlloc(GetProcessHeap(), 0, (size+20)*sizeof(CHAR));
+++ saved = size;
+++ hres = pObtainUserAgentString(0, str2, &size);
+++ ok(hres == S_OK, "ObtainUserAgentString failed: %08x\n", hres);
+++ ok(size == saved, "size=%d, expected %d\n", size, saved);
+++ ok(strlen(expected) <= strlen(str2) &&
+++ !memcmp(expected, str2, strlen(expected)*sizeof(CHAR)),
+++ "user agent was \"%s\", expected to start with \"%s\"\n",
+++ str2, expected);
+++
+++ size = saved+10;
+++ hres = pObtainUserAgentString(0, str2, &size);
+++ ok(hres == S_OK, "ObtainUserAgentString failed: %08x\n", hres);
+++ ok(size == saved, "size=%d, expected %d\n", size, saved);
+++
+++ size = 0;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_USERAGENT, NULL, 0, &size, 0);
+++ ok(hres == E_OUTOFMEMORY, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(size, "size == 0\n");
+++
+++ size = 0xdeadbeef;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_USERAGENT, NULL, 1000, &size, 0);
+++ ok(hres == E_INVALIDARG, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(size, "size == 0\n");
+++
+++ saved = size;
+++ size = 0;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_USERAGENT, str2, saved+10, &size, 0);
+++ ok(hres == E_OUTOFMEMORY, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(size == saved, "size = %d, expected %d\n", size, saved);
+++ ok(sizeof(expected) <= strlen(str2) && !memcmp(expected, str2, sizeof(expected)-1),
+++ "user agent was \"%s\", expected to start with \"%s\"\n",
+++ str2, expected);
+++
+++ size = 0;
+++ str2[0] = 0;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_USERAGENT, str2, saved, &size, 0);
+++ ok(hres == E_OUTOFMEMORY, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(size == saved, "size = %d, expected %d\n", size, saved);
+++ ok(sizeof(expected) <= strlen(str2) && !memcmp(expected, str2, sizeof(expected)-1),
+++ "user agent was \"%s\", expected to start with \"%s\"\n",
+++ str2, expected);
+++
+++ size = saved;
+++ str2[0] = 0;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_USERAGENT, str2, saved-1, &size, 0);
+++ ok(hres == E_OUTOFMEMORY, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(size == saved, "size = %d, expected %d\n", size, saved);
+++ ok(!str2[0], "buf changed\n");
+++
+++ size = saved;
+++ str2[0] = 0;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_USERAGENT, str2, saved, NULL, 0);
+++ ok(hres == E_INVALIDARG, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(!str2[0], "buf changed\n");
+++
+++ hres = UrlMkSetSessionOption(URLMON_OPTION_USERAGENT, test_str, sizeof(test_str), 0);
+++ ok(hres == S_OK, "UrlMkSetSessionOption failed: %08x\n", hres);
+++
+++ size = 0;
+++ str2[0] = 0;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_USERAGENT, str2, saved, &size, 0);
+++ ok(hres == E_OUTOFMEMORY, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(size == sizeof(test_str) && !memcmp(str2, test_str, sizeof(test_str)), "wrong user agent\n");
+++
+++ hres = UrlMkSetSessionOption(URLMON_OPTION_USERAGENT, test2_str, sizeof(test2_str), 0);
+++ ok(hres == S_OK, "UrlMkSetSessionOption failed: %08x\n", hres);
+++
+++ size = 0;
+++ str2[0] = 0;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_USERAGENT, str2, saved, &size, 0);
+++ ok(hres == E_OUTOFMEMORY, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(size == sizeof(test_str) && !memcmp(str2, test_str, sizeof(test_str)), "wrong user agent\n");
+++
+++ hres = UrlMkSetSessionOption(URLMON_OPTION_USERAGENT, test_str, 2, 0);
+++ ok(hres == S_OK, "UrlMkSetSessionOption failed: %08x\n", hres);
+++
+++ size = 0;
+++ str2[0] = 0;
+++ hres = pUrlMkGetSessionOption(URLMON_OPTION_USERAGENT, str2, saved, &size, 0);
+++ ok(hres == E_OUTOFMEMORY, "UrlMkGetSessionOption failed: %08x\n", hres);
+++ ok(size == 3 && !strcmp(str2, "te"), "wrong user agent\n");
+++
+++ hres = UrlMkSetSessionOption(URLMON_OPTION_USERAGENT, test_str, 0, 0);
+++ ok(hres == E_INVALIDARG, "UrlMkSetSessionOption failed: %08x\n", hres);
+++
+++ hres = UrlMkSetSessionOption(URLMON_OPTION_USERAGENT, NULL, sizeof(test_str), 0);
+++ ok(hres == E_INVALIDARG, "UrlMkSetSessionOption failed: %08x\n", hres);
+++
+++ hres = UrlMkSetSessionOption(URLMON_OPTION_USERAGENT, NULL, 0, 0);
+++ ok(hres == E_INVALIDARG, "UrlMkSetSessionOption failed: %08x\n", hres);
+++
+++ HeapFree(GetProcessHeap(), 0, str2);
+++}
+++
+++static void test_MkParseDisplayNameEx(void)
+++{
+++ IMoniker *mon = NULL;
+++ LPWSTR name;
+++ DWORD issys;
+++ ULONG eaten = 0;
+++ IBindCtx *bctx;
+++ HRESULT hres;
+++
+++ static const WCHAR clsid_nameW[] = {'c','l','s','i','d',':',
+++ '2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-','A','2','D','8',
+++ '-','0','8','0','0','2','B','3','0','3','0','9','D',':',0};
+++
+++ const struct
+++ {
+++ LPBC *ppbc;
+++ LPCWSTR szDisplayName;
+++ ULONG *pchEaten;
+++ LPMONIKER *ppmk;
+++ } invalid_parameters[] =
+++ {
+++ {NULL, NULL, NULL, NULL},
+++ {NULL, NULL, NULL, &mon},
+++ {NULL, NULL, &eaten, NULL},
+++ {NULL, NULL, &eaten, &mon},
+++ {NULL, wszEmpty, NULL, NULL},
+++ {NULL, wszEmpty, NULL, &mon},
+++ {NULL, wszEmpty, &eaten, NULL},
+++ {NULL, wszEmpty, &eaten, &mon},
+++ {&bctx, NULL, NULL, NULL},
+++ {&bctx, NULL, NULL, &mon},
+++ {&bctx, NULL, &eaten, NULL},
+++ {&bctx, NULL, &eaten, &mon},
+++ {&bctx, wszEmpty, NULL, NULL},
+++ {&bctx, wszEmpty, NULL, &mon},
+++ {&bctx, wszEmpty, &eaten, NULL},
+++ {&bctx, wszEmpty, &eaten, &mon},
+++ };
+++
+++ int i;
+++
+++ CreateBindCtx(0, &bctx);
+++
+++ for (i = 0; i < sizeof(invalid_parameters)/sizeof(invalid_parameters[0]); i++)
+++ {
+++ eaten = 0xdeadbeef;
+++ mon = (IMoniker *)0xdeadbeef;
+++ hres = MkParseDisplayNameEx(invalid_parameters[i].ppbc ? *invalid_parameters[i].ppbc : NULL,
+++ invalid_parameters[i].szDisplayName,
+++ invalid_parameters[i].pchEaten,
+++ invalid_parameters[i].ppmk);
+++ ok(hres == E_INVALIDARG,
+++ "[%d] Expected MkParseDisplayNameEx to return E_INVALIDARG, got %08x\n", i, hres);
+++ ok(eaten == 0xdeadbeef, "[%d] Expected eaten to be 0xdeadbeef, got %u\n", i, eaten);
+++ ok(mon == (IMoniker *)0xdeadbeef, "[%d] Expected mon to be 0xdeadbeef, got %p\n", i, mon);
+++ }
+++
+++ hres = MkParseDisplayNameEx(bctx, url9, &eaten, &mon);
+++ ok(hres == S_OK, "MkParseDisplayNameEx failed: %08x\n", hres);
+++ ok(eaten == sizeof(url9)/sizeof(WCHAR)-1, "eaten=%d\n", eaten);
+++ ok(mon != NULL, "mon == NULL\n");
+++
+++ hres = IMoniker_GetDisplayName(mon, NULL, 0, &name);
+++ ok(hres == S_OK, "GetDiasplayName failed: %08x\n", hres);
+++ ok(!lstrcmpW(name, url9), "wrong display name %s\n", wine_dbgstr_w(name));
+++ CoTaskMemFree(name);
+++
+++ hres = IMoniker_IsSystemMoniker(mon, &issys);
+++ ok(hres == S_OK, "IsSystemMoniker failed: %08x\n", hres);
+++ ok(issys == MKSYS_URLMONIKER, "issys=%x\n", issys);
+++
+++ IMoniker_Release(mon);
+++
+++ hres = MkParseDisplayNameEx(bctx, clsid_nameW, &eaten, &mon);
+++ ok(hres == S_OK, "MkParseDisplayNameEx failed: %08x\n", hres);
+++ ok(eaten == sizeof(clsid_nameW)/sizeof(WCHAR)-1, "eaten=%d\n", eaten);
+++ ok(mon != NULL, "mon == NULL\n");
+++
+++ hres = IMoniker_IsSystemMoniker(mon, &issys);
+++ ok(hres == S_OK, "IsSystemMoniker failed: %08x\n", hres);
+++ ok(issys == MKSYS_CLASSMONIKER, "issys=%x\n", issys);
+++
+++ IMoniker_Release(mon);
+++
+++ hres = MkParseDisplayNameEx(bctx, url8, &eaten, &mon);
+++ ok(FAILED(hres), "MkParseDisplayNameEx succeeded: %08x\n", hres);
+++
+++ IBindCtx_Release(bctx);
+++}
+++
+++static void test_IsValidURL(void)
+++{
+++ HRESULT hr;
++++ IBindCtx *bctx = NULL;
+++
+++ hr = IsValidURL(NULL, 0, 0);
+++ ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
++++
++++ hr = IsValidURL(NULL, wszHttpWineHQ, 0);
++++ ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
++++
++++ CreateBindCtx(0, &bctx);
++++
++++ hr = IsValidURL(bctx, wszHttpWineHQ, 0);
++++ ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
++++
++++ IBindCtx_Release(bctx);
++++}
++++
++++static const struct {
++++ INTERNETFEATURELIST feature;
++++ DWORD get_flags;
++++ HRESULT expected;
++++ BOOL todo;
++++} default_feature_tests[] = {
++++ {FEATURE_OBJECT_CACHING,GET_FEATURE_FROM_PROCESS,S_OK},
++++ {FEATURE_ZONE_ELEVATION,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_MIME_HANDLING,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_MIME_SNIFFING,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_WINDOW_RESTRICTIONS,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_WEBOC_POPUPMANAGEMENT,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_BEHAVIORS,GET_FEATURE_FROM_PROCESS,S_OK},
++++ {FEATURE_DISABLE_MK_PROTOCOL,GET_FEATURE_FROM_PROCESS,S_OK},
++++ {FEATURE_LOCALMACHINE_LOCKDOWN,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_SECURITYBAND,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_RESTRICT_ACTIVEXINSTALL,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_VALIDATE_NAVIGATE_URL,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_RESTRICT_FILEDOWNLOAD,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_ADDON_MANAGEMENT,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_PROTOCOL_LOCKDOWN,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_HTTP_USERNAME_PASSWORD_DISABLE,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_SAFE_BINDTOOBJECT,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_UNC_SAVEDFILECHECK,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_GET_URL_DOM_FILEPATH_UNENCODED,GET_FEATURE_FROM_PROCESS,S_OK},
++++ {FEATURE_TABBED_BROWSING,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_SSLUX,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_DISABLE_NAVIGATION_SOUNDS,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_DISABLE_LEGACY_COMPRESSION,GET_FEATURE_FROM_PROCESS,S_OK},
++++ {FEATURE_FORCE_ADDR_AND_STATUS,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_XMLHTTP,GET_FEATURE_FROM_PROCESS,S_OK},
++++ {FEATURE_DISABLE_TELNET_PROTOCOL,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_FEEDS,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_BLOCK_INPUT_PROMPTS,GET_FEATURE_FROM_PROCESS,S_FALSE}
++++};
++++
++++static void test_internet_feature_defaults(void) {
++++ HRESULT hres;
++++ DWORD i;
++++
++++ for(i = 0; i < sizeof(default_feature_tests)/sizeof(default_feature_tests[0]); ++i) {
++++ hres = pCoInternetIsFeatureEnabled(default_feature_tests[i].feature, default_feature_tests[i].get_flags);
++++ if(default_feature_tests[i].todo) {
++++ todo_wine
++++ ok(hres == default_feature_tests[i].expected, "CoInternetIsFeatureEnabled returned %08x, expected %08x on test %d\n",
++++ hres, default_feature_tests[i].expected, i);
++++ } else {
++++ ok(hres == default_feature_tests[i].expected, "CoInternetIsFeatureEnabled returned %08x, expected %08x on test %d\n",
++++ hres, default_feature_tests[i].expected, i);
++++ }
++++ }
++++}
++++
++++/* With older versions of IE (IE 7 and earlier), urlmon caches
++++ * the FeatureControl values from the registry when it's loaded
++++ * into memory. Newer versions of IE conditionally cache the
++++ * the FeatureControl registry values (i.e. When a call to
++++ * CoInternetIsFeatureEnabled and a corresponding CoInternetSetFeatureEnabled
++++ * call hasn't already been made for the specified Feature). Because of
++++ * this we skip these tests on IE 7 and earlier.
++++ */
++++static void test_internet_features_registry(void) {
++++ HRESULT hres;
++++ DWORD res;
++++ char module[MAX_PATH];
++++ char *name;
++++ HKEY feature_control;
++++ HKEY feature;
++++ DWORD value;
++++ BOOL delete_feature_key = TRUE;
++++ BOOL delete_feature_control_key = FALSE;
++++
++++ static const char* szFeatureControlKey = "Software\\Microsoft\\Internet Explorer\\Main\\FeatureControl";
++++ static const char* szFeatureBehaviorsKey = "FEATURE_BEHAVIORS";
++++ static const char* szFeatureZoneElevationKey = "FEATURE_ZONE_ELEVATION";
++++
++++ if(!pIEInstallScope) {
++++ win_skip("Skipping internet feature registry tests, IE is too old...\n");
++++ return;
++++ }
++++
++++ res = GetModuleFileNameA(NULL, module, sizeof(module));
++++ ok(res, "GetModuleFileName failed: %d\n", GetLastError());
++++
++++ name = strrchr(module, '\\')+1;
++++
++++ /* Some Windows machines don't have a FeatureControl key in HKCU. */
++++ res = RegOpenKeyA(HKEY_CURRENT_USER, szFeatureControlKey, &feature_control);
++++ if(res != ERROR_SUCCESS) {
++++ res = RegCreateKeyA(HKEY_CURRENT_USER, szFeatureControlKey, &feature_control);
++++ ok(res == ERROR_SUCCESS, "RegCreateKey failed: %d\n", res);
++++ delete_feature_control_key = TRUE;
++++ }
++++
++++ res = RegOpenKeyA(feature_control, szFeatureBehaviorsKey, &feature);
++++ if(res == ERROR_SUCCESS)
++++ /* FEATURE_BEHAVIORS already existed, so don't delete it when we're done. */
++++ delete_feature_key = FALSE;
++++ else {
++++ res = RegCreateKeyA(feature_control, szFeatureBehaviorsKey, &feature);
++++ ok(res == ERROR_SUCCESS, "RegCreateKey failed: %d\n", res);
++++ }
++++
++++ value = 0;
++++ res = RegSetValueExA(feature, name, 0, REG_DWORD, (BYTE*)&value, sizeof(DWORD));
++++ ok(res == ERROR_SUCCESS, "RegSetValueEx failed: %d\n", res);
++++
++++ hres = pCoInternetIsFeatureEnabled(FEATURE_BEHAVIORS, GET_FEATURE_FROM_PROCESS);
++++ ok(hres == S_FALSE, "CoInternetIsFeatureEnabled returned %08x, expected S_FALSE\n", hres);
++++
++++ if(delete_feature_key) {
++++ RegCloseKey(feature);
++++ RegDeleteKeyA(feature_control, szFeatureBehaviorsKey);
++++ } else {
++++ RegDeleteValue(feature, name);
++++ RegCloseKey(feature);
++++ }
++++
++++ /* IE's feature control cached the value it got from the registry earlier. */
++++ hres = pCoInternetIsFeatureEnabled(FEATURE_BEHAVIORS, GET_FEATURE_FROM_PROCESS);
++++ ok(hres == S_FALSE, "CoInternetIsFeatureEnabled returned %08x, expected S_FALSE\n", hres);
++++
++++ /* Restore this feature back to its default value. */
++++ hres = pCoInternetSetFeatureEnabled(FEATURE_BEHAVIORS, SET_FEATURE_ON_PROCESS, TRUE);
++++ ok(hres == S_OK, "CoInternetSetFeatureEnabled failed: %08x\n", hres);
++++
++++ RegCloseKey(feature_control);
++++ if(delete_feature_control_key)
++++ RegDeleteKeyA(HKEY_CURRENT_USER, szFeatureControlKey);
++++
++++ res = RegOpenKeyA(HKEY_LOCAL_MACHINE, szFeatureControlKey, &feature_control);
++++ ok(res == ERROR_SUCCESS, "RegOpenKey failed: %d\n", res);
++++
++++ res = RegOpenKeyA(feature_control, szFeatureZoneElevationKey, &feature);
++++ ok(res == ERROR_SUCCESS, "RegOpenKey failed: %d\n", res);
++++
++++ value = 1;
++++ res = RegSetValueExA(feature, "*", 0, REG_DWORD, (BYTE*)&value, sizeof(DWORD));
++++ ok(res == ERROR_SUCCESS, "RegSetValueEx failed: %d\n", res);
++++
++++ hres = pCoInternetIsFeatureEnabled(FEATURE_ZONE_ELEVATION, GET_FEATURE_FROM_PROCESS);
++++ ok(hres == S_OK, "CoInternetIsFeatureEnabled returned %08x, expected S_OK\n", hres);
++++
++++ RegDeleteValueA(feature, "*");
++++ RegCloseKey(feature);
++++ RegCloseKey(feature_control);
++++
++++ /* Value is still cached from last time. */
++++ hres = pCoInternetIsFeatureEnabled(FEATURE_ZONE_ELEVATION, GET_FEATURE_FROM_PROCESS);
++++ ok(hres == S_OK, "CoInternetIsFeatureEnabled returned %08x, expected S_OK\n", hres);
++++
++++ hres = pCoInternetSetFeatureEnabled(FEATURE_ZONE_ELEVATION, SET_FEATURE_ON_PROCESS, FALSE);
++++ ok(hres == S_OK, "CoInternetSetFeatureEnabled failed: %08x\n", hres);
++++
++++ test_internet_feature_defaults();
++++}
++++
++++static void test_CoInternetIsFeatureEnabled(void) {
++++ HRESULT hres;
++++
++++ hres = pCoInternetIsFeatureEnabled(FEATURE_ENTRY_COUNT, GET_FEATURE_FROM_PROCESS);
++++ ok(hres == E_FAIL, "CoInternetIsFeatureEnabled returned %08x, expected E_FAIL\n", hres);
++++}
++++
++++static const struct {
++++ INTERNETFEATURELIST feature;
++++ DWORD set_flags;
++++ BOOL enable;
++++ HRESULT set_expected;
++++ BOOL set_todo;
++++ DWORD get_flags;
++++ HRESULT get_expected;
++++ BOOL get_todo;
++++} internet_feature_tests[] = {
++++ {FEATURE_OBJECT_CACHING,SET_FEATURE_ON_PROCESS,FALSE,S_OK,FALSE,GET_FEATURE_FROM_PROCESS,S_FALSE},
++++ {FEATURE_WEBOC_POPUPMANAGEMENT,SET_FEATURE_ON_PROCESS,TRUE,S_OK,FALSE,GET_FEATURE_FROM_PROCESS,S_OK},
++++ {FEATURE_LOCALMACHINE_LOCKDOWN,SET_FEATURE_ON_PROCESS,TRUE,S_OK,FALSE,GET_FEATURE_FROM_PROCESS,S_OK}
++++};
++++
++++static void test_CoInternetSetFeatureEnabled(void) {
++++ HRESULT hres;
++++ DWORD i;
++++
++++ hres = pCoInternetSetFeatureEnabled(FEATURE_ENTRY_COUNT,SET_FEATURE_ON_PROCESS,TRUE);
++++ ok(hres == E_FAIL, "CoInternetSetFeatureEnabled returned %08x, expected E_FAIL\n", hres);
++++
++++ for(i = 0; i < sizeof(internet_feature_tests)/sizeof(internet_feature_tests[0]); ++i) {
++++ hres = pCoInternetSetFeatureEnabled(internet_feature_tests[i].feature, internet_feature_tests[i].set_flags,
++++ internet_feature_tests[i].enable);
++++ if(internet_feature_tests[i].set_todo) {
++++ todo_wine
++++ ok(hres == internet_feature_tests[i].set_expected, "CoInternetSetFeatureEnabled returned %08x, expected %08x on test %d\n",
++++ hres, internet_feature_tests[i].set_expected, i);
++++ } else {
++++ ok(hres == internet_feature_tests[i].set_expected, "CoInternetSetFeatureEnabled returned %08x, expected %08x on test %d\n",
++++ hres, internet_feature_tests[i].set_expected, i);
++++ }
++++
++++ hres = pCoInternetIsFeatureEnabled(internet_feature_tests[i].feature, internet_feature_tests[i].set_flags);
++++ if(internet_feature_tests[i].get_todo) {
++++ todo_wine
++++ ok(hres == internet_feature_tests[i].get_expected, "CoInternetIsFeatureEnabled returned %08x, expected %08x on test %d\n",
++++ hres, internet_feature_tests[i].get_expected, i);
++++ } else {
++++ ok(hres == internet_feature_tests[i].get_expected, "CoInternetIsFeatureEnabled returned %08x, expected %08x on test %d\n",
++++ hres, internet_feature_tests[i].get_expected, i);
++++ }
++++ }
++++}
++++
++++static void test_internet_features(void) {
++++ if(!pCoInternetIsFeatureEnabled || !pCoInternetSetFeatureEnabled) {
++++ win_skip("Skipping internet feature tests, IE is too old\n");
++++ return;
++++ }
++++
++++ test_internet_features_registry();
++++ test_CoInternetIsFeatureEnabled();
++++ test_CoInternetSetFeatureEnabled();
+++}
+++
+++START_TEST(misc)
+++{
+++ HMODULE hurlmon;
+++
- !pCoInternetGetSession || !pCoInternetParseUrl) {
- win_skip("Various needed functions not present in IE 4.0\n");
+++ hurlmon = GetModuleHandle("urlmon.dll");
+++ pCoInternetCompareUrl = (void *) GetProcAddress(hurlmon, "CoInternetCompareUrl");
+++ pCoInternetGetSecurityUrl = (void*) GetProcAddress(hurlmon, "CoInternetGetSecurityUrl");
+++ pCoInternetGetSession = (void*) GetProcAddress(hurlmon, "CoInternetGetSession");
+++ pCoInternetParseUrl = (void*) GetProcAddress(hurlmon, "CoInternetParseUrl");
+++ pCoInternetQueryInfo = (void*) GetProcAddress(hurlmon, "CoInternetQueryInfo");
+++ pCopyStgMedium = (void*) GetProcAddress(hurlmon, "CopyStgMedium");
+++ pFindMimeFromData = (void*) GetProcAddress(hurlmon, "FindMimeFromData");
+++ pObtainUserAgentString = (void*) GetProcAddress(hurlmon, "ObtainUserAgentString");
+++ pReleaseBindInfo = (void*) GetProcAddress(hurlmon, "ReleaseBindInfo");
+++ pUrlMkGetSessionOption = (void*) GetProcAddress(hurlmon, "UrlMkGetSessionOption");
++++ pCompareSecurityIds = (void*) GetProcAddress(hurlmon, "CompareSecurityIds");
++++ pCoInternetIsFeatureEnabled = (void*) GetProcAddress(hurlmon, "CoInternetIsFeatureEnabled");
++++ pCoInternetSetFeatureEnabled = (void*) GetProcAddress(hurlmon, "CoInternetSetFeatureEnabled");
++++ pIEInstallScope = (void*) GetProcAddress(hurlmon, "IEInstallScope");
+++
+++ if (!pCoInternetCompareUrl || !pCoInternetGetSecurityUrl ||
++++ !pCoInternetGetSession || !pCoInternetParseUrl || !pCompareSecurityIds) {
++++ win_skip("Various needed functions not present, too old IE\n");
++++ return;
+++ }
+++
++++ OleInitialize(NULL);
++++
+++ register_protocols();
+++
+++ test_CreateFormatEnum();
+++ test_RegisterFormatEnumerator();
+++ test_CoInternetParseUrl();
+++ test_CoInternetCompareUrl();
+++ test_CoInternetQueryInfo();
+++ test_FindMimeFromData();
+++ test_NameSpace();
+++ test_MimeFilter();
+++ test_ReleaseBindInfo();
+++ test_CopyStgMedium();
+++ test_UrlMkGetSessionOption();
+++ test_user_agent();
+++ test_MkParseDisplayNameEx();
+++ test_IsValidURL();
++++ test_internet_features();
+++
+++ OleUninitialize();
+++}
--- /dev/null
--- /dev/null
--- /dev/null
- * Copyright 2005-2009 Jacek Caban for CodeWeavers
+++/*
- static BOOL first_data_notif, http_is_first, http_post_test, test_redirect;
- static int state = 0, prot_state, read_report_data;
++++ * Copyright 2005-2011 Jacek Caban for CodeWeavers
+++ *
+++ * This library is free software; you can redistribute it and/or
+++ * modify it under the terms of the GNU Lesser General Public
+++ * License as published by the Free Software Foundation; either
+++ * version 2.1 of the License, or (at your option) any later version.
+++ *
+++ * This library is distributed in the hope that it will be useful,
+++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+++ * Lesser General Public License for more details.
+++ *
+++ * You should have received a copy of the GNU Lesser General Public
+++ * License along with this library; if not, write to the Free Software
+++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+++ */
+++
+++#define COBJMACROS
+++#define CONST_VTABLE
+++
+++#include <wine/test.h>
+++#include <stdarg.h>
+++#include <stdio.h>
+++
+++#include "windef.h"
+++#include "winbase.h"
+++#include "ole2.h"
+++#include "urlmon.h"
+++#include "wininet.h"
+++
+++static HRESULT (WINAPI *pCoInternetGetSession)(DWORD, IInternetSession **, DWORD);
+++static HRESULT (WINAPI *pReleaseBindInfo)(BINDINFO*);
++++static HRESULT (WINAPI *pCreateUri)(LPCWSTR, DWORD, DWORD_PTR, IUri**);
+++
+++#define DEFINE_EXPECT(func) \
+++ static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
+++
+++#define SET_EXPECT(func) \
+++ expect_ ## func = TRUE
+++
+++#define CHECK_EXPECT2(func) \
+++ do { \
+++ ok(expect_ ##func, "unexpected call " #func "\n"); \
+++ called_ ## func = TRUE; \
+++ }while(0)
+++
+++#define CHECK_EXPECT(func) \
+++ do { \
+++ CHECK_EXPECT2(func); \
+++ expect_ ## func = FALSE; \
+++ }while(0)
+++
+++#define CHECK_CALLED(func) \
+++ do { \
+++ ok(called_ ## func, "expected " #func "\n"); \
+++ expect_ ## func = called_ ## func = FALSE; \
+++ }while(0)
+++
+++#define CHECK_NOT_CALLED(func) \
+++ do { \
+++ ok(!called_ ## func, "unexpected " #func "\n"); \
+++ expect_ ## func = called_ ## func = FALSE; \
+++ }while(0)
+++
+++#define CLEAR_CALLED(func) \
+++ expect_ ## func = called_ ## func = FALSE
+++
+++DEFINE_EXPECT(GetBindInfo);
+++DEFINE_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
+++DEFINE_EXPECT(ReportProgress_DIRECTBIND);
+++DEFINE_EXPECT(ReportProgress_RAWMIMETYPE);
+++DEFINE_EXPECT(ReportProgress_FINDINGRESOURCE);
+++DEFINE_EXPECT(ReportProgress_CONNECTING);
+++DEFINE_EXPECT(ReportProgress_SENDINGREQUEST);
+++DEFINE_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
+++DEFINE_EXPECT(ReportProgress_VERIFIEDMIMETYPEAVAILABLE);
+++DEFINE_EXPECT(ReportProgress_PROTOCOLCLASSID);
+++DEFINE_EXPECT(ReportProgress_COOKIE_SENT);
+++DEFINE_EXPECT(ReportProgress_REDIRECTING);
+++DEFINE_EXPECT(ReportProgress_ENCODING);
+++DEFINE_EXPECT(ReportProgress_ACCEPTRANGES);
+++DEFINE_EXPECT(ReportProgress_PROXYDETECTING);
+++DEFINE_EXPECT(ReportProgress_LOADINGMIMEHANDLER);
+++DEFINE_EXPECT(ReportProgress_DECODING);
+++DEFINE_EXPECT(ReportData);
+++DEFINE_EXPECT(ReportData2);
+++DEFINE_EXPECT(ReportResult);
+++DEFINE_EXPECT(GetBindString_ACCEPT_MIMES);
+++DEFINE_EXPECT(GetBindString_USER_AGENT);
+++DEFINE_EXPECT(GetBindString_POST_COOKIE);
+++DEFINE_EXPECT(GetBindString_URL);
+++DEFINE_EXPECT(QueryService_HttpNegotiate);
+++DEFINE_EXPECT(QueryService_InternetProtocol);
+++DEFINE_EXPECT(QueryService_HttpSecurity);
+++DEFINE_EXPECT(QueryInterface_IWinInetInfo);
+++DEFINE_EXPECT(QueryInterface_IWinInetHttpInfo);
+++DEFINE_EXPECT(BeginningTransaction);
+++DEFINE_EXPECT(GetRootSecurityId);
+++DEFINE_EXPECT(OnResponse);
+++DEFINE_EXPECT(Switch);
+++DEFINE_EXPECT(Continue);
+++DEFINE_EXPECT(CreateInstance);
+++DEFINE_EXPECT(Start);
++++DEFINE_EXPECT(StartEx);
+++DEFINE_EXPECT(Terminate);
+++DEFINE_EXPECT(Read);
+++DEFINE_EXPECT(Read2);
+++DEFINE_EXPECT(SetPriority);
+++DEFINE_EXPECT(LockRequest);
+++DEFINE_EXPECT(UnlockRequest);
++++DEFINE_EXPECT(Abort);
+++DEFINE_EXPECT(MimeFilter_CreateInstance);
+++DEFINE_EXPECT(MimeFilter_Start);
+++DEFINE_EXPECT(MimeFilter_ReportProgress);
+++DEFINE_EXPECT(MimeFilter_ReportData);
+++DEFINE_EXPECT(MimeFilter_ReportResult);
+++DEFINE_EXPECT(MimeFilter_Terminate);
+++DEFINE_EXPECT(MimeFilter_LockRequest);
+++DEFINE_EXPECT(MimeFilter_UnlockRequest);
+++DEFINE_EXPECT(MimeFilter_Read);
+++DEFINE_EXPECT(MimeFilter_Switch);
+++DEFINE_EXPECT(MimeFilter_Continue);
++++DEFINE_EXPECT(Stream_Seek);
++++DEFINE_EXPECT(Stream_Read);
+++
+++static const WCHAR wszIndexHtml[] = {'i','n','d','e','x','.','h','t','m','l',0};
+++static const WCHAR index_url[] =
+++ {'f','i','l','e',':','i','n','d','e','x','.','h','t','m','l',0};
+++
+++static const WCHAR acc_mimeW[] = {'*','/','*',0};
+++static const WCHAR user_agentW[] = {'W','i','n','e',0};
+++static const WCHAR text_htmlW[] = {'t','e','x','t','/','h','t','m','l',0};
+++static const WCHAR hostW[] = {'w','w','w','.','w','i','n','e','h','q','.','o','r','g',0};
+++static const WCHAR winehq_ipW[] = {'2','0','9','.','4','6','.','2','5','.','1','3','4',0};
+++static const WCHAR emptyW[] = {0};
+++static const WCHAR gzipW[] = {'g','z','i','p',0};
+++
+++static HRESULT expect_hrResult;
+++static LPCWSTR file_name, http_url, expect_wsz;
+++static IInternetProtocol *async_protocol = NULL;
- static DWORD prot_read, pi, filter_state;
- static BOOL security_problem;
- static BOOL async_read_pending, mimefilter_test, direct_read, wait_for_switch, emulate_prot, short_read;
++++static BOOL first_data_notif, http_is_first, test_redirect;
++++static int prot_state, read_report_data, post_stream_read;
+++static DWORD bindf, ex_priority , pi;
+++static IInternetProtocol *binding_protocol, *filtered_protocol;
+++static IInternetBindInfo *prot_bind_info;
+++static IInternetProtocolSink *binding_sink, *filtered_sink;
+++static void *expect_pv;
+++static HANDLE event_complete, event_complete2, event_continue, event_continue_done;
+++static BOOL binding_test;
+++static PROTOCOLDATA protocoldata, *pdata, continue_protdata;
- /* lstrcmpW is not implemented on Win9x */
- static int strcmp_ww(LPCWSTR strw1, LPCWSTR strw2)
- {
- CHAR stra1[512], stra2[512];
- WideCharToMultiByte(CP_ACP, 0, strw1, -1, stra1, MAX_PATH, NULL, NULL);
- WideCharToMultiByte(CP_ACP, 0, strw2, -1, stra2, MAX_PATH, NULL, NULL);
- return lstrcmpA(stra1, stra2);
- }
-
++++static DWORD prot_read, pi, filter_state, http_post_test, thread_id;
++++static BOOL security_problem, test_async_req, impl_protex;
++++static BOOL async_read_pending, mimefilter_test, direct_read, wait_for_switch, emulate_prot, short_read, test_abort;
++++
++++enum {
++++ STATE_CONNECTING,
++++ STATE_SENDINGREQUEST,
++++ STATE_STARTDOWNLOADING,
++++ STATE_DOWNLOADING
++++} state;
+++
+++static enum {
+++ FILE_TEST,
+++ HTTP_TEST,
+++ HTTPS_TEST,
+++ FTP_TEST,
+++ MK_TEST,
++++ ITS_TEST,
+++ BIND_TEST
+++} tested_protocol;
+++
+++static const WCHAR protocol_names[][10] = {
+++ {'f','i','l','e',0},
+++ {'h','t','t','p',0},
+++ {'h','t','t','p','s',0},
+++ {'f','t','p',0},
+++ {'m','k',0},
++++ {'i','t','s',0},
+++ {'t','e','s','t',0}
+++};
+++
+++static const WCHAR binding_urls[][130] = {
+++ {'f','i','l','e',':','t','e','s','t','.','h','t','m','l',0},
+++ {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.',
+++ 'o','r','g','/','s','i','t','e','/','a','b','o','u','t',0},
+++ {'h','t','t','p','s',':','/','/','w','w','w','.','c','o','d','e','w','e','a','v','e','r','s',
+++ '.','c','o','m','/','t','e','s','t','.','h','t','m','l',0},
+++ {'f','t','p',':','/','/','f','t','p','.','w','i','n','e','h','q','.','o','r','g',
+++ '/','p','u','b','/','o','t','h','e','r',
+++ '/','w','i','n','e','l','o','g','o','.','x','c','f','.','t','a','r','.','b','z','2',0},
+++ {'m','k',':','t','e','s','t',0},
++++ {'i','t','s',':','t','e','s','t','.','c','h','m',':',':','/','b','l','a','n','k','.','h','t','m','l',0},
+++ {'t','e','s','t',':','/','/','f','i','l','e','.','h','t','m','l',0}
+++};
+++
++++static const CHAR post_data[] = "mode=Test";
++++
+++static const char *debugstr_guid(REFIID riid)
+++{
+++ static char buf[50];
+++
+++ sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
+++ riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
+++ riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
+++ riid->Data4[5], riid->Data4[6], riid->Data4[7]);
+++
+++ return buf;
+++}
+++
+++static int strcmp_wa(LPCWSTR strw, const char *stra)
+++{
+++ CHAR buf[512];
+++ WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
+++ return lstrcmpA(stra, buf);
+++}
+++
- ok(!strcmp_ww(szURL, binding_urls[tested_protocol]), "szURL != http_url\n");
+++static HRESULT WINAPI HttpSecurity_QueryInterface(IHttpSecurity *iface, REFIID riid, void **ppv)
+++{
+++ if(IsEqualGUID(&IID_IUnknown, riid)
+++ || IsEqualGUID(&IID_IHttpSecurity, riid)) {
+++ *ppv = iface;
+++ return S_OK;
+++ }
+++
+++ ok(0, "unexpected call\n");
+++ return E_NOINTERFACE;
+++}
+++
+++static ULONG WINAPI HttpSecurity_AddRef(IHttpSecurity *iface)
+++{
+++ return 2;
+++}
+++
+++static ULONG WINAPI HttpSecurity_Release(IHttpSecurity *iface)
+++{
+++ return 1;
+++}
+++
+++static HRESULT WINAPI HttpSecurity_GetWindow(IHttpSecurity* iface, REFGUID rguidReason, HWND *phwnd)
+++{
+++ trace("HttpSecurity_GetWindow\n");
+++
+++ return S_FALSE;
+++}
+++
+++static HRESULT WINAPI HttpSecurity_OnSecurityProblem(IHttpSecurity *iface, DWORD dwProblem)
+++{
+++ trace("Security problem: %u\n", dwProblem);
+++ ok(dwProblem == ERROR_INTERNET_SEC_CERT_REV_FAILED, "Expected ERROR_INTERNET_SEC_CERT_REV_FAILED got %u\n", dwProblem);
+++
+++ /* Only retry once */
+++ if (security_problem)
+++ return E_ABORT;
+++
+++ security_problem = TRUE;
+++ SET_EXPECT(BeginningTransaction);
+++
+++ return RPC_E_RETRY;
+++}
+++
+++static IHttpSecurityVtbl HttpSecurityVtbl = {
+++ HttpSecurity_QueryInterface,
+++ HttpSecurity_AddRef,
+++ HttpSecurity_Release,
+++ HttpSecurity_GetWindow,
+++ HttpSecurity_OnSecurityProblem
+++};
+++
+++static IHttpSecurity http_security = { &HttpSecurityVtbl };
+++
+++static HRESULT WINAPI HttpNegotiate_QueryInterface(IHttpNegotiate2 *iface, REFIID riid, void **ppv)
+++{
+++ if(IsEqualGUID(&IID_IUnknown, riid)
+++ || IsEqualGUID(&IID_IHttpNegotiate, riid)
+++ || IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
+++ *ppv = iface;
+++ return S_OK;
+++ }
+++
+++ ok(0, "unexpected call\n");
+++ return E_NOINTERFACE;
+++}
+++
+++static ULONG WINAPI HttpNegotiate_AddRef(IHttpNegotiate2 *iface)
+++{
+++ return 2;
+++}
+++
+++static ULONG WINAPI HttpNegotiate_Release(IHttpNegotiate2 *iface)
+++{
+++ return 1;
+++}
+++
+++static HRESULT WINAPI HttpNegotiate_BeginningTransaction(IHttpNegotiate2 *iface, LPCWSTR szURL,
+++ LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
+++{
+++ LPWSTR addl_headers;
+++
+++ static const WCHAR wszHeaders[] =
+++ {'C','o','n','t','e','n','t','-','T','y','p','e',':',' ','a','p','p','l','i','c','a','t',
+++ 'i','o','n','/','x','-','w','w','w','-','f','o','r','m','-','u','r','l','e','n','c','o',
+++ 'd','e','d','\r','\n',0};
+++
+++ CHECK_EXPECT(BeginningTransaction);
+++
+++ if(binding_test)
- ok(!strcmp_ww(szURL, http_url), "szURL != http_url\n");
++++ ok(!lstrcmpW(szURL, binding_urls[tested_protocol]), "szURL != http_url\n");
+++ else
- if (!addl_headers)
- {
- http_post_test = FALSE;
- skip("Out of memory\n");
- return E_OUTOFMEMORY;
- }
++++ ok(!lstrcmpW(szURL, http_url), "szURL != http_url\n");
+++ ok(!dwReserved, "dwReserved=%d, expected 0\n", dwReserved);
+++ ok(pszAdditionalHeaders != NULL, "pszAdditionalHeaders == NULL\n");
+++ if(pszAdditionalHeaders)
+++ {
+++ ok(*pszAdditionalHeaders == NULL, "*pszAdditionalHeaders != NULL\n");
+++ if (http_post_test)
+++ {
+++ addl_headers = CoTaskMemAlloc(sizeof(wszHeaders));
- if(!state) {
+++ memcpy(addl_headers, wszHeaders, sizeof(wszHeaders));
+++ *pszAdditionalHeaders = addl_headers;
+++ }
+++ }
+++
+++ return S_OK;
+++}
+++
+++static HRESULT WINAPI HttpNegotiate_OnResponse(IHttpNegotiate2 *iface, DWORD dwResponseCode,
+++ LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders, LPWSTR *pszAdditionalRequestHeaders)
+++{
+++ CHECK_EXPECT(OnResponse);
+++
+++ ok(dwResponseCode == 200, "dwResponseCode=%d, expected 200\n", dwResponseCode);
+++ ok(szResponseHeaders != NULL, "szResponseHeaders == NULL\n");
+++ ok(szRequestHeaders == NULL, "szRequestHeaders != NULL\n");
+++ ok(pszAdditionalRequestHeaders == NULL, "pszAdditionalHeaders != NULL\n");
+++
+++ return S_OK;
+++}
+++
+++static HRESULT WINAPI HttpNegotiate_GetRootSecurityId(IHttpNegotiate2 *iface,
+++ BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
+++{
+++ static const BYTE sec_id[] = {'h','t','t','p',':','t','e','s','t',1,0,0,0};
+++
+++ CHECK_EXPECT(GetRootSecurityId);
+++
+++ ok(!dwReserved, "dwReserved=%ld, expected 0\n", dwReserved);
+++ ok(pbSecurityId != NULL, "pbSecurityId == NULL\n");
+++ ok(pcbSecurityId != NULL, "pcbSecurityId == NULL\n");
+++
+++ if(pcbSecurityId) {
+++ ok(*pcbSecurityId == 512, "*pcbSecurityId=%d, expected 512\n", *pcbSecurityId);
+++ *pcbSecurityId = sizeof(sec_id);
+++ }
+++
+++ if(pbSecurityId)
+++ memcpy(pbSecurityId, sec_id, sizeof(sec_id));
+++
+++ return E_FAIL;
+++}
+++
+++static IHttpNegotiate2Vtbl HttpNegotiateVtbl = {
+++ HttpNegotiate_QueryInterface,
+++ HttpNegotiate_AddRef,
+++ HttpNegotiate_Release,
+++ HttpNegotiate_BeginningTransaction,
+++ HttpNegotiate_OnResponse,
+++ HttpNegotiate_GetRootSecurityId
+++};
+++
+++static IHttpNegotiate2 http_negotiate = { &HttpNegotiateVtbl };
+++
+++static HRESULT QueryInterface(REFIID,void**);
+++
+++static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
+++{
+++ return QueryInterface(riid, ppv);
+++}
+++
+++static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
+++{
+++ return 2;
+++}
+++
+++static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
+++{
+++ return 1;
+++}
+++
+++static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
+++ REFIID riid, void **ppv)
+++{
+++ if(IsEqualGUID(&IID_IHttpNegotiate, guidService) || IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
+++ CHECK_EXPECT2(QueryService_HttpNegotiate);
+++ return IHttpNegotiate2_QueryInterface(&http_negotiate, riid, ppv);
+++ }
+++
+++ if(IsEqualGUID(&IID_IInternetProtocol, guidService)) {
+++ ok(IsEqualGUID(&IID_IInternetProtocol, riid), "unexpected riid\n");
+++ CHECK_EXPECT(QueryService_InternetProtocol);
+++ return E_NOINTERFACE;
+++ }
+++
+++ if(IsEqualGUID(&IID_IHttpSecurity, guidService)) {
+++ ok(IsEqualGUID(&IID_IHttpSecurity, riid), "unexpected riid\n");
+++ CHECK_EXPECT(QueryService_HttpSecurity);
+++ return IHttpSecurity_QueryInterface(&http_security, riid, ppv);
+++ }
+++
+++ ok(0, "unexpected service %s\n", debugstr_guid(guidService));
+++ return E_FAIL;
+++}
+++
+++static const IServiceProviderVtbl ServiceProviderVtbl = {
+++ ServiceProvider_QueryInterface,
+++ ServiceProvider_AddRef,
+++ ServiceProvider_Release,
+++ ServiceProvider_QueryService
+++};
+++
+++static IServiceProvider service_provider = { &ServiceProviderVtbl };
+++
++++static HRESULT WINAPI Stream_QueryInterface(IStream *iface, REFIID riid, void **ppv)
++++{
++++ ok(0, "unexpected call\n");
++++ return E_NOINTERFACE;
++++}
++++
++++static ULONG WINAPI Stream_AddRef(IStream *iface)
++++{
++++ return 2;
++++}
++++
++++static ULONG WINAPI Stream_Release(IStream *iface)
++++{
++++ return 1;
++++}
++++
++++static HRESULT WINAPI Stream_Read(IStream *iface, void *pv,
++++ ULONG cb, ULONG *pcbRead)
++++{
++++ CHECK_EXPECT2(Stream_Read);
++++
++++ ok(GetCurrentThreadId() != thread_id, "wrong thread %d\n", GetCurrentThreadId());
++++
++++ ok(pv != NULL, "pv == NULL\n");
++++ ok(cb == 0x20000 || broken(cb == 0x2000), "cb = %d\n", cb);
++++ ok(pcbRead != NULL, "pcbRead == NULL\n");
++++
++++ if(post_stream_read) {
++++ *pcbRead = 0;
++++ return S_FALSE;
++++ }
++++
++++ memcpy(pv, post_data, sizeof(post_data)-1);
++++ post_stream_read += *pcbRead = sizeof(post_data)-1;
++++ return S_OK;
++++}
++++
++++static HRESULT WINAPI Stream_Write(IStream *iface, const void *pv,
++++ ULONG cb, ULONG *pcbWritten)
++++{
++++ ok(0, "unexpected call\n");
++++ return E_NOTIMPL;
++++}
++++
++++static HRESULT WINAPI Stream_Seek(IStream *iface, LARGE_INTEGER dlibMove,
++++ DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
++++{
++++ CHECK_EXPECT(Stream_Seek);
++++
++++ ok(!dlibMove.QuadPart, "dlibMove != 0\n");
++++ ok(dwOrigin == STREAM_SEEK_SET, "dwOrigin = %d\n", dwOrigin);
++++ ok(!plibNewPosition, "plibNewPosition == NULL\n");
++++
++++ return S_OK;
++++}
++++
++++static HRESULT WINAPI Stream_SetSize(IStream *iface, ULARGE_INTEGER libNewSize)
++++{
++++ ok(0, "unexpected call\n");
++++ return E_NOTIMPL;
++++}
++++
++++static HRESULT WINAPI Stream_CopyTo(IStream *iface, IStream *pstm,
++++ ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
++++{
++++ ok(0, "unexpected call\n");
++++ return E_NOTIMPL;
++++}
++++
++++static HRESULT WINAPI Stream_Commit(IStream *iface, DWORD grfCommitFlags)
++++{
++++ ok(0, "unexpected call\n");
++++ return E_NOTIMPL;
++++}
++++
++++static HRESULT WINAPI Stream_Revert(IStream *iface)
++++{
++++ ok(0, "unexpected call\n");
++++ return E_NOTIMPL;
++++}
++++
++++static HRESULT WINAPI Stream_LockRegion(IStream *iface, ULARGE_INTEGER libOffset,
++++ ULARGE_INTEGER cb, DWORD dwLockType)
++++{
++++ ok(0, "unexpected call\n");
++++ return E_NOTIMPL;
++++}
++++
++++static HRESULT WINAPI Stream_UnlockRegion(IStream *iface,
++++ ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
++++{
++++ ok(0, "unexpected call\n");
++++ return E_NOTIMPL;
++++}
++++
++++static HRESULT WINAPI Stream_Stat(IStream *iface, STATSTG *pstatstg,
++++ DWORD dwStatFlag)
++++{
++++ ok(0, "unexpected call\n");
++++ return E_NOTIMPL;
++++}
++++
++++static HRESULT WINAPI Stream_Clone(IStream *iface, IStream **ppstm)
++++{
++++ ok(0, "unexpected call\n");
++++ return E_NOTIMPL;
++++}
++++
++++static const IStreamVtbl StreamVtbl = {
++++ Stream_QueryInterface,
++++ Stream_AddRef,
++++ Stream_Release,
++++ Stream_Read,
++++ Stream_Write,
++++ Stream_Seek,
++++ Stream_SetSize,
++++ Stream_CopyTo,
++++ Stream_Commit,
++++ Stream_Revert,
++++ Stream_LockRegion,
++++ Stream_UnlockRegion,
++++ Stream_Stat,
++++ Stream_Clone
++++};
++++
++++static IStream Stream = { &StreamVtbl };
++++
+++static HRESULT WINAPI ProtocolSink_QueryInterface(IInternetProtocolSink *iface, REFIID riid, void **ppv)
+++{
+++ return QueryInterface(riid, ppv);
+++}
+++
+++static ULONG WINAPI ProtocolSink_AddRef(IInternetProtocolSink *iface)
+++{
+++ return 2;
+++}
+++
+++static ULONG WINAPI ProtocolSink_Release(IInternetProtocolSink *iface)
+++{
+++ return 1;
+++}
+++
+++static void call_continue(PROTOCOLDATA *protocol_data)
+++{
+++ HRESULT hres;
+++
- if (http_is_first) {
++++ if(state == STATE_CONNECTING) {
+++ if(tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST)
+++ CLEAR_CALLED(ReportProgress_COOKIE_SENT);
+++ if(tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST || tested_protocol == FTP_TEST) {
- CLEAR_CALLED(ReportProgress_CONNECTING);
++++ if (http_is_first){
+++ CLEAR_CALLED(ReportProgress_FINDINGRESOURCE);
- }else if(test_redirect) {
- CHECK_CALLED(ReportProgress_FINDINGRESOURCE);
- }else todo_wine {
- CHECK_NOT_CALLED(ReportProgress_FINDINGRESOURCE);
- /* IE7 does call this */
- CLEAR_CALLED(ReportProgress_CONNECTING);
+++ CLEAR_CALLED(ReportProgress_PROXYDETECTING);
- if(tested_protocol == HTTPS_TEST || test_redirect)
+++ }
++++ CLEAR_CALLED(ReportProgress_CONNECTING);
+++ }
+++ if(tested_protocol == FTP_TEST)
+++ todo_wine CHECK_CALLED(ReportProgress_SENDINGREQUEST);
+++ else if (tested_protocol != HTTPS_TEST)
+++ CHECK_CALLED(ReportProgress_SENDINGREQUEST);
+++ if(test_redirect)
+++ CHECK_CALLED(ReportProgress_REDIRECTING);
++++ state = test_async_req ? STATE_SENDINGREQUEST : STATE_STARTDOWNLOADING;
++++ }
++++
++++ switch(state) {
++++ case STATE_SENDINGREQUEST:
++++ SET_EXPECT(Stream_Read);
++++ SET_EXPECT(ReportProgress_SENDINGREQUEST);
++++ break;
++++ case STATE_STARTDOWNLOADING:
+++ if(tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST) {
+++ SET_EXPECT(OnResponse);
- SET_EXPECT(ReportData);
++++ if(tested_protocol == HTTPS_TEST || test_redirect || test_abort)
+++ SET_EXPECT(ReportProgress_ACCEPTRANGES);
+++ SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
+++ if(bindf & BINDF_NEEDFILE)
+++ SET_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
+++ }
++++ default:
++++ break;
+++ }
+++
- if(tested_protocol == FTP_TEST)
++++ if(state != STATE_SENDINGREQUEST)
++++ SET_EXPECT(ReportData);
+++ hres = IInternetProtocol_Continue(async_protocol, protocol_data);
+++ ok(hres == S_OK, "Continue failed: %08x\n", hres);
- else if (! security_problem)
++++ if(tested_protocol == FTP_TEST || security_problem)
+++ CLEAR_CALLED(ReportData);
- if (!state) {
++++ else if(state != STATE_SENDINGREQUEST)
+++ CHECK_CALLED(ReportData);
+++
- state = 1;
++++ switch(state) {
++++ case STATE_SENDINGREQUEST:
++++ CHECK_CALLED(Stream_Read);
++++ CHECK_CALLED(ReportProgress_SENDINGREQUEST);
++++ state = STATE_STARTDOWNLOADING;
++++ break;
++++ case STATE_STARTDOWNLOADING:
+++ if (! security_problem)
+++ {
- if(tested_protocol != FILE_TEST && !mimefilter_test && (pi & PI_MIMEVERIFICATION)) {
++++ state = STATE_DOWNLOADING;
+++ if(tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST) {
+++ CHECK_CALLED(OnResponse);
+++ if(tested_protocol == HTTPS_TEST)
+++ CHECK_CALLED(ReportProgress_ACCEPTRANGES);
+++ else if(test_redirect)
+++ CLEAR_CALLED(ReportProgress_ACCEPTRANGES);
+++ CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
+++ if(bindf & BINDF_NEEDFILE)
+++ CHECK_CALLED(ReportProgress_CACHEFILENAMEAVAILABLE);
+++ }
+++ }
+++ else
+++ {
+++ security_problem = FALSE;
+++ SET_EXPECT(ReportProgress_CONNECTING);
+++ }
++++ default:
++++ break;
+++ }
+++}
+++
+++static HRESULT WINAPI ProtocolSink_Switch(IInternetProtocolSink *iface, PROTOCOLDATA *pProtocolData)
+++{
+++ if(tested_protocol == FTP_TEST)
+++ CHECK_EXPECT2(Switch);
+++ else
+++ CHECK_EXPECT(Switch);
+++
+++ ok(pProtocolData != NULL, "pProtocolData == NULL\n");
+++ if(binding_test) {
+++ ok(pProtocolData != &protocoldata, "pProtocolData == &protocoldata\n");
+++ ok(pProtocolData->grfFlags == protocoldata.grfFlags, "grfFlags wrong %x/%x\n",
+++ pProtocolData->grfFlags, protocoldata.grfFlags );
+++ ok(pProtocolData->dwState == protocoldata.dwState, "dwState wrong %x/%x\n",
+++ pProtocolData->dwState, protocoldata.dwState );
+++ ok(pProtocolData->pData == protocoldata.pData, "pData wrong %p/%p\n",
+++ pProtocolData->pData, protocoldata.pData );
+++ ok(pProtocolData->cbData == protocoldata.cbData, "cbData wrong %x/%x\n",
+++ pProtocolData->cbData, protocoldata.cbData );
+++ }
+++
+++ pdata = pProtocolData;
+++
+++ if(binding_test) {
+++ SetEvent(event_complete);
+++ WaitForSingleObject(event_complete2, INFINITE);
+++ return S_OK;
+++ }if(direct_read) {
+++ continue_protdata = *pProtocolData;
+++ SetEvent(event_continue);
+++ WaitForSingleObject(event_continue_done, INFINITE);
+++ }else {
+++ call_continue(pProtocolData);
+++ SetEvent(event_complete);
+++ }
+++
+++ return S_OK;
+++}
+++
+++static HRESULT WINAPI ProtocolSink_ReportProgress(IInternetProtocolSink *iface, ULONG ulStatusCode,
+++ LPCWSTR szStatusText)
+++{
+++ static const WCHAR null_guid[] = {'{','0','0','0','0','0','0','0','0','-','0','0','0','0','-',
+++ '0','0','0','0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0','0','0','0','}',0};
+++ static const WCHAR text_plain[] = {'t','e','x','t','/','p','l','a','i','n',0};
+++
+++ switch(ulStatusCode) {
+++ case BINDSTATUS_MIMETYPEAVAILABLE:
+++ CHECK_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
- ok(!strcmp_ww(szStatusText, expect_wsz), "unexpected szStatusText\n");
++++ if(tested_protocol != FILE_TEST && tested_protocol != ITS_TEST && !mimefilter_test && (pi & PI_MIMEVERIFICATION)) {
+++ if(!short_read || !direct_read)
+++ CHECK_CALLED(Read); /* set in Continue */
+++ else if(short_read)
+++ CHECK_CALLED(Read2); /* set in Read */
+++ }
+++ ok(szStatusText != NULL, "szStatusText == NULL\n");
+++ if(szStatusText) {
+++ if(tested_protocol == BIND_TEST)
+++ ok(szStatusText == expect_wsz, "unexpected szStatusText\n");
+++ else if (http_post_test)
+++ ok(lstrlenW(text_plain) <= lstrlenW(szStatusText) &&
+++ !memcmp(szStatusText, text_plain, lstrlenW(text_plain)*sizeof(WCHAR)),
+++ "szStatusText != text/plain\n");
+++ else if(!mimefilter_test)
+++ ok(lstrlenW(text_htmlW) <= lstrlenW(szStatusText) &&
+++ !memcmp(szStatusText, text_htmlW, lstrlenW(text_htmlW)*sizeof(WCHAR)),
+++ "szStatusText != text/html\n");
+++ }
+++ break;
+++ case BINDSTATUS_DIRECTBIND:
+++ CHECK_EXPECT2(ReportProgress_DIRECTBIND);
+++ ok(szStatusText == NULL, "szStatusText != NULL\n");
+++ break;
+++ case BINDSTATUS_RAWMIMETYPE:
+++ CHECK_EXPECT2(ReportProgress_RAWMIMETYPE);
+++ ok(szStatusText != NULL, "szStatusText == NULL\n");
+++ if(szStatusText)
+++ ok(lstrlenW(szStatusText) < lstrlenW(text_htmlW) ||
+++ !memcmp(szStatusText, text_htmlW, lstrlenW(text_htmlW)*sizeof(WCHAR)),
+++ "szStatusText != text/html\n");
+++ break;
+++ case BINDSTATUS_CACHEFILENAMEAVAILABLE:
+++ CHECK_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
+++ ok(szStatusText != NULL, "szStatusText == NULL\n");
+++ if(szStatusText) {
+++ if(binding_test)
- ok(!strcmp_ww(szStatusText, file_name), "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
++++ ok(!lstrcmpW(szStatusText, expect_wsz), "unexpected szStatusText\n");
+++ else if(tested_protocol == FILE_TEST)
- if(tested_protocol == FILE_TEST) {
++++ ok(!lstrcmpW(szStatusText, file_name), "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
+++ else
+++ ok(szStatusText != NULL, "szStatusText == NULL\n");
+++ }
+++ break;
+++ case BINDSTATUS_FINDINGRESOURCE:
+++ CHECK_EXPECT2(ReportProgress_FINDINGRESOURCE);
+++ ok(szStatusText != NULL, "szStatusText == NULL\n");
+++ break;
+++ case BINDSTATUS_CONNECTING:
+++ CHECK_EXPECT2(ReportProgress_CONNECTING);
+++ ok(szStatusText != NULL, "szStatusText == NULL\n");
+++ break;
+++ case BINDSTATUS_SENDINGREQUEST:
+++ CHECK_EXPECT2(ReportProgress_SENDINGREQUEST);
- ok(!strcmp_ww(szStatusText, text_htmlW), "szStatusText != text/html\n");
++++ if(tested_protocol == FILE_TEST || tested_protocol == ITS_TEST) {
+++ ok(szStatusText != NULL, "szStatusText == NULL\n");
+++ if(szStatusText)
+++ ok(!*szStatusText, "wrong szStatusText\n");
+++ }
+++ break;
+++ case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
+++ CHECK_EXPECT(ReportProgress_VERIFIEDMIMETYPEAVAILABLE);
+++ ok(szStatusText != NULL, "szStatusText == NULL\n");
+++ if(szStatusText)
- ok(!strcmp_ww(szStatusText, null_guid), "unexpected classid %s\n", wine_dbgstr_w(szStatusText));
++++ ok(!lstrcmpW(szStatusText, text_htmlW), "szStatusText != text/html\n");
+++ break;
+++ case BINDSTATUS_PROTOCOLCLASSID:
+++ CHECK_EXPECT(ReportProgress_PROTOCOLCLASSID);
+++ ok(szStatusText != NULL, "szStatusText == NULL\n");
- ok(!strcmp_wa(szStatusText, "http://test.winehq.org/hello.html"), "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
++++ ok(!lstrcmpW(szStatusText, null_guid), "unexpected classid %s\n", wine_dbgstr_w(szStatusText));
+++ break;
+++ case BINDSTATUS_COOKIE_SENT:
+++ CHECK_EXPECT(ReportProgress_COOKIE_SENT);
+++ ok(szStatusText == NULL, "szStatusText != NULL\n");
+++ break;
+++ case BINDSTATUS_REDIRECTING:
+++ CHECK_EXPECT(ReportProgress_REDIRECTING);
+++ if(test_redirect)
- ok(!strcmp_ww(szStatusText, gzipW), "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
++++ ok(!strcmp_wa(szStatusText, "http://test.winehq.org/tests/hello.html"), "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
+++ else
+++ ok(szStatusText == NULL, "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
+++ break;
+++ case BINDSTATUS_ENCODING:
+++ CHECK_EXPECT(ReportProgress_ENCODING);
+++ ok(!strcmp_wa(szStatusText, "gzip"), "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
+++ break;
+++ case BINDSTATUS_ACCEPTRANGES:
+++ CHECK_EXPECT(ReportProgress_ACCEPTRANGES);
+++ ok(!szStatusText, "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
+++ break;
+++ case BINDSTATUS_PROXYDETECTING:
+++ CHECK_EXPECT(ReportProgress_PROXYDETECTING);
+++ SET_EXPECT(ReportProgress_CONNECTING);
+++ ok(!szStatusText, "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
+++ break;
+++ case BINDSTATUS_LOADINGMIMEHANDLER:
+++ CHECK_EXPECT(ReportProgress_LOADINGMIMEHANDLER);
+++ ok(!szStatusText, "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
+++ break;
+++ case BINDSTATUS_DECODING:
+++ CHECK_EXPECT(ReportProgress_DECODING);
- if(!mimefilter_test && tested_protocol == FILE_TEST) {
++++ ok(!lstrcmpW(szStatusText, gzipW), "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
+++ break;
+++ default:
+++ ok(0, "Unexpected status %d\n", ulStatusCode);
+++ };
+++
+++ return S_OK;
+++}
+++
+++static HRESULT WINAPI ProtocolSink_ReportData(IInternetProtocolSink *iface, DWORD grfBSCF,
+++ ULONG ulProgress, ULONG ulProgressMax)
+++{
+++ HRESULT hres;
+++
+++ static int rec_depth;
+++ rec_depth++;
+++
- ok((grfBSCF == (BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION)) ||
- (grfBSCF == (BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_SKIPDRAINDATAFORFILEURLS)),
- "grcfBSCF = %08x\n", grfBSCF);
++++ if(!mimefilter_test && (tested_protocol == FILE_TEST || tested_protocol == ITS_TEST)) {
+++ CHECK_EXPECT2(ReportData);
+++
+++ ok(ulProgress == ulProgressMax, "ulProgress (%d) != ulProgressMax (%d)\n",
+++ ulProgress, ulProgressMax);
+++ ok(ulProgressMax == 13, "ulProgressMax=%d, expected 13\n", ulProgressMax);
+++ /* BSCF_SKIPDRAINDATAFORFILEURLS added in IE8 */
- if(reported_all_data) {
++++ if(tested_protocol == FILE_TEST)
++++ ok((grfBSCF == (BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION)) ||
++++ (grfBSCF == (BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_SKIPDRAINDATAFORFILEURLS)),
++++ "grcfBSCF = %08x\n", grfBSCF);
++++ else
++++ ok(grfBSCF == (BSCF_FIRSTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE), "grcfBSCF = %08x\n", grfBSCF);
+++ }else if(direct_read) {
+++ BYTE buf[14096];
+++ ULONG read;
+++
+++ if(!read_report_data && rec_depth == 1) {
+++ BOOL reported_all_data = called_ReportData2;
+++
+++ CHECK_EXPECT2(ReportData);
+++
+++ if(short_read) {
+++ ok(grfBSCF == (BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE)
+++ || grfBSCF == BSCF_FIRSTDATANOTIFICATION, /* < IE8 */
+++ "grcfBSCF = %08x\n", grfBSCF);
+++ CHECK_CALLED(Read); /* Set in Continue */
+++ first_data_notif = FALSE;
+++ }else if(first_data_notif) {
+++ ok(grfBSCF == BSCF_FIRSTDATANOTIFICATION, "grcfBSCF = %08x\n", grfBSCF);
+++ first_data_notif = FALSE;
+++ }else if(reported_all_data) {
+++ ok(grfBSCF == (BSCF_LASTDATANOTIFICATION|BSCF_INTERMEDIATEDATANOTIFICATION),
+++ "grcfBSCF = %08x\n", grfBSCF);
+++ }else if(!direct_read) {
+++ ok(grfBSCF == BSCF_INTERMEDIATEDATANOTIFICATION, "grcfBSCF = %08x\n", grfBSCF);
+++ }
+++
+++ do {
+++ read = 0;
+++ if(emulate_prot)
+++ SET_EXPECT(Read);
+++ else
+++ SET_EXPECT(ReportData2);
+++ SET_EXPECT(ReportResult);
++++ if(!emulate_prot)
++++ SET_EXPECT(Switch);
+++ hres = IInternetProtocol_Read(binding_test ? binding_protocol : async_protocol, expect_pv = buf, sizeof(buf), &read);
++++ ok(hres == E_PENDING || hres == S_FALSE || hres == S_OK, "Read failed: %08x\n", hres);
+++ if(hres == S_OK)
+++ ok(read, "read == 0\n");
- }
++++ if(reported_all_data)
+++ ok(hres == S_FALSE, "Read failed: %08x, expected S_FALSE\n", hres);
- if(!state) {
- state = 1;
++++ if(!emulate_prot && hres != E_PENDING)
++++ CHECK_NOT_CALLED(Switch); /* otherwise checked in wait_for_switch loop */
+++ if(emulate_prot)
+++ CHECK_CALLED(Read);
+++ if(!reported_all_data && called_ReportData2) {
+++ if(!emulate_prot)
+++ CHECK_CALLED(ReportData2);
+++ CHECK_CALLED(ReportResult);
+++ ok(hres == S_OK, "Read failed: %08x\n", hres);
+++ reported_all_data = TRUE;
+++ }else {
+++ if(!emulate_prot)
+++ CHECK_NOT_CALLED(ReportData2);
+++ CHECK_NOT_CALLED(ReportResult);
+++ }
+++ }while(hres == S_OK);
+++ if(hres == S_FALSE)
+++ wait_for_switch = FALSE;
+++ }else {
+++ CHECK_EXPECT(ReportData2);
+++
+++ ok(grfBSCF & BSCF_LASTDATANOTIFICATION, "grfBSCF = %08x\n", grfBSCF);
+++
+++ read = 0xdeadbeef;
+++ if(emulate_prot)
+++ SET_EXPECT(Read2);
+++ hres = IInternetProtocol_Read(binding_test ? binding_protocol : async_protocol, expect_pv = buf, sizeof(buf), &read);
+++ if(emulate_prot)
+++ CHECK_CALLED(Read2);
+++ ok(hres == S_FALSE, "Read returned: %08x, expected E_FALSE\n", hres);
+++ ok(!read, "read = %d\n", read);
+++ }
+++ }else if(!binding_test && (tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST
+++ || tested_protocol == FTP_TEST)) {
+++ if(!(grfBSCF & BSCF_LASTDATANOTIFICATION) || (grfBSCF & BSCF_DATAFULLYAVAILABLE))
+++ CHECK_EXPECT(ReportData);
+++ else if (http_post_test)
+++ ok(ulProgress == 13, "Read %u bytes instead of 13\n", ulProgress);
+++
+++ ok(ulProgress, "ulProgress == 0\n");
+++
+++ if(first_data_notif) {
+++ ok(grfBSCF == BSCF_FIRSTDATANOTIFICATION
+++ || grfBSCF == (BSCF_LASTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE),
+++ "grcfBSCF = %08x\n", grfBSCF);
+++ first_data_notif = FALSE;
+++ } else {
+++ ok(grfBSCF == BSCF_INTERMEDIATEDATANOTIFICATION
+++ || grfBSCF == (BSCF_LASTDATANOTIFICATION|BSCF_INTERMEDIATEDATANOTIFICATION)
+++ || broken(grfBSCF == (BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION)),
+++ "grcfBSCF = %08x\n", grfBSCF);
+++ }
+++
+++ if(!(bindf & BINDF_FROMURLMON) &&
+++ !(grfBSCF & BSCF_LASTDATANOTIFICATION)) {
- } else todo_wine {
- CHECK_NOT_CALLED(ReportProgress_FINDINGRESOURCE);
- CHECK_NOT_CALLED(ReportProgress_CONNECTING);
++++ if(state == STATE_CONNECTING) {
++++ state = STATE_DOWNLOADING;
+++ if(http_is_first) {
+++ CHECK_CALLED(ReportProgress_FINDINGRESOURCE);
+++ CHECK_CALLED(ReportProgress_CONNECTING);
- if(SUCCEEDED(hrResult) || tested_protocol == FTP_TEST)
+++ }
+++ CHECK_CALLED(ReportProgress_SENDINGREQUEST);
+++ CHECK_CALLED(OnResponse);
+++ CHECK_CALLED(ReportProgress_RAWMIMETYPE);
+++ }
+++ SetEvent(event_complete);
+++ }
+++ }else if(!read_report_data) {
+++ BYTE buf[1000];
+++ ULONG read;
+++ HRESULT hres;
+++
+++ CHECK_EXPECT(ReportData);
+++
+++ if(tested_protocol != BIND_TEST) {
+++ do {
+++ if(mimefilter_test)
+++ SET_EXPECT(MimeFilter_Read);
+++ else if(rec_depth > 1)
+++ SET_EXPECT(Read2);
+++ else
+++ SET_EXPECT(Read);
+++ hres = IInternetProtocol_Read(binding_protocol, expect_pv=buf, sizeof(buf), &read);
+++ if(mimefilter_test)
+++ CHECK_CALLED(MimeFilter_Read);
+++ else if(rec_depth > 1)
+++ CHECK_CALLED(Read2);
+++ else
+++ CHECK_CALLED(Read);
+++ }while(hres == S_OK);
+++ }
+++ }
+++
+++ rec_depth--;
+++ return S_OK;
+++}
+++
+++static HRESULT WINAPI ProtocolSink_ReportResult(IInternetProtocolSink *iface, HRESULT hrResult,
+++ DWORD dwError, LPCWSTR szResult)
+++{
+++ CHECK_EXPECT(ReportResult);
+++
+++ if(tested_protocol == FTP_TEST)
+++ ok(hrResult == E_PENDING || hrResult == S_OK, "hrResult = %08x, expected E_PENDING or S_OK\n", hrResult);
+++ else
+++ ok(hrResult == expect_hrResult, "hrResult = %08x, expected: %08x\n",
+++ hrResult, expect_hrResult);
- broken(tested_protocol == MK_TEST), /* Win9x, WinME and NT4 */
++++ if(SUCCEEDED(hrResult) || tested_protocol == FTP_TEST || test_abort)
+++ ok(dwError == ERROR_SUCCESS, "dwError = %d, expected ERROR_SUCCESS\n", dwError);
+++ else
+++ ok(dwError != ERROR_SUCCESS ||
- static const CHAR szPostData[] = "mode=Test";
-
++++ broken(tested_protocol == MK_TEST), /* WinME and NT4 */
+++ "dwError == ERROR_SUCCESS\n");
+++ ok(!szResult, "szResult != NULL\n");
+++
+++ if(direct_read)
+++ SET_EXPECT(ReportData); /* checked after main loop */
+++
+++ return S_OK;
+++}
+++
+++static IInternetProtocolSinkVtbl protocol_sink_vtbl = {
+++ ProtocolSink_QueryInterface,
+++ ProtocolSink_AddRef,
+++ ProtocolSink_Release,
+++ ProtocolSink_Switch,
+++ ProtocolSink_ReportProgress,
+++ ProtocolSink_ReportData,
+++ ProtocolSink_ReportResult
+++};
+++
+++static IInternetProtocolSink protocol_sink = { &protocol_sink_vtbl };
+++
+++static HRESULT WINAPI MimeProtocolSink_QueryInterface(IInternetProtocolSink *iface, REFIID riid, void **ppv)
+++{
+++ ok(0, "unexpected call\n");
+++ return E_NOTIMPL;
+++}
+++
+++static ULONG WINAPI MimeProtocolSink_AddRef(IInternetProtocolSink *iface)
+++{
+++ return 2;
+++}
+++
+++static ULONG WINAPI MimeProtocolSink_Release(IInternetProtocolSink *iface)
+++{
+++ return 1;
+++}
+++
+++static HRESULT WINAPI MimeProtocolSink_Switch(IInternetProtocolSink *iface, PROTOCOLDATA *pProtocolData)
+++{
+++ HRESULT hres;
+++
+++ CHECK_EXPECT(MimeFilter_Switch);
+++
+++ SET_EXPECT(Switch);
+++ hres = IInternetProtocolSink_Switch(filtered_sink, pProtocolData);
+++ ok(hres == S_OK, "Switch failed: %08x\n", hres);
+++ CHECK_CALLED(Switch);
+++
+++ return S_OK;
+++}
+++
+++static HRESULT WINAPI MimeProtocolSink_ReportProgress(IInternetProtocolSink *iface, ULONG ulStatusCode,
+++ LPCWSTR szStatusText)
+++{
+++ CHECK_EXPECT(MimeFilter_ReportProgress);
+++ return S_OK;
+++}
+++
+++static HRESULT WINAPI MimeProtocolSink_ReportData(IInternetProtocolSink *iface, DWORD grfBSCF,
+++ ULONG ulProgress, ULONG ulProgressMax)
+++{
+++ DWORD read = 0;
+++ BYTE buf[8192];
+++ HRESULT hres;
+++
+++ CHECK_EXPECT(MimeFilter_ReportData);
+++
+++ if(!filter_state) {
+++ SET_EXPECT(Read);
+++ hres = IInternetProtocol_Read(filtered_protocol, buf, sizeof(buf), &read);
+++ if(tested_protocol == HTTP_TEST)
+++ ok(hres == S_OK || hres == E_PENDING || hres == S_FALSE, "Read failed: %08x\n", hres);
+++ else
+++ ok(hres == S_OK, "Read failed: %08x\n", hres);
+++ CHECK_CALLED(Read);
+++
+++ SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
+++ hres = IInternetProtocolSink_ReportProgress(filtered_sink, BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE, text_htmlW);
+++ ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
+++ CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
+++
+++ /* FIXME: test BINDSTATUS_CACHEFILENAMEAVAILABLE */
+++ }
+++
+++ if(!read_report_data)
+++ SET_EXPECT(ReportData);
+++ hres = IInternetProtocolSink_ReportData(filtered_sink, grfBSCF, ulProgress, ulProgressMax);
+++ ok(hres == S_OK, "ReportData failed: %08x\n", hres);
+++ if(!read_report_data)
+++ CHECK_CALLED(ReportData);
+++
+++ if(!filter_state)
+++ filter_state = 1;
+++
+++ return S_OK;
+++}
+++
+++static HRESULT WINAPI MimeProtocolSink_ReportResult(IInternetProtocolSink *iface, HRESULT hrResult,
+++ DWORD dwError, LPCWSTR szResult)
+++{
+++ HRESULT hres;
+++
+++ CHECK_EXPECT(MimeFilter_ReportResult);
+++
+++ ok(hrResult == S_OK, "hrResult = %08x\n", hrResult);
+++ ok(dwError == ERROR_SUCCESS, "dwError = %u\n", dwError);
+++ ok(!szResult, "szResult = %s\n", wine_dbgstr_w(szResult));
+++
+++ SET_EXPECT(ReportResult);
+++ hres = IInternetProtocolSink_ReportResult(filtered_sink, hrResult, dwError, szResult);
+++ ok(SUCCEEDED(hres), "ReportResult failed: %08x\n", hres);
+++ CHECK_CALLED(ReportResult);
+++
+++ return S_OK;
+++}
+++
+++static IInternetProtocolSinkVtbl mime_protocol_sink_vtbl = {
+++ MimeProtocolSink_QueryInterface,
+++ MimeProtocolSink_AddRef,
+++ MimeProtocolSink_Release,
+++ MimeProtocolSink_Switch,
+++ MimeProtocolSink_ReportProgress,
+++ MimeProtocolSink_ReportData,
+++ MimeProtocolSink_ReportResult
+++};
+++
+++static IInternetProtocolSink mime_protocol_sink = { &mime_protocol_sink_vtbl };
+++
+++static HRESULT QueryInterface(REFIID riid, void **ppv)
+++{
+++ static const IID IID_undocumented = {0x58DFC7D0,0x5381,0x43E5,{0x9D,0x72,0x4C,0xDD,0xE4,0xCB,0x0F,0x1A}};
+++
+++ *ppv = NULL;
+++
+++ if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocolSink, riid))
+++ *ppv = &protocol_sink;
+++ if(IsEqualGUID(&IID_IServiceProvider, riid))
+++ *ppv = &service_provider;
+++ if(IsEqualGUID(&IID_IUriContainer, riid))
+++ return E_NOINTERFACE; /* TODO */
+++
+++ /* NOTE: IE8 queries for undocumented {58DFC7D0-5381-43E5-9D72-4CDDE4CB0F1A} interface. */
+++ if(IsEqualGUID(&IID_undocumented, riid))
+++ return E_NOINTERFACE;
+++
+++ if(*ppv)
+++ return S_OK;
+++
+++ ok(0, "unexpected call %s\n", debugstr_guid(riid));
+++ return E_NOINTERFACE;
+++}
+++
+++static HRESULT WINAPI BindInfo_QueryInterface(IInternetBindInfo *iface, REFIID riid, void **ppv)
+++{
+++ if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetBindInfo, riid)) {
+++ *ppv = iface;
+++ return S_OK;
+++ }
+++ return E_NOINTERFACE;
+++}
+++
+++static ULONG WINAPI BindInfo_AddRef(IInternetBindInfo *iface)
+++{
+++ return 2;
+++}
+++
+++static ULONG WINAPI BindInfo_Release(IInternetBindInfo *iface)
+++{
+++ return 1;
+++}
+++
+++static HRESULT WINAPI BindInfo_GetBindInfo(IInternetBindInfo *iface, DWORD *grfBINDF, BINDINFO *pbindinfo)
+++{
+++ DWORD cbSize;
+++
- if (http_post_test)
+++ CHECK_EXPECT(GetBindInfo);
+++
+++ ok(grfBINDF != NULL, "grfBINDF == NULL\n");
+++ ok(pbindinfo != NULL, "pbindinfo == NULL\n");
+++ ok(pbindinfo->cbSize == sizeof(BINDINFO), "wrong size of pbindinfo: %d\n", pbindinfo->cbSize);
+++
+++ *grfBINDF = bindf;
+++ if(binding_test)
+++ *grfBINDF |= BINDF_FROMURLMON;
+++ cbSize = pbindinfo->cbSize;
+++ memset(pbindinfo, 0, cbSize);
+++ pbindinfo->cbSize = cbSize;
+++
- /* Must be GMEM_FIXED, GMEM_MOVABLE does not work properly
- * with urlmon on native (Win98 and WinXP) */
- U(pbindinfo->stgmedData).hGlobal = GlobalAlloc(GPTR, sizeof(szPostData));
- if (!U(pbindinfo->stgmedData).hGlobal)
- {
- http_post_test = FALSE;
- skip("Out of memory\n");
- return E_OUTOFMEMORY;
- }
- lstrcpy((LPSTR)U(pbindinfo->stgmedData).hGlobal, szPostData);
- pbindinfo->cbstgmedData = sizeof(szPostData)-1;
++++ if(http_post_test)
+++ {
- pbindinfo->stgmedData.tymed = TYMED_HGLOBAL;
++++ pbindinfo->cbstgmedData = sizeof(post_data)-1;
+++ pbindinfo->dwBindVerb = BINDVERB_POST;
- static ULONG WINAPI Protocol_AddRef(IInternetProtocol *iface)
++++ pbindinfo->stgmedData.tymed = http_post_test;
++++
++++ if(http_post_test == TYMED_HGLOBAL) {
++++ HGLOBAL data;
++++
++++ /* Must be GMEM_FIXED, GMEM_MOVABLE does not work properly */
++++ data = GlobalAlloc(GPTR, sizeof(post_data));
++++ memcpy(data, post_data, sizeof(post_data));
++++ U(pbindinfo->stgmedData).hGlobal = data;
++++ }else {
++++ IStream *post_stream;
++++ HGLOBAL data;
++++ HRESULT hres;
++++
++++ if(0) {
++++ /* Must be GMEM_FIXED, GMEM_MOVABLE does not work properly */
++++ data = GlobalAlloc(GPTR, sizeof(post_data));
++++ memcpy(data, post_data, sizeof(post_data));
++++ U(pbindinfo->stgmedData).hGlobal = data;
++++
++++ hres = CreateStreamOnHGlobal(data, FALSE, &post_stream);
++++ ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
++++
++++ U(pbindinfo->stgmedData).pstm =post_stream;/* &Stream; */
++++ }
++++ U(pbindinfo->stgmedData).pstm = &Stream;
++++ }
+++ }
+++
+++ return S_OK;
+++}
+++
+++static HRESULT WINAPI BindInfo_GetBindString(IInternetBindInfo *iface, ULONG ulStringType,
+++ LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
+++{
+++ ok(ppwzStr != NULL, "ppwzStr == NULL\n");
+++ ok(pcElFetched != NULL, "pcElFetched == NULL\n");
+++
+++ switch(ulStringType) {
+++ case BINDSTRING_ACCEPT_MIMES:
+++ CHECK_EXPECT(GetBindString_ACCEPT_MIMES);
+++ ok(cEl == 256, "cEl=%d, expected 256\n", cEl);
+++ if(pcElFetched) {
+++ ok(*pcElFetched == 256, "*pcElFetched=%d, expected 256\n", *pcElFetched);
+++ *pcElFetched = 1;
+++ }
+++ if(ppwzStr) {
+++ *ppwzStr = CoTaskMemAlloc(sizeof(acc_mimeW));
+++ memcpy(*ppwzStr, acc_mimeW, sizeof(acc_mimeW));
+++ }
+++ return S_OK;
+++ case BINDSTRING_USER_AGENT:
+++ CHECK_EXPECT(GetBindString_USER_AGENT);
+++ ok(cEl == 1, "cEl=%d, expected 1\n", cEl);
+++ if(pcElFetched) {
+++ ok(*pcElFetched == 0, "*pcElFetch=%d, expectd 0\n", *pcElFetched);
+++ *pcElFetched = 1;
+++ }
+++ if(ppwzStr) {
+++ *ppwzStr = CoTaskMemAlloc(sizeof(user_agentW));
+++ memcpy(*ppwzStr, user_agentW, sizeof(user_agentW));
+++ }
+++ return S_OK;
+++ case BINDSTRING_POST_COOKIE:
+++ CHECK_EXPECT(GetBindString_POST_COOKIE);
+++ ok(cEl == 1, "cEl=%d, expected 1\n", cEl);
+++ if(pcElFetched)
+++ ok(*pcElFetched == 0, "*pcElFetch=%d, expectd 0\n", *pcElFetched);
+++ return S_OK;
+++ case BINDSTRING_URL: {
+++ DWORD size;
+++
+++ CHECK_EXPECT(GetBindString_URL);
+++ ok(cEl == 1, "cEl=%d, expected 1\n", cEl);
+++ ok(*pcElFetched == 0, "*pcElFetch=%d, expectd 0\n", *pcElFetched);
+++ *pcElFetched = 1;
+++
+++ size = (lstrlenW(binding_urls[tested_protocol])+1)*sizeof(WCHAR);
+++ *ppwzStr = CoTaskMemAlloc(size);
+++ memcpy(*ppwzStr, binding_urls[tested_protocol], size);
+++ return S_OK;
+++ }
+++ default:
+++ ok(0, "unexpected call\n");
+++ }
+++
+++ return E_NOTIMPL;
+++}
+++
+++static IInternetBindInfoVtbl bind_info_vtbl = {
+++ BindInfo_QueryInterface,
+++ BindInfo_AddRef,
+++ BindInfo_Release,
+++ BindInfo_GetBindInfo,
+++ BindInfo_GetBindString
+++};
+++
+++static IInternetBindInfo bind_info = { &bind_info_vtbl };
+++
+++static HRESULT WINAPI InternetPriority_QueryInterface(IInternetPriority *iface,
+++ REFIID riid, void **ppv)
+++{
+++ ok(0, "unexpected call\n");
+++ return E_NOINTERFACE;
+++}
+++
+++static ULONG WINAPI InternetPriority_AddRef(IInternetPriority *iface)
+++{
+++ return 2;
+++}
+++
+++static ULONG WINAPI InternetPriority_Release(IInternetPriority *iface)
+++{
+++ return 1;
+++}
+++
+++static HRESULT WINAPI InternetPriority_SetPriority(IInternetPriority *iface, LONG nPriority)
+++{
+++ CHECK_EXPECT(SetPriority);
+++ ok(nPriority == ex_priority, "nPriority=%d\n", nPriority);
+++ return S_OK;
+++}
+++
+++static HRESULT WINAPI InternetPriority_GetPriority(IInternetPriority *iface, LONG *pnPriority)
+++{
+++ ok(0, "unexpected call\n");
+++ return E_NOTIMPL;
+++}
+++
+++
+++static const IInternetPriorityVtbl InternetPriorityVtbl = {
+++ InternetPriority_QueryInterface,
+++ InternetPriority_AddRef,
+++ InternetPriority_Release,
+++ InternetPriority_SetPriority,
+++ InternetPriority_GetPriority
+++};
+++
+++static IInternetPriority InternetPriority = { &InternetPriorityVtbl };
+++
- static ULONG WINAPI Protocol_Release(IInternetProtocol *iface)
++++static ULONG WINAPI Protocol_AddRef(IInternetProtocolEx *iface)
+++{
+++ return 2;
+++}
+++
- static HRESULT WINAPI Protocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
++++static ULONG WINAPI Protocol_Release(IInternetProtocolEx *iface)
+++{
+++ return 1;
+++}
+++
- ok(0, "unexpected call\n");
- return E_NOTIMPL;
++++static HRESULT WINAPI Protocol_Abort(IInternetProtocolEx *iface, HRESULT hrReason,
+++ DWORD dwOptions)
+++{
- static HRESULT WINAPI Protocol_Suspend(IInternetProtocol *iface)
++++ HRESULT hres;
++++
++++ CHECK_EXPECT(Abort);
++++
++++ SET_EXPECT(ReportResult);
++++ hres = IInternetProtocolSink_ReportResult(binding_sink, S_OK, ERROR_SUCCESS, NULL);
++++ ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
++++ CHECK_CALLED(ReportResult);
++++
++++ return S_OK;
+++}
+++
- static HRESULT WINAPI Protocol_Resume(IInternetProtocol *iface)
++++static HRESULT WINAPI Protocol_Suspend(IInternetProtocolEx *iface)
+++{
+++ ok(0, "unexpected call\n");
+++ return E_NOTIMPL;
+++}
+++
- static HRESULT WINAPI Protocol_Seek(IInternetProtocol *iface,
++++static HRESULT WINAPI Protocol_Resume(IInternetProtocolEx *iface)
+++{
+++ ok(0, "unexpected call\n");
+++ return E_NOTIMPL;
+++}
+++
- static HRESULT WINAPI ProtocolEmul_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
++++static HRESULT WINAPI Protocol_Seek(IInternetProtocolEx *iface,
+++ LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
+++{
+++ ok(0, "unexpected call\n");
+++ return E_NOTIMPL;
+++}
+++
- trace("IID_IInternetProtocolEx not supported\n");
++++static HRESULT WINAPI ProtocolEmul_QueryInterface(IInternetProtocolEx *iface, REFIID riid, void **ppv)
+++{
+++ if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocol, riid)) {
+++ *ppv = iface;
+++ return S_OK;
+++ }
+++
+++ if(IsEqualGUID(&IID_IInternetProtocolEx, riid)) {
- static HRESULT WINAPI ProtocolEmul_Start(IInternetProtocol *iface, LPCWSTR szUrl,
- IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
- DWORD grfPI, HANDLE_PTR dwReserved)
++++ if(impl_protex) {
++++ *ppv = iface;
++++ return S_OK;
++++ }
+++ *ppv = NULL;
+++ return E_NOINTERFACE;
+++ }
+++
+++ if(IsEqualGUID(&IID_IInternetPriority, riid)) {
+++ *ppv = &InternetPriority;
+++ return S_OK;
+++ }
+++
+++ if(IsEqualGUID(&IID_IWinInetInfo, riid)) {
+++ CHECK_EXPECT(QueryInterface_IWinInetInfo);
+++ *ppv = NULL;
+++ return E_NOINTERFACE;
+++ }
+++
+++ if(IsEqualGUID(&IID_IWinInetHttpInfo, riid)) {
+++ CHECK_EXPECT(QueryInterface_IWinInetHttpInfo);
+++ *ppv = NULL;
+++ return E_NOINTERFACE;
+++ }
+++
+++ ok(0, "unexpected riid %s\n", debugstr_guid(riid));
+++ *ppv = NULL;
+++ return E_NOINTERFACE;
+++}
+++
+++static DWORD WINAPI thread_proc(PVOID arg)
+++{
+++ HRESULT hres;
+++
+++ memset(&protocoldata, -1, sizeof(protocoldata));
+++
+++ prot_state = 0;
+++
+++ SET_EXPECT(ReportProgress_FINDINGRESOURCE);
+++ hres = IInternetProtocolSink_ReportProgress(binding_sink,
+++ BINDSTATUS_FINDINGRESOURCE, hostW);
+++ CHECK_CALLED(ReportProgress_FINDINGRESOURCE);
+++ ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
+++
+++ SET_EXPECT(ReportProgress_CONNECTING);
+++ hres = IInternetProtocolSink_ReportProgress(binding_sink,
+++ BINDSTATUS_CONNECTING, winehq_ipW);
+++ CHECK_CALLED(ReportProgress_CONNECTING);
+++ ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
+++
+++ SET_EXPECT(ReportProgress_SENDINGREQUEST);
+++ hres = IInternetProtocolSink_ReportProgress(binding_sink,
+++ BINDSTATUS_SENDINGREQUEST, NULL);
+++ CHECK_CALLED(ReportProgress_SENDINGREQUEST);
+++ ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
+++
+++ prot_state = 1;
+++ SET_EXPECT(Switch);
+++ hres = IInternetProtocolSink_Switch(binding_sink, &protocoldata);
+++ CHECK_CALLED(Switch);
+++ ok(hres == S_OK, "Switch failed: %08x\n", hres);
+++
+++ if(!short_read) {
+++ prot_state = 2;
+++ if(mimefilter_test)
+++ SET_EXPECT(MimeFilter_Switch);
+++ else
+++ SET_EXPECT(Switch);
+++ hres = IInternetProtocolSink_Switch(binding_sink, &protocoldata);
+++ ok(hres == S_OK, "Switch failed: %08x\n", hres);
+++ if(mimefilter_test)
+++ CHECK_CALLED(MimeFilter_Switch);
+++ else
+++ CHECK_CALLED(Switch);
+++
++++ if(test_abort) {
++++ SetEvent(event_complete);
++++ return 0;
++++ }
++++
+++ prot_state = 2;
+++ if(mimefilter_test)
+++ SET_EXPECT(MimeFilter_Switch);
+++ else
+++ SET_EXPECT(Switch);
+++ hres = IInternetProtocolSink_Switch(binding_sink, &protocoldata);
+++ ok(hres == S_OK, "Switch failed: %08x\n", hres);
+++ if(mimefilter_test)
+++ CHECK_CALLED(MimeFilter_Switch);
+++ else
+++ CHECK_CALLED(Switch);
+++
+++ prot_state = 3;
+++ if(mimefilter_test)
+++ SET_EXPECT(MimeFilter_Switch);
+++ else
+++ SET_EXPECT(Switch);
+++ hres = IInternetProtocolSink_Switch(binding_sink, &protocoldata);
+++ ok(hres == S_OK, "Switch failed: %08x\n", hres);
+++ if(mimefilter_test)
+++ CHECK_CALLED(MimeFilter_Switch);
+++ else
+++ CHECK_CALLED(Switch);
+++ }
+++
+++ SetEvent(event_complete);
+++
+++ return 0;
+++}
+++
- CHECK_EXPECT(Start);
-
++++static void protocol_start(IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo, DWORD pi)
+++{
+++ BINDINFO bindinfo, exp_bindinfo;
+++ DWORD cbindf = 0;
+++ HRESULT hres;
+++
- ok(!grfPI, "grfPI = %x\n", grfPI);
- ok(!dwReserved, "dwReserved = %lx\n", dwReserved);
+++ ok(pOIProtSink != NULL, "pOIProtSink == NULL\n");
+++ ok(pOIBindInfo != NULL, "pOIBindInfo == NULL\n");
+++ ok(pOIProtSink != &protocol_sink, "unexpected pOIProtSink\n");
+++ ok(pOIBindInfo != &bind_info, "unexpected pOIBindInfo\n");
- ok(!strcmp_ww(ua, user_agentW), "unexpected user agent %s\n", wine_dbgstr_w(ua));
++++ ok(!pi, "pi = %x\n", pi);
+++
+++ if(binding_test)
+++ ok(pOIProtSink == binding_sink, "pOIProtSink != binding_sink\n");
+++
+++ memset(&bindinfo, 0, sizeof(bindinfo));
+++ bindinfo.cbSize = sizeof(bindinfo);
+++ memcpy(&exp_bindinfo, &bindinfo, sizeof(bindinfo));
+++ SET_EXPECT(GetBindInfo);
+++ hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &cbindf, &bindinfo);
+++ ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
+++ CHECK_CALLED(GetBindInfo);
+++ ok(cbindf == (bindf|BINDF_FROMURLMON), "bindf = %x, expected %x\n",
+++ cbindf, (bindf|BINDF_FROMURLMON));
+++ ok(!memcmp(&exp_bindinfo, &bindinfo, sizeof(bindinfo)), "unexpected bindinfo\n");
+++ pReleaseBindInfo(&bindinfo);
+++
+++ SET_EXPECT(ReportProgress_SENDINGREQUEST);
+++ hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_SENDINGREQUEST, emptyW);
+++ ok(hres == S_OK, "ReportProgress(BINDSTATUS_SENDINGREQUEST) failed: %08x\n", hres);
+++ CHECK_CALLED(ReportProgress_SENDINGREQUEST);
+++
+++ if(tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST) {
+++ IServiceProvider *service_provider;
+++ IHttpNegotiate *http_negotiate;
+++ IHttpNegotiate2 *http_negotiate2;
+++ LPWSTR ua = (LPWSTR)0xdeadbeef, accept_mimes[256];
+++ LPWSTR additional_headers = NULL;
+++ BYTE sec_id[100];
+++ DWORD fetched = 0, size = 100;
+++ DWORD tid;
+++
+++ SET_EXPECT(GetBindString_USER_AGENT);
+++ hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_USER_AGENT,
+++ &ua, 1, &fetched);
+++ CHECK_CALLED(GetBindString_USER_AGENT);
+++ ok(hres == S_OK, "GetBindString(BINDSTRING_USER_AGETNT) failed: %08x\n", hres);
+++ ok(fetched == 1, "fetched = %d, expected 254\n", fetched);
+++ ok(ua != NULL, "ua = %p\n", ua);
- ok(!strcmp_ww(acc_mimeW, accept_mimes[0]), "unexpected mimes %s\n", wine_dbgstr_w(accept_mimes[0]));
++++ ok(!lstrcmpW(ua, user_agentW), "unexpected user agent %s\n", wine_dbgstr_w(ua));
+++ CoTaskMemFree(ua);
+++
+++ fetched = 256;
+++ SET_EXPECT(GetBindString_ACCEPT_MIMES);
+++ hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_ACCEPT_MIMES,
+++ accept_mimes, 256, &fetched);
+++ CHECK_CALLED(GetBindString_ACCEPT_MIMES);
+++
+++ ok(hres == S_OK,
+++ "GetBindString(BINDSTRING_ACCEPT_MIMES) failed: %08x\n", hres);
+++ ok(fetched == 1, "fetched = %d, expected 1\n", fetched);
-
- return S_OK;
++++ ok(!lstrcmpW(acc_mimeW, accept_mimes[0]), "unexpected mimes %s\n", wine_dbgstr_w(accept_mimes[0]));
+++ CoTaskMemFree(accept_mimes[0]);
+++
+++ hres = IInternetBindInfo_QueryInterface(pOIBindInfo, &IID_IServiceProvider,
+++ (void**)&service_provider);
+++ ok(hres == S_OK, "QueryInterface failed: %08x\n", hres);
+++
+++ SET_EXPECT(QueryService_HttpNegotiate);
+++ hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
+++ &IID_IHttpNegotiate, (void**)&http_negotiate);
+++ CHECK_CALLED(QueryService_HttpNegotiate);
+++ ok(hres == S_OK, "QueryService failed: %08x\n", hres);
+++
+++ SET_EXPECT(BeginningTransaction);
+++ hres = IHttpNegotiate_BeginningTransaction(http_negotiate, binding_urls[tested_protocol],
+++ NULL, 0, &additional_headers);
+++ CHECK_CALLED(BeginningTransaction);
+++ IHttpNegotiate_Release(http_negotiate);
+++ ok(hres == S_OK, "BeginningTransction failed: %08x\n", hres);
+++ ok(additional_headers == NULL, "additional_headers=%p\n", additional_headers);
+++
+++ SET_EXPECT(QueryService_HttpNegotiate);
+++ hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate2,
+++ &IID_IHttpNegotiate2, (void**)&http_negotiate2);
+++ CHECK_CALLED(QueryService_HttpNegotiate);
+++ ok(hres == S_OK, "QueryService failed: %08x\n", hres);
+++
+++ size = 512;
+++ SET_EXPECT(GetRootSecurityId);
+++ hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, sec_id, &size, 0);
+++ CHECK_CALLED(GetRootSecurityId);
+++ IHttpNegotiate2_Release(http_negotiate2);
+++ ok(hres == E_FAIL, "GetRootSecurityId failed: %08x, expected E_FAIL\n", hres);
+++ ok(size == 13, "size=%d\n", size);
+++
+++ IServiceProvider_Release(service_provider);
+++
+++ CreateThread(NULL, 0, thread_proc, NULL, 0, &tid);
- BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION, 13, 13);
++++ return;
+++ }
+++
+++ SET_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
+++ hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
+++ BINDSTATUS_CACHEFILENAMEAVAILABLE, expect_wsz = emptyW);
+++ ok(hres == S_OK, "ReportProgress(BINDSTATUS_CACHEFILENAMEAVAILABLE) failed: %08x\n", hres);
+++ CHECK_CALLED(ReportProgress_CACHEFILENAMEAVAILABLE);
+++
+++ if(mimefilter_test) {
+++ SET_EXPECT(MimeFilter_CreateInstance);
+++ SET_EXPECT(MimeFilter_Start);
+++ SET_EXPECT(ReportProgress_LOADINGMIMEHANDLER);
+++ }
+++ SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
+++ hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE,
+++ mimefilter_test ? gzipW : (expect_wsz = text_htmlW));
+++ ok(hres == S_OK,
+++ "ReportProgress(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE) failed: %08x\n", hres);
+++ if(mimefilter_test) {
+++ CHECK_CALLED(MimeFilter_CreateInstance);
+++ CHECK_CALLED(MimeFilter_Start);
+++ CHECK_CALLED(ReportProgress_LOADINGMIMEHANDLER);
+++ todo_wine CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
+++ }else {
+++ CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
+++ }
+++
+++ if(mimefilter_test)
+++ SET_EXPECT(MimeFilter_ReportData);
+++ else
+++ SET_EXPECT(ReportData);
+++ hres = IInternetProtocolSink_ReportData(pOIProtSink,
- static HRESULT WINAPI ProtocolEmul_Continue(IInternetProtocol *iface,
++++ BSCF_FIRSTDATANOTIFICATION | (tested_protocol == ITS_TEST ? BSCF_DATAFULLYAVAILABLE : BSCF_LASTDATANOTIFICATION),
++++ 13, 13);
+++ ok(hres == S_OK, "ReportData failed: %08x\n", hres);
+++ if(mimefilter_test)
+++ CHECK_CALLED(MimeFilter_ReportData);
+++ else
+++ CHECK_CALLED(ReportData);
+++
++++ if(tested_protocol == ITS_TEST) {
++++ SET_EXPECT(ReportData);
++++ hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_BEGINDOWNLOADDATA, NULL);
++++ ok(hres == S_OK, "ReportProgress(BINDSTATUS_BEGINDOWNLOADDATA) failed: %08x\n", hres);
++++ CHECK_CALLED(ReportData);
++++ }
++++
+++ if(tested_protocol == BIND_TEST) {
+++ hres = IInternetProtocol_Terminate(binding_protocol, 0);
+++ ok(hres == E_FAIL, "Termiante failed: %08x\n", hres);
+++ }
+++
+++ if(mimefilter_test)
+++ SET_EXPECT(MimeFilter_ReportResult);
+++ else
+++ SET_EXPECT(ReportResult);
+++ hres = IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
+++ ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
+++ if(mimefilter_test)
+++ CHECK_CALLED(MimeFilter_ReportResult);
+++ else
+++ CHECK_CALLED(ReportResult);
++++}
+++
++++static HRESULT WINAPI ProtocolEmul_Start(IInternetProtocolEx *iface, LPCWSTR szUrl,
++++ IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
++++ DWORD grfPI, HANDLE_PTR dwReserved)
++++{
++++ CHECK_EXPECT(Start);
++++
++++ ok(!dwReserved, "dwReserved = %lx\n", dwReserved);
++++ protocol_start(pOIProtSink, pOIBindInfo, grfPI);
+++ return S_OK;
+++}
+++
- static HRESULT WINAPI ProtocolEmul_Terminate(IInternetProtocol *iface, DWORD dwOptions)
++++static HRESULT WINAPI ProtocolEmul_Continue(IInternetProtocolEx *iface,
+++ PROTOCOLDATA *pProtocolData)
+++{
+++ DWORD bscf = 0, pr;
+++ HRESULT hres;
+++
+++ CHECK_EXPECT(Continue);
+++
+++ ok(pProtocolData != NULL, "pProtocolData == NULL\n");
+++ if(!pProtocolData || tested_protocol == BIND_TEST)
+++ return S_OK;
+++ if(binding_test) {
+++ ok(pProtocolData != &protocoldata, "pProtocolData == &protocoldata\n");
+++ ok(pProtocolData->grfFlags == protocoldata.grfFlags, "grfFlags wrong %x/%x\n",
+++ pProtocolData->grfFlags, protocoldata.grfFlags );
+++ ok(pProtocolData->dwState == protocoldata.dwState, "dwState wrong %x/%x\n",
+++ pProtocolData->dwState, protocoldata.dwState );
+++ ok(pProtocolData->pData == protocoldata.pData, "pData wrong %p/%p\n",
+++ pProtocolData->pData, protocoldata.pData );
+++ ok(pProtocolData->cbData == protocoldata.cbData, "cbData wrong %x/%x\n",
+++ pProtocolData->cbData, protocoldata.cbData );
+++ }
+++
+++ switch(prot_state) {
+++ case 1: {
+++ IServiceProvider *service_provider;
+++ IHttpNegotiate *http_negotiate;
+++ static WCHAR header[] = {'?',0};
+++
+++ hres = IInternetProtocolSink_QueryInterface(binding_sink, &IID_IServiceProvider,
+++ (void**)&service_provider);
+++ ok(hres == S_OK, "Could not get IServiceProvicder\n");
+++
+++ SET_EXPECT(QueryService_HttpNegotiate);
+++ hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
+++ &IID_IHttpNegotiate, (void**)&http_negotiate);
+++ IServiceProvider_Release(service_provider);
+++ CHECK_CALLED(QueryService_HttpNegotiate);
+++ ok(hres == S_OK, "Could not get IHttpNegotiate\n");
+++
+++ SET_EXPECT(OnResponse);
+++ hres = IHttpNegotiate_OnResponse(http_negotiate, 200, header, NULL, NULL);
+++ IHttpNegotiate_Release(http_negotiate);
+++ CHECK_CALLED(OnResponse);
+++ IHttpNegotiate_Release(http_negotiate);
+++ ok(hres == S_OK, "OnResponse failed: %08x\n", hres);
+++
+++ if(mimefilter_test) {
+++ SET_EXPECT(MimeFilter_CreateInstance);
+++ SET_EXPECT(MimeFilter_Start);
+++ SET_EXPECT(ReportProgress_LOADINGMIMEHANDLER);
+++ }else if(!(pi & PI_MIMEVERIFICATION)) {
+++ SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
+++ }
+++ hres = IInternetProtocolSink_ReportProgress(binding_sink,
+++ BINDSTATUS_MIMETYPEAVAILABLE, mimefilter_test ? gzipW : text_htmlW);
+++ if(mimefilter_test) {
+++ CHECK_CALLED(MimeFilter_CreateInstance);
+++ CHECK_CALLED(MimeFilter_Start);
+++ CHECK_CALLED(ReportProgress_LOADINGMIMEHANDLER);
+++ }else if(!(pi & PI_MIMEVERIFICATION)) {
+++ CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
+++ }
+++ ok(hres == S_OK,
+++ "ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08x\n", hres);
+++
+++ bscf |= BSCF_FIRSTDATANOTIFICATION;
+++ break;
+++ }
+++ case 2:
+++ case 3:
+++ bscf = BSCF_INTERMEDIATEDATANOTIFICATION;
+++ break;
+++ }
+++
+++ pr = prot_read;
+++ if(mimefilter_test) {
+++ SET_EXPECT(MimeFilter_ReportData);
+++ }else if(pi & PI_MIMEVERIFICATION) {
+++ if(pr < 200)
+++ SET_EXPECT(Read); /* checked in ReportData for short_read */
+++ if(pr == 200) {
+++ if(!mimefilter_test)
+++ SET_EXPECT(Read); /* checked in BINDSTATUS_MIMETYPEAVAILABLE or ReportData */
+++ SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
+++ }
+++ if(pr >= 200)
+++ SET_EXPECT(ReportData);
+++ }else {
+++ SET_EXPECT(ReportData);
+++ }
+++
+++ hres = IInternetProtocolSink_ReportData(binding_sink, bscf, pr, 400);
+++ ok(hres == S_OK, "ReportData failed: %08x\n", hres);
+++
+++ if(mimefilter_test) {
+++ SET_EXPECT(MimeFilter_ReportData);
+++ }else if(pi & PI_MIMEVERIFICATION) {
+++ if(!short_read && pr < 200)
+++ CHECK_CALLED(Read);
+++ if(pr == 200) {
+++ CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
+++ }
+++ }else {
+++ CHECK_CALLED(ReportData);
+++ }
+++
+++ if(prot_state == 3)
+++ prot_state = 4;
+++
+++ return S_OK;
+++}
+++
- static HRESULT WINAPI ProtocolEmul_Read(IInternetProtocol *iface, void *pv,
++++static HRESULT WINAPI ProtocolEmul_Terminate(IInternetProtocolEx *iface, DWORD dwOptions)
+++{
+++ CHECK_EXPECT(Terminate);
+++ ok(!dwOptions, "dwOptions=%d\n", dwOptions);
+++ return S_OK;
+++}
+++
- static HRESULT WINAPI ProtocolEmul_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
++++static HRESULT WINAPI ProtocolEmul_Read(IInternetProtocolEx *iface, void *pv,
+++ ULONG cb, ULONG *pcbRead)
+++{
+++ if(read_report_data)
+++ CHECK_EXPECT2(Read2);
+++
+++ if(mimefilter_test || short_read) {
+++ if(!read_report_data)
+++ CHECK_EXPECT2(Read);
+++ }else if((pi & PI_MIMEVERIFICATION)) {
+++ if(!read_report_data)
+++ CHECK_EXPECT2(Read);
+++
+++ if(prot_read < 300) {
+++ ok(pv != expect_pv, "pv == expect_pv\n");
+++ if(prot_read < 300)
+++ ok(cb == 2048-prot_read, "cb=%d\n", cb);
+++ else
+++ ok(cb == 700, "cb=%d\n", cb);
+++ }else {
+++ ok(expect_pv <= pv && (BYTE*)pv < (BYTE*)expect_pv + cb, "pv != expect_pv\n");
+++ }
+++ }else {
+++ if(!read_report_data)
+++ CHECK_EXPECT(Read);
+++
+++ ok(pv == expect_pv, "pv != expect_pv\n");
+++ ok(cb == 1000, "cb=%d\n", cb);
+++ ok(!*pcbRead, "*pcbRead = %d\n", *pcbRead);
+++ }
+++ ok(pcbRead != NULL, "pcbRead == NULL\n");
+++
+++ if(prot_state == 3 || (short_read && prot_state != 4)) {
+++ HRESULT hres;
+++
+++ prot_state = 4;
+++ if(short_read) {
+++ SET_EXPECT(Read2); /* checked in BINDSTATUS_MIMETYPEAVAILABLE */
+++ SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
+++ }
+++ if(mimefilter_test)
+++ SET_EXPECT(MimeFilter_ReportData);
+++ else if(direct_read)
+++ SET_EXPECT(ReportData2);
+++ read_report_data++;
+++ hres = IInternetProtocolSink_ReportData(binding_sink,
+++ BSCF_LASTDATANOTIFICATION|BSCF_INTERMEDIATEDATANOTIFICATION, 0, 0);
+++ read_report_data--;
+++ ok(hres == S_OK, "ReportData failed: %08x\n", hres);
+++ if(short_read)
+++ CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
+++ if(mimefilter_test)
+++ CHECK_CALLED(MimeFilter_ReportData);
+++ else if(direct_read)
+++ CHECK_CALLED(ReportData2);
+++
+++ if(mimefilter_test)
+++ SET_EXPECT(MimeFilter_ReportResult);
+++ else
+++ SET_EXPECT(ReportResult);
+++ hres = IInternetProtocolSink_ReportResult(binding_sink, S_OK, ERROR_SUCCESS, NULL);
+++ ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
+++ if(mimefilter_test)
+++ CHECK_CALLED(MimeFilter_ReportResult);
+++ else
+++ CHECK_CALLED(ReportResult);
+++
+++ memset(pv, 'x', 100);
+++ prot_read += *pcbRead = 100;
+++ return S_OK;
+++ }if(prot_state == 4) {
+++ *pcbRead = 0;
+++ return S_FALSE;
+++ }
+++
+++ if((async_read_pending = !async_read_pending)) {
+++ *pcbRead = 0;
+++ return tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST ? E_PENDING : S_FALSE;
+++ }
+++
+++ memset(pv, 'x', 100);
+++ prot_read += *pcbRead = 100;
+++ return S_OK;
+++}
+++
- static HRESULT WINAPI ProtocolEmul_UnlockRequest(IInternetProtocol *iface)
++++static HRESULT WINAPI ProtocolEmul_LockRequest(IInternetProtocolEx *iface, DWORD dwOptions)
+++{
+++ CHECK_EXPECT(LockRequest);
+++ ok(dwOptions == 0, "dwOptions=%x\n", dwOptions);
+++ return S_OK;
+++}
+++
- static const IInternetProtocolVtbl ProtocolVtbl = {
++++static HRESULT WINAPI ProtocolEmul_UnlockRequest(IInternetProtocolEx *iface)
+++{
+++ CHECK_EXPECT(UnlockRequest);
+++ return S_OK;
+++}
+++
- ProtocolEmul_UnlockRequest
++++static HRESULT WINAPI ProtocolEmul_StartEx(IInternetProtocolEx *iface, IUri *pUri,
++++ IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
++++ DWORD grfPI, HANDLE *dwReserved)
++++{
++++ CHECK_EXPECT(StartEx);
++++ ok(!dwReserved, "dwReserved = %p\n", dwReserved);
++++ protocol_start(pOIProtSink, pOIBindInfo, grfPI);
++++ return S_OK;
++++}
++++
++++static const IInternetProtocolExVtbl ProtocolVtbl = {
+++ ProtocolEmul_QueryInterface,
+++ Protocol_AddRef,
+++ Protocol_Release,
+++ ProtocolEmul_Start,
+++ ProtocolEmul_Continue,
+++ Protocol_Abort,
+++ ProtocolEmul_Terminate,
+++ Protocol_Suspend,
+++ Protocol_Resume,
+++ ProtocolEmul_Read,
+++ Protocol_Seek,
+++ ProtocolEmul_LockRequest,
- static IInternetProtocol Protocol = { &ProtocolVtbl };
++++ ProtocolEmul_UnlockRequest,
++++ ProtocolEmul_StartEx
+++};
+++
- static HRESULT WINAPI MimeProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
++++static IInternetProtocolEx Protocol = { &ProtocolVtbl };
+++
- static HRESULT WINAPI MimeProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
++++static HRESULT WINAPI MimeProtocol_QueryInterface(IInternetProtocolEx *iface, REFIID riid, void **ppv)
+++{
+++ if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocol, riid)) {
+++ *ppv = iface;
+++ return S_OK;
+++ }
+++
+++ if(IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
+++ *ppv = &mime_protocol_sink;
+++ return S_OK;
+++ }
+++
+++ ok(0, "unexpected riid %s\n", debugstr_guid(riid));
+++ *ppv = NULL;
+++ return E_NOINTERFACE;
+++}
+++
- ok(!strcmp_ww(szUrl, gzipW), "wrong url %s\n", wine_dbgstr_w(szUrl));
++++static HRESULT WINAPI MimeProtocol_Start(IInternetProtocolEx *iface, LPCWSTR szUrl,
+++ IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
+++ DWORD grfPI, HANDLE_PTR dwReserved)
+++{
+++ PROTOCOLFILTERDATA *data;
+++ LPOLESTR url_str = NULL;
+++ DWORD fetched = 0;
+++ BINDINFO bindinfo;
+++ DWORD cbindf = 0;
+++ HRESULT hres;
+++
+++ CHECK_EXPECT(MimeFilter_Start);
+++
- ok(!strcmp_ww(url_str, binding_urls[tested_protocol]), "wrong url_str %s\n", wine_dbgstr_w(url_str));
++++ ok(!lstrcmpW(szUrl, gzipW), "wrong url %s\n", wine_dbgstr_w(szUrl));
+++ ok(grfPI == (PI_FILTER_MODE|PI_FORCE_ASYNC), "grfPI=%x, expected PI_FILTER_MODE|PI_FORCE_ASYNC\n", grfPI);
+++ ok(dwReserved, "dwReserved == 0\n");
+++ ok(pOIProtSink != NULL, "pOIProtSink == NULL\n");
+++ ok(pOIBindInfo != NULL, "pOIBindInfo == NULL\n");
+++
+++ if(binding_test) {
+++ ok(pOIProtSink != binding_sink, "pOIProtSink == protocol_sink\n");
+++ ok(pOIBindInfo == prot_bind_info, "pOIBindInfo != bind_info\n");
+++ }else {
+++ ok(pOIProtSink == &protocol_sink, "pOIProtSink != protocol_sink\n");
+++ ok(pOIBindInfo == &bind_info, "pOIBindInfo != bind_info\n");
+++ }
+++
+++ data = (void*)dwReserved;
+++ ok(data->cbSize == sizeof(*data), "data->cbSize = %d\n", data->cbSize);
+++ ok(!data->pProtocolSink, "data->pProtocolSink != NULL\n");
+++ ok(data->pProtocol != NULL, "data->pProtocol == NULL\n");
+++ ok(!data->pUnk, "data->pUnk != NULL\n");
+++ ok(!data->dwFilterFlags, "data->dwProtocolFlags = %x\n", data->dwFilterFlags);
+++ if(binding_test) {
+++ IInternetProtocolSink *prot_sink;
+++
+++ IInternetProtocol_QueryInterface(data->pProtocol, &IID_IInternetProtocolSink, (void**)&prot_sink);
+++ ok(prot_sink == pOIProtSink, "QI(data->pProtocol, IID_IInternetProtocolSink) != pOIProtSink\n");
+++ IInternetProtocolSink_Release(prot_sink);
+++
+++ ok(data->pProtocol != binding_protocol, "data->pProtocol == binding_protocol\n");
+++
+++ filtered_protocol = data->pProtocol;
+++ IInternetProtocol_AddRef(filtered_protocol);
+++ }else {
+++ IInternetProtocol *prot;
+++
+++ IInternetProtocol_QueryInterface(data->pProtocol, &IID_IInternetProtocol, (void**)&prot);
+++ ok(prot == async_protocol, "QI(data->pProtocol, IID_IInternetProtocol) != async_protocol\n");
+++ IInternetProtocol_Release(prot);
+++
+++ ok(data->pProtocol != async_protocol, "data->pProtocol == async_protocol\n");
+++ }
+++
+++ filtered_sink = pOIProtSink;
+++
+++ SET_EXPECT(ReportProgress_DECODING);
+++ hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_DECODING, gzipW);
+++ ok(hres == S_OK, "ReportProgress(BINDSTATUS_DECODING) failed: %08x\n", hres);
+++ CHECK_CALLED(ReportProgress_DECODING);
+++
+++ SET_EXPECT(GetBindInfo);
+++ memset(&bindinfo, 0, sizeof(bindinfo));
+++ bindinfo.cbSize = sizeof(bindinfo);
+++ hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &cbindf, &bindinfo);
+++ ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
+++ ok(cbindf == (bindf|BINDF_FROMURLMON), "cbindf = %x, expected %x\n", cbindf, bindf);
+++ CHECK_CALLED(GetBindInfo);
+++
+++ SET_EXPECT(GetBindString_URL);
+++ hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_URL, &url_str, 1, &fetched);
+++ ok(hres == S_OK, "GetBindString(BINDSTRING_URL) failed: %08x\n", hres);
+++ ok(fetched == 1, "fetched = %d\n", fetched);
- static HRESULT WINAPI Protocol_Continue(IInternetProtocol *iface,
++++ ok(!lstrcmpW(url_str, binding_urls[tested_protocol]), "wrong url_str %s\n", wine_dbgstr_w(url_str));
+++ CoTaskMemFree(url_str);
+++ CHECK_CALLED(GetBindString_URL);
+++
+++ return S_OK;
+++}
+++
- static HRESULT WINAPI MimeProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
++++static HRESULT WINAPI Protocol_Continue(IInternetProtocolEx *iface,
+++ PROTOCOLDATA *pProtocolData)
+++{
+++ CHECK_EXPECT(MimeFilter_Continue);
+++ return E_NOTIMPL;
+++}
+++
- static HRESULT WINAPI MimeProtocol_Read(IInternetProtocol *iface, void *pv,
++++static HRESULT WINAPI MimeProtocol_Terminate(IInternetProtocolEx *iface, DWORD dwOptions)
+++{
+++ HRESULT hres;
+++
+++ CHECK_EXPECT(MimeFilter_Terminate);
+++
+++ ok(!dwOptions, "dwOptions = %x\n", dwOptions);
+++
+++ SET_EXPECT(Terminate);
+++ hres = IInternetProtocol_Terminate(filtered_protocol, dwOptions);
+++ ok(hres == S_OK, "Terminate failed: %08x\n", hres);
+++ CHECK_CALLED(Terminate);
+++
+++ return S_OK;
+++}
+++
- static HRESULT WINAPI MimeProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
++++static HRESULT WINAPI MimeProtocol_Read(IInternetProtocolEx *iface, void *pv,
+++ ULONG cb, ULONG *pcbRead)
+++{
+++ BYTE buf[2096];
+++ DWORD read = 0;
+++ HRESULT hres;
+++
+++ CHECK_EXPECT(MimeFilter_Read);
+++
+++ ok(pv != NULL, "pv == NULL\n");
+++ ok(cb != 0, "cb == 0\n");
+++ ok(pcbRead != NULL, "pcbRead == NULL\n");
+++
+++ if(read_report_data)
+++ SET_EXPECT(Read2);
+++ else
+++ SET_EXPECT(Read);
+++ hres = IInternetProtocol_Read(filtered_protocol, buf, sizeof(buf), &read);
+++ ok(hres == S_OK || hres == S_FALSE || hres == E_PENDING, "Read failed: %08x\n", hres);
+++ if(read_report_data)
+++ CHECK_CALLED(Read2);
+++ else
+++ CHECK_CALLED(Read);
+++
+++ if(pcbRead) {
+++ ok(*pcbRead == 0, "*pcbRead=%d, expected 0\n", *pcbRead);
+++ *pcbRead = read;
+++ }
+++
+++ memset(pv, 'x', read);
+++ return hres;
+++}
+++
- static HRESULT WINAPI MimeProtocol_UnlockRequest(IInternetProtocol *iface)
++++static HRESULT WINAPI MimeProtocol_LockRequest(IInternetProtocolEx *iface, DWORD dwOptions)
+++{
+++ HRESULT hres;
+++
+++ CHECK_EXPECT(MimeFilter_LockRequest);
+++
+++ ok(!dwOptions, "dwOptions = %x\n", dwOptions);
+++
+++ SET_EXPECT(LockRequest);
+++ hres = IInternetProtocol_LockRequest(filtered_protocol, dwOptions);
+++ ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
+++ CHECK_CALLED(LockRequest);
+++
+++ return S_OK;
+++}
+++
- static const IInternetProtocolVtbl MimeProtocolVtbl = {
++++static HRESULT WINAPI MimeProtocol_UnlockRequest(IInternetProtocolEx *iface)
+++{
+++ HRESULT hres;
+++
+++ CHECK_EXPECT(MimeFilter_UnlockRequest);
+++
+++ SET_EXPECT(UnlockRequest);
+++ hres = IInternetProtocol_UnlockRequest(filtered_protocol);
+++ ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
+++ CHECK_CALLED(UnlockRequest);
+++
+++ return S_OK;
+++}
+++
- static IInternetProtocol MimeProtocol = { &MimeProtocolVtbl };
++++static const IInternetProtocolExVtbl MimeProtocolVtbl = {
+++ MimeProtocol_QueryInterface,
+++ Protocol_AddRef,
+++ Protocol_Release,
+++ MimeProtocol_Start,
+++ Protocol_Continue,
+++ Protocol_Abort,
+++ MimeProtocol_Terminate,
+++ Protocol_Suspend,
+++ Protocol_Resume,
+++ MimeProtocol_Read,
+++ Protocol_Seek,
+++ MimeProtocol_LockRequest,
+++ MimeProtocol_UnlockRequest
+++};
+++
- #define TEST_BINDING 0x01
- #define TEST_FILTER 0x02
- #define TEST_FIRST_HTTP 0x04
- #define TEST_DIRECT_READ 0x08
- #define TEST_POST 0x10
- #define TEST_EMULATEPROT 0x20
- #define TEST_SHORT_READ 0x40
- #define TEST_REDIRECT 0x80
++++static IInternetProtocolEx MimeProtocol = { &MimeProtocolVtbl };
+++
+++static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
+++{
+++ ok(0, "unexpected call\n");
+++ return E_NOINTERFACE;
+++}
+++
+++static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
+++{
+++ return 2;
+++}
+++
+++static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
+++{
+++ return 1;
+++}
+++
+++static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
+++ REFIID riid, void **ppv)
+++{
+++ CHECK_EXPECT(CreateInstance);
+++
+++ ok(pOuter == (IUnknown*)prot_bind_info, "pOuter != protocol_unk\n");
+++ ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", debugstr_guid(riid));
+++ ok(ppv != NULL, "ppv == NULL\n");
+++
+++ *ppv = &Protocol;
+++ return S_OK;
+++}
+++
+++static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
+++{
+++ ok(0, "unexpected call\n");
+++ return S_OK;
+++}
+++
+++static const IClassFactoryVtbl ClassFactoryVtbl = {
+++ ClassFactory_QueryInterface,
+++ ClassFactory_AddRef,
+++ ClassFactory_Release,
+++ ClassFactory_CreateInstance,
+++ ClassFactory_LockServer
+++};
+++
+++static IClassFactory ClassFactory = { &ClassFactoryVtbl };
+++
+++static HRESULT WINAPI MimeFilter_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
+++{
+++ CHECK_EXPECT(MimeFilter_CreateInstance);
+++
+++ ok(!outer, "outer = %p\n", outer);
+++ ok(IsEqualGUID(&IID_IInternetProtocol, riid), "unexpected riid %s\n", debugstr_guid(riid));
+++
+++ *ppv = &MimeProtocol;
+++ return S_OK;
+++}
+++
+++static const IClassFactoryVtbl MimeFilterCFVtbl = {
+++ ClassFactory_QueryInterface,
+++ ClassFactory_AddRef,
+++ ClassFactory_Release,
+++ MimeFilter_CreateInstance,
+++ ClassFactory_LockServer
+++};
+++
+++static IClassFactory mimefilter_cf = { &MimeFilterCFVtbl };
+++
- state = 0;
++++#define TEST_BINDING 0x0001
++++#define TEST_FILTER 0x0002
++++#define TEST_FIRST_HTTP 0x0004
++++#define TEST_DIRECT_READ 0x0008
++++#define TEST_POST 0x0010
++++#define TEST_EMULATEPROT 0x0020
++++#define TEST_SHORT_READ 0x0040
++++#define TEST_REDIRECT 0x0080
++++#define TEST_ABORT 0x0100
++++#define TEST_ASYNCREQ 0x0200
++++#define TEST_USEIURI 0x0400
++++#define TEST_IMPLPROTEX 0x0800
++++
++++static void register_filter(BOOL do_register)
++++{
++++ IInternetSession *session;
++++ HRESULT hres;
++++
++++ static const WCHAR gzipW[] = {'g','z','i','p',0};
++++
++++ hres = pCoInternetGetSession(0, &session, 0);
++++ ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
++++
++++ if(do_register) {
++++ hres = IInternetSession_RegisterMimeFilter(session, &mimefilter_cf, &IID_IInternetProtocol, gzipW);
++++ ok(hres == S_OK, "RegisterMimeFilter failed: %08x\n", hres);
++++ }else {
++++ hres = IInternetSession_UnregisterMimeFilter(session, &mimefilter_cf, gzipW);
++++ ok(hres == S_OK, "RegisterMimeFilter failed: %08x\n", hres);
++++ }
++++
++++ IInternetSession_Release(session);
++++}
+++
+++static void init_test(int prot, DWORD flags)
+++{
+++ tested_protocol = prot;
+++ binding_test = (flags & TEST_BINDING) != 0;
+++ first_data_notif = TRUE;
+++ prot_read = 0;
+++ prot_state = 0;
+++ async_read_pending = TRUE;
+++ mimefilter_test = (flags & TEST_FILTER) != 0;
+++ filter_state = 0;
++++ post_stream_read = 0;
+++ ResetEvent(event_complete);
+++ ResetEvent(event_complete2);
+++ ResetEvent(event_continue);
+++ ResetEvent(event_continue_done);
+++ async_protocol = binding_protocol = filtered_protocol = NULL;
+++ filtered_sink = NULL;
+++ http_is_first = (flags & TEST_FIRST_HTTP) != 0;
+++ first_data_notif = TRUE;
- http_post_test = (flags & TEST_POST) != 0;
++++ state = STATE_CONNECTING;
++++ test_async_req = (flags & TEST_ASYNCREQ) != 0;
+++ direct_read = (flags & TEST_DIRECT_READ) != 0;
- static BOOL file_protocol_start(IInternetProtocol *protocol, LPCWSTR url, BOOL is_first)
+++ emulate_prot = (flags & TEST_EMULATEPROT) != 0;
+++ wait_for_switch = TRUE;
+++ short_read = (flags & TEST_SHORT_READ) != 0;
++++ http_post_test = TYMED_NULL;
+++ test_redirect = (flags & TEST_REDIRECT) != 0;
++++ test_abort = (flags & TEST_ABORT) != 0;
++++ impl_protex = (flags & TEST_IMPLPROTEX) != 0;
++++
++++ register_filter(mimefilter_test);
+++}
+++
+++static void test_priority(IInternetProtocol *protocol)
+++{
+++ IInternetPriority *priority;
+++ LONG pr;
+++ HRESULT hres;
+++
+++ hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority,
+++ (void**)&priority);
+++ ok(hres == S_OK, "QueryInterface(IID_IInternetPriority) failed: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = IInternetPriority_GetPriority(priority, &pr);
+++ ok(hres == S_OK, "GetPriority failed: %08x\n", hres);
+++ ok(pr == 0, "pr=%d, expected 0\n", pr);
+++
+++ hres = IInternetPriority_SetPriority(priority, 1);
+++ ok(hres == S_OK, "SetPriority failed: %08x\n", hres);
+++
+++ hres = IInternetPriority_GetPriority(priority, &pr);
+++ ok(hres == S_OK, "GetPriority failed: %08x\n", hres);
+++ ok(pr == 1, "pr=%d, expected 1\n", pr);
+++
+++ IInternetPriority_Release(priority);
+++}
+++
- hres = IInternetProtocol_Start(protocol, url, &protocol_sink, &bind_info, 0, 0);
- if(hres == INET_E_RESOURCE_NOT_FOUND) {
- win_skip("Start failed\n");
- return FALSE;
++++static void test_early_abort(const CLSID *clsid)
++++{
++++ IInternetProtocol *protocol;
++++ HRESULT hres;
++++
++++ hres = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
++++ &IID_IInternetProtocol, (void**)&protocol);
++++ ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
++++
++++ hres = IInternetProtocol_Abort(protocol, E_ABORT, 0);
++++ ok(hres == S_OK, "Abort failed: %08x\n", hres);
++++
++++ hres = IInternetProtocol_Abort(protocol, E_FAIL, 0);
++++ ok(hres == S_OK, "Abort failed: %08x\n", hres);
++++
++++ IInternetProtocol_Release(protocol);
++++}
++++
++++static BOOL file_protocol_start(IInternetProtocol *protocol, LPCWSTR url,
++++ IInternetProtocolEx *protocolex, IUri *uri, BOOL is_first)
+++{
+++ HRESULT hres;
+++
+++ SET_EXPECT(GetBindInfo);
+++ if(!(bindf & BINDF_FROMURLMON))
+++ SET_EXPECT(ReportProgress_DIRECTBIND);
+++ if(is_first) {
+++ SET_EXPECT(ReportProgress_SENDINGREQUEST);
+++ SET_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
+++ if(bindf & BINDF_FROMURLMON)
+++ SET_EXPECT(ReportProgress_VERIFIEDMIMETYPEAVAILABLE);
+++ else
+++ SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
+++ }
+++ SET_EXPECT(ReportData);
+++ if(is_first)
+++ SET_EXPECT(ReportResult);
+++
+++ expect_hrResult = S_OK;
+++
- ok(hres == S_OK, "Start failed: %08x\n", hres);
++++ if(protocolex) {
++++ hres = IInternetProtocolEx_StartEx(protocolex, uri, &protocol_sink, &bind_info, 0, 0);
++++ ok(hres == S_OK, "StartEx failed: %08x\n", hres);
++++ }else {
++++ hres = IInternetProtocol_Start(protocol, url, &protocol_sink, &bind_info, 0, 0);
++++ if(hres == INET_E_RESOURCE_NOT_FOUND) {
++++ win_skip("Start failed\n");
++++ return FALSE;
++++ }
++++ ok(hres == S_OK, "Start failed: %08x\n", hres);
+++ }
- IInternetProtocol *protocol;
- BYTE buf[512];
- ULONG cb;
- hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol, (void**)&protocol);
- ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
-
- if(SUCCEEDED(hres)) {
- if(file_protocol_start(protocol, url, TRUE)) {
- hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
- ok(hres == S_OK, "Read failed: %08x\n", hres);
- ok(cb == 2, "cb=%u expected 2\n", cb);
- hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
- ok(hres == S_FALSE, "Read failed: %08x\n", hres);
- hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
- ok(hres == S_FALSE, "Read failed: %08x expected S_FALSE\n", hres);
- ok(cb == 0, "cb=%u expected 0\n", cb);
- hres = IInternetProtocol_UnlockRequest(protocol);
- ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
- }
+++
+++ CHECK_CALLED(GetBindInfo);
+++ if(!(bindf & BINDF_FROMURLMON))
+++ CHECK_CALLED(ReportProgress_DIRECTBIND);
+++ if(is_first) {
+++ CHECK_CALLED(ReportProgress_SENDINGREQUEST);
+++ CHECK_CALLED(ReportProgress_CACHEFILENAMEAVAILABLE);
+++ if(bindf & BINDF_FROMURLMON)
+++ CHECK_CALLED(ReportProgress_VERIFIEDMIMETYPEAVAILABLE);
+++ else
+++ CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
+++ }
+++ CHECK_CALLED(ReportData);
+++ if(is_first)
+++ CHECK_CALLED(ReportResult);
+++
+++ return TRUE;
+++}
+++
+++static void test_file_protocol_url(LPCWSTR url)
+++{
+++ IInternetProtocolInfo *protocol_info;
+++ IUnknown *unk;
+++ IClassFactory *factory;
++++ IInternetProtocol *protocol;
++++ BYTE buf[512];
++++ ULONG cb;
+++ HRESULT hres;
+++
+++ hres = CoGetClassObject(&CLSID_FileProtocol, CLSCTX_INPROC_SERVER, NULL,
+++ &IID_IUnknown, (void**)&unk);
+++ ok(hres == S_OK, "CoGetClassObject failed: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
+++ ok(hres == E_NOINTERFACE,
+++ "Could not get IInternetProtocolInfo interface: %08x, expected E_NOINTERFACE\n", hres);
+++
+++ hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
+++ ok(hres == S_OK, "Could not get IClassFactory interface\n");
++++ IUnknown_Release(unk);
++++ if(FAILED(hres))
++++ return;
++++
++++ hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol, (void**)&protocol);
++++ ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
++++
+++ if(SUCCEEDED(hres)) {
- if(file_protocol_start(protocol, url, FALSE)) {
- hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
- ok(hres == S_FALSE, "Read failed: %08x\n", hres);
- hres = IInternetProtocol_LockRequest(protocol, 0);
- ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
- hres = IInternetProtocol_UnlockRequest(protocol);
- ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
- }
++++ if(file_protocol_start(protocol, url, NULL, NULL, TRUE)) {
++++ hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
++++ ok(hres == S_OK, "Read failed: %08x\n", hres);
++++ ok(cb == 2, "cb=%u expected 2\n", cb);
++++ hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
++++ ok(hres == S_FALSE, "Read failed: %08x\n", hres);
++++ hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
++++ ok(hres == S_FALSE, "Read failed: %08x expected S_FALSE\n", hres);
++++ ok(cb == 0, "cb=%u expected 0\n", cb);
++++ hres = IInternetProtocol_UnlockRequest(protocol);
++++ ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
++++ }
+++
- IInternetProtocol_Release(protocol);
++++ if(file_protocol_start(protocol, url, NULL, NULL, FALSE)) {
++++ hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
++++ ok(hres == S_FALSE, "Read failed: %08x\n", hres);
++++ hres = IInternetProtocol_LockRequest(protocol, 0);
++++ ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
++++ hres = IInternetProtocol_UnlockRequest(protocol);
++++ ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
++++ }
++++
++++ IInternetProtocol_Release(protocol);
++++ }
+++
- hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol, (void**)&protocol);
- ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
-
- if(SUCCEEDED(hres)) {
- if(file_protocol_start(protocol, url, TRUE)) {
- hres = IInternetProtocol_LockRequest(protocol, 0);
- ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
- hres = IInternetProtocol_Terminate(protocol, 0);
- ok(hres == S_OK, "Terminate failed: %08x\n", hres);
- hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
- ok(hres == S_OK, "Read failed: %08x\n\n", hres);
- hres = IInternetProtocol_UnlockRequest(protocol);
- ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
- hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
- ok(hres == S_OK, "Read failed: %08x\n", hres);
- hres = IInternetProtocol_Terminate(protocol, 0);
- ok(hres == S_OK, "Terminate failed: %08x\n", hres);
- }
++++ hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol, (void**)&protocol);
++++ ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
++++ if(SUCCEEDED(hres)) {
++++ if(file_protocol_start(protocol, url, NULL, NULL, TRUE)) {
++++ hres = IInternetProtocol_LockRequest(protocol, 0);
++++ ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
++++ hres = IInternetProtocol_Terminate(protocol, 0);
++++ ok(hres == S_OK, "Terminate failed: %08x\n", hres);
++++ hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
++++ ok(hres == S_OK, "Read failed: %08x\n\n", hres);
++++ hres = IInternetProtocol_UnlockRequest(protocol);
++++ ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
++++ hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
++++ ok(hres == S_OK, "Read failed: %08x\n", hres);
++++ hres = IInternetProtocol_Terminate(protocol, 0);
++++ ok(hres == S_OK, "Terminate failed: %08x\n", hres);
+++ }
+++
- IInternetProtocol_Release(protocol);
++++ IInternetProtocol_Release(protocol);
++++ }
+++
- hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol, (void**)&protocol);
- ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
++++ hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol, (void**)&protocol);
++++ ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
++++ if(SUCCEEDED(hres)) {
++++ if(file_protocol_start(protocol, url, NULL, NULL, TRUE)) {
++++ hres = IInternetProtocol_Terminate(protocol, 0);
++++ ok(hres == S_OK, "Terminate failed: %08x\n", hres);
++++ hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
++++ ok(hres == S_OK, "Read failed: %08x\n", hres);
++++ ok(cb == 2, "cb=%u expected 2\n", cb);
+++ }
+++
- if(SUCCEEDED(hres)) {
- if(file_protocol_start(protocol, url, TRUE)) {
- hres = IInternetProtocol_Terminate(protocol, 0);
- ok(hres == S_OK, "Terminate failed: %08x\n", hres);
- hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
- ok(hres == S_OK, "Read failed: %08x\n", hres);
- ok(cb == 2, "cb=%u expected 2\n", cb);
- }
++++ IInternetProtocol_Release(protocol);
++++ }
++++
++++ if(pCreateUri) {
++++ IInternetProtocolEx *protocolex;
++++ IUri *uri;
+++
- IInternetProtocol_Release(protocol);
++++ hres = pCreateUri(url, Uri_CREATE_FILE_USE_DOS_PATH, 0, &uri);
++++ ok(hres == S_OK, "CreateUri failed: %08x\n", hres);
++++
++++ hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocolEx, (void**)&protocolex);
++++ ok(hres == S_OK, "Could not get IInternetProtocolEx: %08x\n", hres);
+++
- IClassFactory_Release(factory);
++++ if(file_protocol_start(NULL, NULL, protocolex, uri, TRUE)) {
++++ hres = IInternetProtocolEx_Read(protocolex, buf, 2, &cb);
++++ ok(hres == S_OK, "Read failed: %08x\n", hres);
++++ hres = IInternetProtocolEx_LockRequest(protocolex, 0);
++++ ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
++++ hres = IInternetProtocolEx_UnlockRequest(protocolex);
++++ ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
+++ }
+++
- IUnknown_Release(unk);
++++ IUri_Release(uri);
++++ IInternetProtocolEx_Release(protocolex);
++++ }else {
++++ win_skip("Skipping file protocol StartEx tests\n");
+++ }
+++
- if(!file && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
- {
- win_skip("Detected Win9x or WinMe\n");
- return;
- }
++++ IClassFactory_Release(factory);
+++}
+++
+++static void test_file_protocol_fail(void)
+++{
+++ IInternetProtocol *protocol;
+++ HRESULT hres;
+++
+++ static const WCHAR index_url2[] =
+++ {'f','i','l','e',':','/','/','i','n','d','e','x','.','h','t','m','l',0};
+++
+++ hres = CoCreateInstance(&CLSID_FileProtocol, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
+++ &IID_IInternetProtocol, (void**)&protocol);
+++ ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ SET_EXPECT(GetBindInfo);
+++ expect_hrResult = MK_E_SYNTAX;
+++ hres = IInternetProtocol_Start(protocol, wszIndexHtml, &protocol_sink, &bind_info, 0, 0);
+++ ok(hres == MK_E_SYNTAX ||
+++ hres == E_INVALIDARG,
+++ "Start failed: %08x, expected MK_E_SYNTAX or E_INVALIDARG\n", hres);
+++ CLEAR_CALLED(GetBindInfo); /* GetBindInfo not called in IE7 */
+++
+++ SET_EXPECT(GetBindInfo);
+++ if(!(bindf & BINDF_FROMURLMON))
+++ SET_EXPECT(ReportProgress_DIRECTBIND);
+++ SET_EXPECT(ReportProgress_SENDINGREQUEST);
+++ SET_EXPECT(ReportResult);
+++ expect_hrResult = INET_E_RESOURCE_NOT_FOUND;
+++ hres = IInternetProtocol_Start(protocol, index_url, &protocol_sink, &bind_info, 0, 0);
+++ ok(hres == INET_E_RESOURCE_NOT_FOUND,
+++ "Start failed: %08x expected INET_E_RESOURCE_NOT_FOUND\n", hres);
+++ CHECK_CALLED(GetBindInfo);
+++ if(!(bindf & BINDF_FROMURLMON))
+++ CHECK_CALLED(ReportProgress_DIRECTBIND);
+++ CHECK_CALLED(ReportProgress_SENDINGREQUEST);
+++ CHECK_CALLED(ReportResult);
+++
+++ IInternetProtocol_Release(protocol);
+++
+++ hres = CoCreateInstance(&CLSID_FileProtocol, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
+++ &IID_IInternetProtocol, (void**)&protocol);
+++ ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ SET_EXPECT(GetBindInfo);
+++ if(!(bindf & BINDF_FROMURLMON))
+++ SET_EXPECT(ReportProgress_DIRECTBIND);
+++ SET_EXPECT(ReportProgress_SENDINGREQUEST);
+++ SET_EXPECT(ReportResult);
+++ expect_hrResult = INET_E_RESOURCE_NOT_FOUND;
+++
+++ hres = IInternetProtocol_Start(protocol, index_url2, &protocol_sink, &bind_info, 0, 0);
+++ ok(hres == INET_E_RESOURCE_NOT_FOUND,
+++ "Start failed: %08x, expected INET_E_RESOURCE_NOT_FOUND\n", hres);
+++ CHECK_CALLED(GetBindInfo);
+++ if(!(bindf & BINDF_FROMURLMON))
+++ CHECK_CALLED(ReportProgress_DIRECTBIND);
+++ CHECK_CALLED(ReportProgress_SENDINGREQUEST);
+++ CHECK_CALLED(ReportResult);
+++
+++ SET_EXPECT(GetBindInfo);
+++ hres = IInternetProtocol_Start(protocol, NULL, &protocol_sink, &bind_info, 0, 0);
+++ ok(hres == E_INVALIDARG, "Start failed: %08x, expected E_INVALIDARG\n", hres);
+++ CLEAR_CALLED(GetBindInfo); /* GetBindInfo not called in IE7 */
+++
+++ SET_EXPECT(GetBindInfo);
+++ hres = IInternetProtocol_Start(protocol, emptyW, &protocol_sink, &bind_info, 0, 0);
+++ ok(hres == E_INVALIDARG, "Start failed: %08x, expected E_INVALIDARG\n", hres);
+++ CLEAR_CALLED(GetBindInfo); /* GetBindInfo not called in IE7 */
+++
+++ IInternetProtocol_Release(protocol);
+++}
+++
+++static void test_file_protocol(void) {
+++ WCHAR buf[INTERNET_MAX_URL_LENGTH], file_name_buf[MAX_PATH];
+++ DWORD size;
+++ ULONG len;
+++ HANDLE file;
+++
+++ static const WCHAR wszFile[] = {'f','i','l','e',':',0};
+++ static const WCHAR wszFile2[] = {'f','i','l','e',':','/','/',0};
+++ static const WCHAR wszFile3[] = {'f','i','l','e',':','/','/','/',0};
+++ static const WCHAR wszFile4[] = {'f','i','l','e',':','\\','\\',0};
+++ static const char html_doc[] = "<HTML></HTML>";
+++
+++ trace("Testing file protocol...\n");
+++ init_test(FILE_TEST, 0);
+++
+++ SetLastError(0xdeadbeef);
+++ file = CreateFileW(wszIndexHtml, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
+++ FILE_ATTRIBUTE_NORMAL, NULL);
- static BOOL http_protocol_start(LPCWSTR url)
+++ ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
+++ if(file == INVALID_HANDLE_VALUE)
+++ return;
+++ WriteFile(file, html_doc, sizeof(html_doc)-1, &size, NULL);
+++ CloseHandle(file);
+++
+++ file_name = wszIndexHtml;
+++ bindf = 0;
+++ test_file_protocol_url(index_url);
+++ bindf = BINDF_FROMURLMON;
+++ test_file_protocol_url(index_url);
+++ bindf = BINDF_FROMURLMON | BINDF_NEEDFILE;
+++ test_file_protocol_url(index_url);
+++
+++ memcpy(buf, wszFile, sizeof(wszFile));
+++ len = sizeof(wszFile)/sizeof(WCHAR)-1;
+++ len += GetCurrentDirectoryW(sizeof(buf)/sizeof(WCHAR)-len, buf+len);
+++ buf[len++] = '\\';
+++ memcpy(buf+len, wszIndexHtml, sizeof(wszIndexHtml));
+++
+++ file_name = buf + sizeof(wszFile)/sizeof(WCHAR)-1;
+++ bindf = 0;
+++ test_file_protocol_url(buf);
+++ bindf = BINDF_FROMURLMON;
+++ test_file_protocol_url(buf);
+++
+++ memcpy(buf, wszFile2, sizeof(wszFile2));
+++ len = GetCurrentDirectoryW(sizeof(file_name_buf)/sizeof(WCHAR), file_name_buf);
+++ file_name_buf[len++] = '\\';
+++ memcpy(file_name_buf+len, wszIndexHtml, sizeof(wszIndexHtml));
+++ lstrcpyW(buf+sizeof(wszFile2)/sizeof(WCHAR)-1, file_name_buf);
+++ file_name = file_name_buf;
+++ bindf = 0;
+++ test_file_protocol_url(buf);
+++ bindf = BINDF_FROMURLMON;
+++ test_file_protocol_url(buf);
+++
+++ buf[sizeof(wszFile2)/sizeof(WCHAR)] = '|';
+++ test_file_protocol_url(buf);
+++
+++ memcpy(buf, wszFile3, sizeof(wszFile3));
+++ len = sizeof(wszFile3)/sizeof(WCHAR)-1;
+++ len += GetCurrentDirectoryW(sizeof(buf)/sizeof(WCHAR)-len, buf+len);
+++ buf[len++] = '\\';
+++ memcpy(buf+len, wszIndexHtml, sizeof(wszIndexHtml));
+++
+++ file_name = buf + sizeof(wszFile3)/sizeof(WCHAR)-1;
+++ bindf = 0;
+++ test_file_protocol_url(buf);
+++ bindf = BINDF_FROMURLMON;
+++ test_file_protocol_url(buf);
+++
+++ memcpy(buf, wszFile4, sizeof(wszFile4));
+++ len = GetCurrentDirectoryW(sizeof(file_name_buf)/sizeof(WCHAR), file_name_buf);
+++ file_name_buf[len++] = '\\';
+++ memcpy(file_name_buf+len, wszIndexHtml, sizeof(wszIndexHtml));
+++ lstrcpyW(buf+sizeof(wszFile4)/sizeof(WCHAR)-1, file_name_buf);
+++ file_name = file_name_buf;
+++ bindf = 0;
+++ test_file_protocol_url(buf);
+++ bindf = BINDF_FROMURLMON;
+++ test_file_protocol_url(buf);
+++
+++ buf[sizeof(wszFile4)/sizeof(WCHAR)] = '|';
+++ test_file_protocol_url(buf);
+++
+++ DeleteFileW(wszIndexHtml);
+++
+++ bindf = 0;
+++ test_file_protocol_fail();
+++ bindf = BINDF_FROMURLMON;
+++ test_file_protocol_fail();
+++}
+++
- if (http_post_test)
++++static BOOL http_protocol_start(LPCWSTR url, BOOL use_iuri)
+++{
+++ static BOOL got_user_agent = FALSE;
++++ IUri *uri = NULL;
+++ HRESULT hres;
+++
++++ if(use_iuri && pCreateUri) {
++++ hres = pCreateUri(url, 0, 0, &uri);
++++ ok(hres == S_OK, "CreateUri failed: %08x\n", hres);
++++ }
++++
+++ SET_EXPECT(GetBindInfo);
+++ if (!(bindf & BINDF_FROMURLMON))
+++ SET_EXPECT(ReportProgress_DIRECTBIND);
+++ if(!got_user_agent)
+++ SET_EXPECT(GetBindString_USER_AGENT);
+++ SET_EXPECT(GetBindString_ACCEPT_MIMES);
+++ SET_EXPECT(QueryService_HttpNegotiate);
+++ SET_EXPECT(BeginningTransaction);
+++ SET_EXPECT(GetRootSecurityId);
- hres = IInternetProtocol_Start(async_protocol, url, &protocol_sink, &bind_info, 0, 0);
- ok(hres == S_OK, "Start failed: %08x\n", hres);
++++ if(http_post_test) {
+++ SET_EXPECT(GetBindString_POST_COOKIE);
++++ if(http_post_test == TYMED_ISTREAM)
++++ SET_EXPECT(Stream_Seek);
++++ }
+++
- if (http_post_test)
++++ if(uri) {
++++ IInternetProtocolEx *protocolex;
++++
++++ hres = IInternetProtocol_QueryInterface(async_protocol, &IID_IInternetProtocolEx, (void**)&protocolex);
++++ ok(hres == S_OK, "Could not get IInternetProtocolEx iface: %08x\n", hres);
++++
++++ hres = IInternetProtocolEx_StartEx(protocolex, uri, &protocol_sink, &bind_info, 0, 0);
++++ ok(hres == S_OK, "Start failed: %08x\n", hres);
++++
++++ IInternetProtocolEx_Release(protocolex);
++++ IUri_Release(uri);
++++ }else {
++++ hres = IInternetProtocol_Start(async_protocol, url, &protocol_sink, &bind_info, 0, 0);
++++ ok(hres == S_OK, "Start failed: %08x\n", hres);
++++ }
+++ if(FAILED(hres))
+++ return FALSE;
+++
+++ CHECK_CALLED(GetBindInfo);
+++ if (!(bindf & BINDF_FROMURLMON))
+++ CHECK_CALLED(ReportProgress_DIRECTBIND);
+++ if (!got_user_agent)
+++ {
+++ CHECK_CALLED(GetBindString_USER_AGENT);
+++ got_user_agent = TRUE;
+++ }
+++ CHECK_CALLED(GetBindString_ACCEPT_MIMES);
+++ CHECK_CALLED(QueryService_HttpNegotiate);
+++ CHECK_CALLED(BeginningTransaction);
+++ /* GetRootSecurityId called on WinXP but not on Win98 */
+++ CLEAR_CALLED(GetRootSecurityId);
- ok(hres == S_FALSE, "Read failed: %08x\n", hres);
++++ if(http_post_test) {
+++ CHECK_CALLED(GetBindString_POST_COOKIE);
++++ if(http_post_test == TYMED_ISTREAM)
++++ CHECK_CALLED(Stream_Seek);
++++ }
+++
+++ return TRUE;
+++}
+++
+++static void test_protocol_terminate(IInternetProtocol *protocol)
+++{
+++ BYTE buf[3600];
+++ DWORD cb;
+++ HRESULT hres;
+++
+++ hres = IInternetProtocol_LockRequest(protocol, 0);
+++ ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
+++
+++ hres = IInternetProtocol_Read(protocol, buf, 1, &cb);
- static void test_http_protocol_url(LPCWSTR url, int prot, DWORD flags)
++++ ok(hres == test_abort ? S_OK : S_FALSE, "Read failed: %08x\n", hres);
+++
+++ hres = IInternetProtocol_Terminate(protocol, 0);
+++ ok(hres == S_OK, "Terminate failed: %08x\n", hres);
+++
+++ /* This wait is to give the internet handles being freed in Terminate
+++ * enough time to actually terminate in all cases. Internet handles
+++ * terminate asynchronously and native reuses the main InternetOpen
+++ * handle. The only case in which this seems to be necessary is on
+++ * wine with native wininet and urlmon, resulting in the next time
+++ * test_http_protocol_url being called the first data notification actually
+++ * being an extra last data notification from the previous connection
+++ * about once out of every ten times. */
+++ Sleep(100);
+++
+++ hres = IInternetProtocol_UnlockRequest(protocol);
+++ ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
+++}
+++
+++static void test_http_info(IInternetProtocol *protocol)
+++{
+++ IWinInetHttpInfo *info;
+++ HRESULT hres;
+++
+++ hres = IInternetProtocol_QueryInterface(protocol, &IID_IWinInetHttpInfo, (void**)&info);
+++ ok(hres == S_OK, "Could not get IWinInterHttpInfo iface: %08x\n", hres);
+++
+++ /* TODO */
+++
+++ IWinInetHttpInfo_Release(info);
+++}
+++
+++/* is_first refers to whether this is the first call to this function
+++ * _for this url_ */
- SET_EXPECT(ReportProgress_FINDINGRESOURCE);
- SET_EXPECT(ReportProgress_CONNECTING);
++++static void test_http_protocol_url(LPCWSTR url, int prot, DWORD flags, DWORD tymed)
+++{
+++ IInternetProtocolInfo *protocol_info;
+++ IClassFactory *factory;
+++ IUnknown *unk;
+++ HRESULT hres;
+++
+++ init_test(prot, flags);
+++ http_url = url;
++++ http_post_test = tymed;
+++
+++ hres = CoGetClassObject(prot == HTTPS_TEST ? &CLSID_HttpSProtocol : &CLSID_HttpProtocol,
+++ CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
+++ ok(hres == S_OK, "CoGetClassObject failed: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
+++ ok(hres == E_NOINTERFACE,
+++ "Could not get IInternetProtocolInfo interface: %08x, expected E_NOINTERFACE\n",
+++ hres);
+++
+++ hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
+++ ok(hres == S_OK, "Could not get IClassFactory interface\n");
+++ IUnknown_Release(unk);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol,
+++ (void**)&async_protocol);
+++ ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
+++ if(SUCCEEDED(hres)) {
+++ BYTE buf[3600];
+++ DWORD cb;
+++ ULONG ref;
+++
+++ test_priority(async_protocol);
+++ test_http_info(async_protocol);
+++
+++ SET_EXPECT(ReportProgress_COOKIE_SENT);
- if(!http_protocol_start(url))
++++ if(http_is_first) {
++++ SET_EXPECT(ReportProgress_FINDINGRESOURCE);
++++ SET_EXPECT(ReportProgress_CONNECTING);
++++ }
+++ SET_EXPECT(ReportProgress_SENDINGREQUEST);
+++ if(test_redirect)
+++ SET_EXPECT(ReportProgress_REDIRECTING);
+++ SET_EXPECT(ReportProgress_PROXYDETECTING);
+++ if(prot == HTTP_TEST)
+++ SET_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
+++ else
+++ SET_EXPECT(QueryService_HttpSecurity);
+++ if(!(bindf & BINDF_FROMURLMON)) {
+++ SET_EXPECT(OnResponse);
+++ SET_EXPECT(ReportProgress_RAWMIMETYPE);
+++ SET_EXPECT(ReportData);
+++ } else {
+++ SET_EXPECT(Switch);
+++ }
+++
- if(!direct_read)
++++ if(!http_protocol_start(url, (flags & TEST_USEIURI) != 0))
+++ return;
+++
- expect_hrResult = S_OK;
++++ if(!direct_read && !test_abort)
+++ SET_EXPECT(ReportResult);
- SET_EXPECT(Switch);
++++ expect_hrResult = test_abort ? E_ABORT : S_OK;
+++
+++ if(direct_read) {
++++ SET_EXPECT(Switch);
+++ while(wait_for_switch) {
- CHECK_CALLED(Switch);
+++ WaitForSingleObject(event_continue, INFINITE);
- ok(hres == S_FALSE, "Read failed: %08x\n", hres);
- CHECK_CALLED(ReportResult);
++++ CHECK_CALLED(Switch); /* Set in ReportData */
+++ call_continue(&continue_protdata);
+++ SetEvent(event_continue_done);
+++ }
+++ }else {
+++ hres = IInternetProtocol_Read(async_protocol, buf, 1, &cb);
+++ ok((hres == E_PENDING && cb==0) ||
+++ (hres == S_OK && cb==1), "Read failed: %08x (%d bytes)\n", hres, cb);
+++
+++ WaitForSingleObject(event_complete, INFINITE);
+++ if(bindf & BINDF_FROMURLMON)
+++ CHECK_CALLED(Switch);
+++ else
+++ CHECK_CALLED(ReportData);
+++ if(prot == HTTPS_TEST)
+++ CLEAR_CALLED(QueryService_HttpSecurity);
+++
+++ while(1) {
+++ if(bindf & BINDF_FROMURLMON)
+++ SET_EXPECT(Switch);
+++ else
+++ SET_EXPECT(ReportData);
+++ hres = IInternetProtocol_Read(async_protocol, buf, sizeof(buf), &cb);
+++ if(hres == E_PENDING) {
+++ hres = IInternetProtocol_Read(async_protocol, buf, 1, &cb);
+++ ok((hres == E_PENDING && cb==0) ||
+++ (hres == S_OK && cb==1), "Read failed: %08x (%d bytes)\n", hres, cb);
+++ WaitForSingleObject(event_complete, INFINITE);
+++ if(bindf & BINDF_FROMURLMON)
+++ CHECK_CALLED(Switch);
+++ else
+++ CHECK_CALLED(ReportData);
++++
++++ if(test_abort) {
++++ HRESULT hres;
++++
++++ SET_EXPECT(ReportResult);
++++ hres = IInternetProtocol_Abort(async_protocol, E_ABORT, 0);
++++ ok(hres == S_OK, "Abort failed: %08x\n", hres);
++++ CHECK_CALLED(ReportResult);
++++
++++ hres = IInternetProtocol_Abort(async_protocol, E_ABORT, 0);
++++ ok(hres == INET_E_RESULT_DISPATCHED, "Abort failed: %08x\n", hres);
++++ break;
++++ }
+++ }else {
+++ if(bindf & BINDF_FROMURLMON)
+++ CHECK_NOT_CALLED(Switch);
+++ else
+++ CHECK_NOT_CALLED(ReportData);
+++ if(cb == 0) break;
+++ }
+++ }
- ok(!ref, "ref=%x\n", hres);
++++ if(!test_abort) {
++++ ok(hres == S_FALSE, "Read failed: %08x\n", hres);
++++ CHECK_CALLED(ReportResult);
++++ }
+++ }
+++ if(prot == HTTPS_TEST)
+++ CLEAR_CALLED(ReportProgress_SENDINGREQUEST);
+++
++++ hres = IInternetProtocol_Abort(async_protocol, E_ABORT, 0);
++++ ok(hres == INET_E_RESULT_DISPATCHED, "Abort failed: %08x\n", hres);
++++
+++ test_protocol_terminate(async_protocol);
++++
++++ hres = IInternetProtocol_Abort(async_protocol, E_ABORT, 0);
++++ ok(hres == S_OK, "Abort failed: %08x\n", hres);
++++
+++ ref = IInternetProtocol_Release(async_protocol);
- static const WCHAR winehq_url[] =
- {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.',
- 'o','r','g','/','s','i','t','e','/','a','b','o','u','t',0};
++++ ok(!ref, "ref=%x\n", ref);
+++ }
+++
+++ IClassFactory_Release(factory);
+++}
+++
+++static void test_http_protocol(void)
+++{
- {'h','t','t','p',':','/','/','c','r','o','s','s','o','v','e','r','.',
- 'c','o','d','e','w','e','a','v','e','r','s','.','c','o','m','/',
- 'p','o','s','t','t','e','s','t','.','p','h','p',0};
+++ static const WCHAR posttest_url[] =
- 't','e','s','t','r','e','d','i','r','e','c','t',0};
++++ {'h','t','t','p',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.','o','r','g','/',
++++ 't','e','s','t','s','/','p','o','s','t','.','p','h','p',0};
+++ static const WCHAR redirect_url[] =
+++ {'h','t','t','p',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.','o','r','g','/',
- test_http_protocol_url(winehq_url, HTTP_TEST, TEST_FIRST_HTTP);
++++ 't','e','s','t','s','/','r','e','d','i','r','e','c','t',0};
++++ static const WCHAR winetest_url[] =
++++ {'h','t','t','p',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.','o','r','g','/',
++++ 't','e','s','t','s','/','d','a','t','a','.','p','h','p',0};
+++
+++ trace("Testing http protocol (not from urlmon)...\n");
+++ bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
- test_http_protocol_url(winehq_url, HTTP_TEST, 0);
++++ test_http_protocol_url(winetest_url, HTTP_TEST, TEST_FIRST_HTTP, TYMED_NULL);
+++
+++ trace("Testing http protocol (from urlmon)...\n");
+++ bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON;
- test_http_protocol_url(winehq_url, HTTP_TEST, 0);
++++ test_http_protocol_url(winetest_url, HTTP_TEST, 0, TYMED_NULL);
+++
+++ trace("Testing http protocol (to file)...\n");
+++ bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON | BINDF_NEEDFILE;
- /* Without this flag we get a ReportProgress_CACHEFILENAMEAVAILABLE
- * notification with BINDVERB_POST */
- bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON | BINDF_NOWRITECACHE;
- test_http_protocol_url(posttest_url, HTTP_TEST, TEST_FIRST_HTTP|TEST_POST);
++++ test_http_protocol_url(winetest_url, HTTP_TEST, 0, TYMED_NULL);
+++
+++ trace("Testing http protocol (post data)...\n");
- test_http_protocol_url(winehq_url, HTTP_TEST, TEST_DIRECT_READ);
++++ bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON;
++++ test_http_protocol_url(posttest_url, HTTP_TEST, TEST_FIRST_HTTP|TEST_POST, TYMED_HGLOBAL);
++++
++++ trace("Testing http protocol (post data stream)...\n");
++++ test_http_protocol_url(posttest_url, HTTP_TEST, TEST_FIRST_HTTP|TEST_POST|TEST_ASYNCREQ, TYMED_ISTREAM);
+++
+++ trace("Testing http protocol (direct read)...\n");
+++ bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON;
- test_http_protocol_url(redirect_url, HTTP_TEST, TEST_REDIRECT);
++++ test_http_protocol_url(winetest_url, HTTP_TEST, TEST_DIRECT_READ|TEST_USEIURI, TYMED_NULL);
+++
+++ trace("Testing http protocol (redirected)...\n");
+++ bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON;
- test_http_protocol_url(codeweavers_url, HTTPS_TEST, TEST_FIRST_HTTP);
++++ test_http_protocol_url(redirect_url, HTTP_TEST, TEST_REDIRECT, TYMED_NULL);
++++
++++ trace("Testing http protocol abort...\n");
++++ test_http_protocol_url(winetest_url, HTTP_TEST, TEST_ABORT, TYMED_NULL);
++++
++++ test_early_abort(&CLSID_HttpProtocol);
++++ test_early_abort(&CLSID_HttpSProtocol);
+++}
+++
+++static void test_https_protocol(void)
+++{
+++ static const WCHAR codeweavers_url[] =
+++ {'h','t','t','p','s',':','/','/','w','w','w','.','c','o','d','e','w','e','a','v','e','r','s',
+++ '.','c','o','m','/','t','e','s','t','.','h','t','m','l',0};
+++
+++ trace("Testing https protocol (from urlmon)...\n");
+++ bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON | BINDF_NOWRITECACHE;
- state = 0;
++++ test_http_protocol_url(codeweavers_url, HTTPS_TEST, TEST_FIRST_HTTP, TYMED_NULL);
+++}
+++
+++
+++static void test_ftp_protocol(void)
+++{
+++ IInternetProtocolInfo *protocol_info;
+++ IClassFactory *factory;
+++ IUnknown *unk;
+++ BYTE buf[4096];
+++ ULONG ref;
+++ DWORD cb;
+++ HRESULT hres;
+++
+++ static const WCHAR ftp_urlW[] = {'f','t','p',':','/','/','f','t','p','.','w','i','n','e','h','q','.','o','r','g',
+++ '/','p','u','b','/','o','t','h','e','r','/',
+++ 'w','i','n','e','l','o','g','o','.','x','c','f','.','t','a','r','.','b','z','2',0};
+++
+++ trace("Testing ftp protocol...\n");
+++
+++ bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON | BINDF_NOWRITECACHE;
-
++++ state = STATE_STARTDOWNLOADING;
+++ tested_protocol = FTP_TEST;
+++ first_data_notif = TRUE;
+++ expect_hrResult = E_PENDING;
+++
+++ hres = CoGetClassObject(&CLSID_FtpProtocol, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
+++ ok(hres == S_OK, "CoGetClassObject failed: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
+++ ok(hres == E_NOINTERFACE, "Could not get IInternetProtocolInfo interface: %08x, expected E_NOINTERFACE\n", hres);
+++
+++ hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
+++ ok(hres == S_OK, "Could not get IClassFactory interface\n");
+++ IUnknown_Release(unk);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol,
+++ (void**)&async_protocol);
+++ IClassFactory_Release(factory);
+++ ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
+++
+++ test_priority(async_protocol);
+++ test_http_info(async_protocol);
+++
+++ SET_EXPECT(GetBindInfo);
+++ SET_EXPECT(ReportProgress_FINDINGRESOURCE);
+++ SET_EXPECT(ReportProgress_CONNECTING);
+++ SET_EXPECT(ReportProgress_SENDINGREQUEST);
+++ SET_EXPECT(Switch);
+++
+++ hres = IInternetProtocol_Start(async_protocol, ftp_urlW, &protocol_sink, &bind_info, 0, 0);
+++ ok(hres == S_OK, "Start failed: %08x\n", hres);
+++ CHECK_CALLED(GetBindInfo);
+++
+++ SET_EXPECT(ReportResult);
+++
+++ hres = IInternetProtocol_Read(async_protocol, buf, 1, &cb);
+++ ok((hres == E_PENDING && cb==0) ||
+++ (hres == S_OK && cb==1), "Read failed: %08x (%d bytes)\n", hres, cb);
+++
+++ WaitForSingleObject(event_complete, INFINITE);
+++
+++ while(1) {
- SET_EXPECT(Start);
+++ hres = IInternetProtocol_Read(async_protocol, buf, sizeof(buf), &cb);
+++ if(hres == E_PENDING)
+++ WaitForSingleObject(event_complete, INFINITE);
+++ else
+++ if(cb == 0) break;
+++ }
+++
+++ ok(hres == S_FALSE, "Read failed: %08x\n", hres);
+++ CHECK_CALLED(ReportResult);
+++ CHECK_CALLED(Switch);
+++
+++ test_protocol_terminate(async_protocol);
+++
++++ if(pCreateUri) {
++++ IInternetProtocolEx *protocolex;
++++
++++ hres = IInternetProtocol_QueryInterface(async_protocol, &IID_IInternetProtocolEx, (void**)&protocolex);
++++ ok(hres == S_OK, "Could not get IInternetProtocolEx iface: %08x\n", hres);
++++ IInternetProtocolEx_Release(protocolex);
++++ }
++++
+++ ref = IInternetProtocol_Release(async_protocol);
+++ ok(!ref, "ref=%d\n", ref);
++++
++++ test_early_abort(&CLSID_FtpProtocol);
+++}
+++
+++static void test_gopher_protocol(void)
+++{
+++ IInternetProtocolInfo *protocol_info;
+++ IClassFactory *factory;
+++ IUnknown *unk;
+++ HRESULT hres;
+++
+++ trace("Testing gopher protocol...\n");
+++
+++ hres = CoGetClassObject(&CLSID_GopherProtocol, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
+++ ok(hres == S_OK ||
+++ hres == REGDB_E_CLASSNOTREG, /* Gopher protocol has been removed as of Vista */
+++ "CoGetClassObject failed: %08x\n", hres);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
+++ ok(hres == E_NOINTERFACE, "Could not get IInternetProtocolInfo interface: %08x, expected E_NOINTERFACE\n", hres);
+++
+++ hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
+++ ok(hres == S_OK, "Could not get IClassFactory interface\n");
+++ IUnknown_Release(unk);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol,
+++ (void**)&async_protocol);
+++ IClassFactory_Release(factory);
+++ ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
+++
+++ test_priority(async_protocol);
+++
+++ IInternetProtocol_Release(async_protocol);
++++
++++ test_early_abort(&CLSID_GopherProtocol);
+++}
+++
+++static void test_mk_protocol(void)
+++{
+++ IInternetProtocolInfo *protocol_info;
+++ IInternetProtocol *protocol;
+++ IClassFactory *factory;
+++ IUnknown *unk;
+++ HRESULT hres;
+++
+++ static const WCHAR wrong_url1[] = {'t','e','s','t',':','@','M','S','I','T','S','t','o','r','e',
+++ ':',':','/','t','e','s','t','.','h','t','m','l',0};
+++ static const WCHAR wrong_url2[] = {'m','k',':','/','t','e','s','t','.','h','t','m','l',0};
+++
+++ trace("Testing mk protocol...\n");
+++ init_test(MK_TEST, 0);
+++
+++ hres = CoGetClassObject(&CLSID_MkProtocol, CLSCTX_INPROC_SERVER, NULL,
+++ &IID_IUnknown, (void**)&unk);
+++ ok(hres == S_OK, "CoGetClassObject failed: %08x\n", hres);
+++
+++ hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
+++ ok(hres == E_NOINTERFACE,
+++ "Could not get IInternetProtocolInfo interface: %08x, expected E_NOINTERFACE\n",
+++ hres);
+++
+++ hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
+++ ok(hres == S_OK, "Could not get IClassFactory interface\n");
+++ IUnknown_Release(unk);
+++ if(FAILED(hres))
+++ return;
+++
+++ hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol,
+++ (void**)&protocol);
+++ IClassFactory_Release(factory);
+++ ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
+++
+++ SET_EXPECT(GetBindInfo);
+++ hres = IInternetProtocol_Start(protocol, wrong_url1, &protocol_sink, &bind_info, 0, 0);
+++ ok(hres == MK_E_SYNTAX || hres == INET_E_INVALID_URL,
+++ "Start failed: %08x, expected MK_E_SYNTAX or INET_E_INVALID_URL\n", hres);
+++ CLEAR_CALLED(GetBindInfo);
+++
+++ SET_EXPECT(GetBindInfo);
+++ SET_EXPECT(ReportProgress_DIRECTBIND);
+++ SET_EXPECT(ReportProgress_SENDINGREQUEST);
+++ SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
+++ SET_EXPECT(ReportResult);
+++ expect_hrResult = INET_E_RESOURCE_NOT_FOUND;
+++
+++ hres = IInternetProtocol_Start(protocol, wrong_url2, &protocol_sink, &bind_info, 0, 0);
+++ ok(hres == INET_E_RESOURCE_NOT_FOUND ||
+++ hres == INET_E_INVALID_URL, /* win2k3 */
+++ "Start failed: %08x, expected INET_E_RESOURCE_NOT_FOUND or INET_E_INVALID_URL\n", hres);
+++
+++ if (hres == INET_E_RESOURCE_NOT_FOUND) {
+++ CHECK_CALLED(GetBindInfo);
+++ CLEAR_CALLED(ReportProgress_DIRECTBIND);
+++ CHECK_CALLED(ReportProgress_SENDINGREQUEST);
+++ CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
+++ CHECK_CALLED(ReportResult);
+++ }else {
+++ CLEAR_CALLED(GetBindInfo);
+++ CLEAR_CALLED(ReportProgress_DIRECTBIND);
+++ CLEAR_CALLED(ReportProgress_SENDINGREQUEST);
+++ CLEAR_CALLED(ReportProgress_MIMETYPEAVAILABLE);
+++ CLEAR_CALLED(ReportResult);
+++ }
+++
+++ IInternetProtocol_Release(protocol);
+++}
+++
+++static void test_CreateBinding(void)
+++{
+++ IInternetProtocol *protocol;
+++ IInternetPriority *priority;
+++ IInternetSession *session;
+++ IWinInetHttpInfo *http_info;
+++ IWinInetInfo *inet_info;
+++ LONG p;
+++ BYTE buf[1000];
+++ DWORD read;
+++ HRESULT hres;
+++
+++ static const WCHAR test_url[] =
+++ {'t','e','s','t',':','/','/','f','i','l','e','.','h','t','m','l',0};
+++ static const WCHAR wsz_test[] = {'t','e','s','t',0};
+++
+++ trace("Testing CreateBinding...\n");
+++ init_test(BIND_TEST, TEST_BINDING);
+++
+++ hres = pCoInternetGetSession(0, &session, 0);
+++ ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
+++
+++ hres = IInternetSession_RegisterNameSpace(session, &ClassFactory, &IID_NULL, wsz_test, 0, NULL, 0);
+++ ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
+++
+++ hres = IInternetSession_CreateBinding(session, NULL, test_url, NULL, NULL, &protocol, 0);
+++ binding_protocol = protocol;
+++ ok(hres == S_OK, "CreateBinding failed: %08x\n", hres);
+++ ok(protocol != NULL, "protocol == NULL\n");
+++
+++ hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetBindInfo, (void**)&prot_bind_info);
+++ ok(hres == S_OK, "QueryInterface(IID_IInternetBindInfo) failed: %08x\n", hres);
+++
+++ hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetProtocolSink, (void**)&binding_sink);
+++ ok(hres == S_OK, "Could not get IInternetProtocolSink: %08x\n", hres);
+++
+++ hres = IInternetProtocol_Start(protocol, test_url, NULL, &bind_info, 0, 0);
+++ ok(hres == E_INVALIDARG, "Start failed: %08x, expected E_INVALIDARG\n", hres);
+++ hres = IInternetProtocol_Start(protocol, test_url, &protocol_sink, NULL, 0, 0);
+++ ok(hres == E_INVALIDARG, "Start failed: %08x, expected E_INVALIDARG\n", hres);
+++ hres = IInternetProtocol_Start(protocol, NULL, &protocol_sink, &bind_info, 0, 0);
+++ ok(hres == E_INVALIDARG, "Start failed: %08x, expected E_INVALIDARG\n", hres);
+++
+++ hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority, (void**)&priority);
+++ ok(hres == S_OK, "QueryInterface(IID_IInternetPriority) failed: %08x\n", hres);
+++
+++ p = 0xdeadbeef;
+++ hres = IInternetPriority_GetPriority(priority, &p);
+++ ok(hres == S_OK, "GetPriority failed: %08x\n", hres);
+++ ok(!p, "p=%d\n", p);
+++
+++ ex_priority = 100;
+++ hres = IInternetPriority_SetPriority(priority, 100);
+++ ok(hres == S_OK, "SetPriority failed: %08x\n", hres);
+++
+++ p = 0xdeadbeef;
+++ hres = IInternetPriority_GetPriority(priority, &p);
+++ ok(hres == S_OK, "GetPriority failed: %08x\n", hres);
+++ ok(p == 100, "p=%d\n", p);
+++
+++ hres = IInternetProtocol_QueryInterface(protocol, &IID_IWinInetInfo, (void**)&inet_info);
+++ ok(hres == E_NOINTERFACE, "Could not get IWinInetInfo protocol: %08x\n", hres);
+++
+++ SET_EXPECT(QueryService_InternetProtocol);
+++ SET_EXPECT(CreateInstance);
+++ SET_EXPECT(ReportProgress_PROTOCOLCLASSID);
+++ SET_EXPECT(SetPriority);
+++ SET_EXPECT(Start);
+++
+++ expect_hrResult = S_OK;
+++ hres = IInternetProtocol_Start(protocol, test_url, &protocol_sink, &bind_info, 0, 0);
+++ ok(hres == S_OK, "Start failed: %08x\n", hres);
+++
+++ CHECK_CALLED(QueryService_InternetProtocol);
+++ CHECK_CALLED(CreateInstance);
+++ CHECK_CALLED(ReportProgress_PROTOCOLCLASSID);
+++ CHECK_CALLED(SetPriority);
+++ CHECK_CALLED(Start);
+++
+++ SET_EXPECT(QueryInterface_IWinInetInfo);
+++ hres = IInternetProtocol_QueryInterface(protocol, &IID_IWinInetInfo, (void**)&inet_info);
+++ ok(hres == E_NOINTERFACE, "Could not get IWinInetInfo protocol: %08x\n", hres);
+++ CHECK_CALLED(QueryInterface_IWinInetInfo);
+++
+++ SET_EXPECT(QueryInterface_IWinInetInfo);
+++ hres = IInternetProtocol_QueryInterface(protocol, &IID_IWinInetInfo, (void**)&inet_info);
+++ ok(hres == E_NOINTERFACE, "Could not get IWinInetInfo protocol: %08x\n", hres);
+++ CHECK_CALLED(QueryInterface_IWinInetInfo);
+++
+++ SET_EXPECT(QueryInterface_IWinInetHttpInfo);
+++ hres = IInternetProtocol_QueryInterface(protocol, &IID_IWinInetHttpInfo, (void**)&http_info);
+++ ok(hres == E_NOINTERFACE, "Could not get IWinInetInfo protocol: %08x\n", hres);
+++ CHECK_CALLED(QueryInterface_IWinInetHttpInfo);
+++
+++ SET_EXPECT(Read);
+++ read = 0xdeadbeef;
+++ hres = IInternetProtocol_Read(protocol, expect_pv = buf, sizeof(buf), &read);
+++ ok(hres == S_OK, "Read failed: %08x\n", hres);
+++ ok(read == 100, "read = %d\n", read);
+++ CHECK_CALLED(Read);
+++
+++ SET_EXPECT(Read);
+++ read = 0xdeadbeef;
+++ hres = IInternetProtocol_Read(protocol, expect_pv = buf, sizeof(buf), &read);
+++ ok(hres == S_FALSE, "Read failed: %08x\n", hres);
+++ ok(!read, "read = %d\n", read);
+++ CHECK_CALLED(Read);
+++
+++ p = 0xdeadbeef;
+++ hres = IInternetPriority_GetPriority(priority, &p);
+++ ok(hres == S_OK, "GetPriority failed: %08x\n", hres);
+++ ok(p == 100, "p=%d\n", p);
+++
+++ hres = IInternetPriority_SetPriority(priority, 101);
+++ ok(hres == S_OK, "SetPriority failed: %08x\n", hres);
+++
+++ SET_EXPECT(Terminate);
+++ hres = IInternetProtocol_Terminate(protocol, 0xdeadbeef);
+++ ok(hres == S_OK, "Terminate failed: %08x\n", hres);
+++ CHECK_CALLED(Terminate);
+++
+++ SET_EXPECT(Continue);
+++ hres = IInternetProtocolSink_Switch(binding_sink, &protocoldata);
+++ ok(hres == S_OK, "Switch failed: %08x\n", hres);
+++ CHECK_CALLED(Continue);
+++
+++ hres = IInternetProtocolSink_ReportProgress(binding_sink,
+++ BINDSTATUS_CACHEFILENAMEAVAILABLE, expect_wsz = emptyW);
+++ ok(hres == S_OK, "ReportProgress(BINDSTATUS_CACHEFILENAMEAVAILABLE) failed: %08x\n", hres);
+++
+++ hres = IInternetProtocolSink_ReportResult(binding_sink, S_OK, ERROR_SUCCESS, NULL);
+++ ok(hres == E_FAIL, "ReportResult failed: %08x, expected E_FAIL\n", hres);
+++
+++ hres = IInternetProtocolSink_ReportData(binding_sink, 0, 0, 0);
+++ ok(hres == S_OK, "ReportData failed: %08x\n", hres);
+++
+++ IInternetProtocolSink_Release(binding_sink);
+++ IInternetPriority_Release(priority);
+++ IInternetBindInfo_Release(prot_bind_info);
+++ IInternetProtocol_Release(protocol);
+++
++++ hres = IInternetSession_CreateBinding(session, NULL, test_url, NULL, NULL, &protocol, 0);
++++ ok(hres == S_OK, "CreateBinding failed: %08x\n", hres);
++++ ok(protocol != NULL, "protocol == NULL\n");
++++
++++ hres = IInternetProtocol_Abort(protocol, E_ABORT, 0);
++++ ok(hres == S_OK, "Abort failed: %08x\n", hres);
++++
++++ hres = IInternetProtocol_Abort(protocol, E_FAIL, 0);
++++ ok(hres == S_OK, "Abort failed: %08x\n", hres);
++++
++++ IInternetProtocol_Release(protocol);
++++
+++ hres = IInternetSession_UnregisterNameSpace(session, &ClassFactory, wsz_test);
+++ ok(hres == S_OK, "UnregisterNameSpace failed: %08x\n", hres);
+++
++++ hres = IInternetSession_CreateBinding(session, NULL, test_url, NULL, NULL, &protocol, 0);
++++ ok(hres == S_OK, "CreateBinding failed: %08x\n", hres);
++++ ok(protocol != NULL, "protocol == NULL\n");
++++
++++ SET_EXPECT(QueryService_InternetProtocol);
++++ hres = IInternetProtocol_Start(protocol, test_url, &protocol_sink, &bind_info, 0, 0);
++++ ok(hres == MK_E_SYNTAX, "Start failed: %08x, expected MK_E_SYNTAX\n", hres);
++++ CHECK_CALLED(QueryService_InternetProtocol);
++++
++++ IInternetProtocol_Release(protocol);
++++
+++ IInternetSession_Release(session);
+++}
+++
+++static void test_binding(int prot, DWORD grf_pi, DWORD test_flags)
+++{
++++ IInternetProtocolEx *protocolex = NULL;
+++ IInternetProtocol *protocol;
+++ IInternetSession *session;
++++ IUri *uri = NULL;
+++ ULONG ref;
+++ HRESULT hres;
+++
+++ pi = grf_pi;
+++
+++ init_test(prot, test_flags|TEST_BINDING);
+++
+++ hres = pCoInternetGetSession(0, &session, 0);
+++ ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
+++
+++ if(test_flags & TEST_EMULATEPROT) {
+++ hres = IInternetSession_RegisterNameSpace(session, &ClassFactory, &IID_NULL, protocol_names[prot], 0, NULL, 0);
+++ ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
+++ }
+++
+++ hres = IInternetSession_CreateBinding(session, NULL, binding_urls[prot], NULL, NULL, &protocol, 0);
+++ binding_protocol = protocol;
+++ ok(hres == S_OK, "CreateBinding failed: %08x\n", hres);
+++ ok(protocol != NULL, "protocol == NULL\n");
+++
+++ hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetBindInfo, (void**)&prot_bind_info);
+++ ok(hres == S_OK, "QueryInterface(IID_IInternetBindInfo) failed: %08x\n", hres);
+++
+++ hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetProtocolSink, (void**)&binding_sink);
+++ ok(hres == S_OK, "QueryInterface(IID_IInternetProtocolSink) failed: %08x\n", hres);
+++
++++ if(test_flags & TEST_USEIURI) {
++++ hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetProtocolEx, (void**)&protocolex);
++++ ok(hres == S_OK, "Could not get IInternetProtocolEx iface: %08x\n", hres);
++++
++++ hres = pCreateUri(binding_urls[prot], Uri_CREATE_FILE_USE_DOS_PATH, 0, &uri);
++++ ok(hres == S_OK, "CreateUri failed: %08x\n", hres);
++++ }
++++
+++ ex_priority = 0;
+++ SET_EXPECT(QueryService_InternetProtocol);
+++ SET_EXPECT(CreateInstance);
+++ SET_EXPECT(ReportProgress_PROTOCOLCLASSID);
+++ SET_EXPECT(SetPriority);
- hres = IInternetProtocol_Start(protocol, binding_urls[prot], &protocol_sink, &bind_info, pi, 0);
- ok(hres == S_OK, "Start failed: %08x\n", hres);
++++ if(impl_protex)
++++ SET_EXPECT(StartEx);
++++ else
++++ SET_EXPECT(Start);
+++
+++ expect_hrResult = S_OK;
- CHECK_CALLED(Start);
++++
++++ if(protocolex) {
++++ hres = IInternetProtocolEx_StartEx(protocolex, uri, &protocol_sink, &bind_info, pi, 0);
++++ ok(hres == S_OK, "StartEx failed: %08x\n", hres);
++++ }else {
++++ hres = IInternetProtocol_Start(protocol, binding_urls[prot], &protocol_sink, &bind_info, pi, 0);
++++ ok(hres == S_OK, "Start failed: %08x\n", hres);
++++ }
+++
+++ CHECK_CALLED(QueryService_InternetProtocol);
+++ CHECK_CALLED(CreateInstance);
+++ CHECK_CALLED(ReportProgress_PROTOCOLCLASSID);
+++ CHECK_CALLED(SetPriority);
- static void register_filter(void)
- {
- IInternetSession *session;
- HRESULT hres;
-
- static const WCHAR gzipW[] = {'g','z','i','p',0};
-
- hres = pCoInternetGetSession(0, &session, 0);
- ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
-
- hres = IInternetSession_RegisterMimeFilter(session, &mimefilter_cf, &IID_IInternetProtocol, gzipW);
- ok(hres == S_OK, "RegisterMimeFilter failed: %08x\n", hres);
-
- IInternetSession_Release(session);
- }
-
++++ if(impl_protex)
++++ CHECK_CALLED(StartEx);
++++ else
++++ CHECK_CALLED(Start);
++++
++++ if(protocolex)
++++ IInternetProtocolEx_Release(protocolex);
++++ if(uri)
++++ IUri_Release(uri);
+++
+++ if(prot == HTTP_TEST || prot == HTTPS_TEST) {
+++ while(prot_state < 4) {
+++ WaitForSingleObject(event_complete, INFINITE);
+++ if(mimefilter_test && filtered_protocol) {
+++ SET_EXPECT(Continue);
+++ IInternetProtocol_Continue(filtered_protocol, pdata);
+++ CHECK_CALLED(Continue);
+++ }else {
+++ SET_EXPECT(Continue);
+++ IInternetProtocol_Continue(protocol, pdata);
+++ CHECK_CALLED(Continue);
+++ }
++++ if(test_abort && prot_state == 2) {
++++ SET_EXPECT(Abort);
++++ hres = IInternetProtocol_Abort(protocol, E_ABORT, 0);
++++ ok(hres == S_OK, "Abort failed: %08x\n", hres);
++++ CHECK_CALLED(Abort);
++++
++++ hres = IInternetProtocol_Abort(protocol, E_ABORT, 0);
++++ ok(hres == S_OK, "Abort failed: %08x\n", hres);
++++ SetEvent(event_complete2);
++++ break;
++++ }
+++ SetEvent(event_complete2);
+++ }
+++ if(direct_read)
+++ CHECK_CALLED(ReportData); /* Set in ReportResult */
+++ WaitForSingleObject(event_complete, INFINITE);
+++ }else {
+++ if(mimefilter_test)
+++ SET_EXPECT(MimeFilter_LockRequest);
+++ else
+++ SET_EXPECT(LockRequest);
+++ hres = IInternetProtocol_LockRequest(protocol, 0);
+++ ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
+++ if(mimefilter_test)
+++ CHECK_CALLED(MimeFilter_LockRequest);
+++ else
+++ CHECK_CALLED(LockRequest);
+++
+++ if(mimefilter_test)
+++ SET_EXPECT(MimeFilter_UnlockRequest);
+++ else
+++ SET_EXPECT(UnlockRequest);
+++ hres = IInternetProtocol_UnlockRequest(protocol);
+++ ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
+++ if(mimefilter_test)
+++ CHECK_CALLED(MimeFilter_UnlockRequest);
+++ else
+++ CHECK_CALLED(UnlockRequest);
+++ }
+++
+++ if(mimefilter_test)
+++ SET_EXPECT(MimeFilter_Terminate);
+++ else
+++ SET_EXPECT(Terminate);
+++ hres = IInternetProtocol_Terminate(protocol, 0);
+++ ok(hres == S_OK, "Terminate failed: %08x\n", hres);
+++ if(mimefilter_test)
+++ CLEAR_CALLED(MimeFilter_Terminate);
+++ else
+++ CHECK_CALLED(Terminate);
+++
+++ if(filtered_protocol)
+++ IInternetProtocol_Release(filtered_protocol);
+++ IInternetBindInfo_Release(prot_bind_info);
+++ IInternetProtocolSink_Release(binding_sink);
+++ ref = IInternetProtocol_Release(protocol);
+++ ok(!ref, "ref=%u, expected 0\n", ref);
+++
+++ if(test_flags & TEST_EMULATEPROT) {
+++ hres = IInternetSession_UnregisterNameSpace(session, &ClassFactory, protocol_names[prot]);
+++ ok(hres == S_OK, "UnregisterNameSpace failed: %08x\n", hres);
+++ }
+++
+++ IInternetSession_Release(session);
+++}
+++
- if (!pCoInternetGetSession || !pReleaseBindInfo) {
- win_skip("Various needed functions not present in IE 4.0\n");
+++START_TEST(protocol)
+++{
+++ HMODULE hurlmon;
+++
+++ hurlmon = GetModuleHandle("urlmon.dll");
+++ pCoInternetGetSession = (void*) GetProcAddress(hurlmon, "CoInternetGetSession");
+++ pReleaseBindInfo = (void*) GetProcAddress(hurlmon, "ReleaseBindInfo");
++++ pCreateUri = (void*) GetProcAddress(hurlmon, "CreateUri");
+++
-
- register_filter();
++++ if(!GetProcAddress(hurlmon, "CompareSecurityIds")) {
++++ win_skip("Various needed functions not present, too old IE\n");
+++ return;
+++ }
+++
++++ if(!pCreateUri)
++++ win_skip("CreateUri not supported\n");
++++
+++ OleInitialize(NULL);
+++
+++ event_complete = CreateEvent(NULL, FALSE, FALSE, NULL);
+++ event_complete2 = CreateEvent(NULL, FALSE, FALSE, NULL);
+++ event_continue = CreateEvent(NULL, FALSE, FALSE, NULL);
+++ event_continue_done = CreateEvent(NULL, FALSE, FALSE, NULL);
++++ thread_id = GetCurrentThreadId();
+++
+++ test_file_protocol();
+++ test_http_protocol();
+++ test_https_protocol();
+++ test_ftp_protocol();
+++ test_gopher_protocol();
+++ test_mk_protocol();
+++ test_CreateBinding();
+++
+++ bindf &= ~BINDF_FROMURLMON;
+++ trace("Testing file binding (mime verification, emulate prot)...\n");
+++ test_binding(FILE_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT);
+++ trace("Testing http binding (mime verification, emulate prot)...\n");
+++ test_binding(HTTP_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT);
++++ trace("Testing its binding (mime verification, emulate prot)...\n");
++++ test_binding(ITS_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT);
+++ trace("Testing http binding (mime verification, emulate prot, short read, direct read)...\n");
+++ test_binding(HTTP_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_SHORT_READ|TEST_DIRECT_READ);
+++ trace("Testing file binding (mime verification, emulate prot, mime filter)...\n");
+++ test_binding(FILE_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_FILTER);
+++ trace("Testing http binding (mime verification, emulate prot, mime filter)...\n");
+++ test_binding(HTTP_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_FILTER);
+++ trace("Testing http binding (mime verification, emulate prot, direct read)...\n");
+++ test_binding(HTTP_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_DIRECT_READ);
++++ trace("Testing http binding (mime verification, emulate prot, abort)...\n");
++++ test_binding(HTTP_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_ABORT);
++++ if(pCreateUri) {
++++ trace("Testing file binding (use IUri, mime verification, emulate prot)...\n");
++++ test_binding(FILE_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_USEIURI);
++++ trace("Testing file binding (use IUri, impl StartEx, mime verification, emulate prot)...\n");
++++ test_binding(FILE_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_USEIURI|TEST_IMPLPROTEX);
++++ trace("Testing file binding (impl StartEx, mime verification, emulate prot)...\n");
++++ test_binding(FILE_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_IMPLPROTEX);
++++ }
+++
+++ CloseHandle(event_complete);
+++ CloseHandle(event_complete2);
+++ CloseHandle(event_continue);
+++ CloseHandle(event_continue_done);
+++
+++ OleUninitialize();
+++}
--- /dev/null
--- /dev/null
--- /dev/null
- * Copyright 2009-2010 Detlef Riekenberg
+++/*
+++ * Copyright 2005-2006 Jacek Caban for CodeWeavers
- if(!pCoInternetCreateSecurityManager || !pCoInternetCreateZoneManager) {
- return;
- }
++++ * Copyright 2009-2011 Detlef Riekenberg
++++ * Copyright 2011 Thomas Mullaly for CodeWeavers
+++ *
+++ * This library is free software; you can redistribute it and/or
+++ * modify it under the terms of the GNU Lesser General Public
+++ * License as published by the Free Software Foundation; either
+++ * version 2.1 of the License, or (at your option) any later version.
+++ *
+++ * This library is distributed in the hope that it will be useful,
+++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+++ * Lesser General Public License for more details.
+++ *
+++ * You should have received a copy of the GNU Lesser General Public
+++ * License along with this library; if not, write to the Free Software
+++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+++ */
+++
+++#define COBJMACROS
+++#define CONST_VTABLE
+++#define NONAMELESSUNION
+++
+++/* needed for IInternetZoneManagerEx2 */
+++#define _WIN32_IE 0x0700
+++
+++#include <wine/test.h>
+++#include <stdarg.h>
+++#include <stddef.h>
++++#include <stdio.h>
+++
+++#include "windef.h"
+++#include "winbase.h"
+++#include "ole2.h"
+++#include "urlmon.h"
+++
+++#include "initguid.h"
+++
++++#define URLZONE_CUSTOM URLZONE_USER_MIN+1
++++#define URLZONE_CUSTOM2 URLZONE_CUSTOM+1
++++
++++#define DEFINE_EXPECT(func) \
++++ static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
++++
++++#define SET_EXPECT(func) \
++++ expect_ ## func = TRUE
++++
++++#define CHECK_EXPECT(func) \
++++ do { \
++++ ok(expect_ ##func, "unexpected call " #func "\n"); \
++++ expect_ ## func = FALSE; \
++++ called_ ## func = TRUE; \
++++ }while(0)
++++
++++#define CHECK_EXPECT2(func) \
++++ do { \
++++ ok(expect_ ##func, "unexpected call " #func "\n"); \
++++ called_ ## func = TRUE; \
++++ }while(0)
++++
++++#define CHECK_CALLED(func) \
++++ do { \
++++ ok(called_ ## func, "expected " #func "\n"); \
++++ expect_ ## func = called_ ## func = FALSE; \
++++ }while(0)
++++
++++DEFINE_EXPECT(ParseUrl_SECURITY_URL_input);
++++DEFINE_EXPECT(ParseUrl_SECURITY_URL_input2);
++++DEFINE_EXPECT(ParseUrl_SECURITY_URL_expected);
++++DEFINE_EXPECT(ParseUrl_SECURITY_URL_http);
++++DEFINE_EXPECT(ParseUrl_SECURITY_DOMAIN_expected);
+++
+++static HRESULT (WINAPI *pCoInternetCreateSecurityManager)(IServiceProvider *, IInternetSecurityManager**, DWORD);
+++static HRESULT (WINAPI *pCoInternetCreateZoneManager)(IServiceProvider *, IInternetZoneManager**, DWORD);
+++static HRESULT (WINAPI *pCoInternetGetSecurityUrl)(LPCWSTR, LPWSTR*, PSUACTION, DWORD);
++++static HRESULT (WINAPI *pCoInternetGetSecurityUrlEx)(IUri*, IUri**, PSUACTION, DWORD_PTR);
++++static HRESULT (WINAPI *pCreateUri)(LPCWSTR, DWORD, DWORD_PTR, IUri**);
++++static HRESULT (WINAPI *pCoInternetGetSession)(DWORD, IInternetSession**, DWORD);
+++
+++static const WCHAR url1[] = {'r','e','s',':','/','/','m','s','h','t','m','l','.','d','l','l',
+++ '/','b','l','a','n','k','.','h','t','m',0};
+++static const WCHAR url2[] = {'i','n','d','e','x','.','h','t','m',0};
+++static const WCHAR url3[] = {'f','i','l','e',':','/','/','c',':','\\','I','n','d','e','x','.','h','t','m',0};
+++static const WCHAR url4[] = {'f','i','l','e',':','s','o','m','e','%','2','0','f','i','l','e',
+++ '%','2','e','j','p','g',0};
+++static const WCHAR url5[] = {'h','t','t','p',':','/','/','w','w','w','.','z','o','n','e','3',
+++ '.','w','i','n','e','t','e','s','t',0};
+++static const WCHAR url6[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
+++static const WCHAR url7[] = {'f','t','p',':','/','/','z','o','n','e','3',
+++ '.','w','i','n','e','t','e','s','t','/','f','i','l','e','.','t','e','s','t',0};
+++static const WCHAR url8[] = {'t','e','s','t',':','1','2','3','a','b','c',0};
+++static const WCHAR url9[] = {'h','t','t','p',':','/','/','w','w','w','.','z','o','n','e','3',
+++ '.','w','i','n','e','t','e','s','t', '/','s','i','t','e','/','a','b','o','u','t',0};
+++static const WCHAR url10[] = {'f','i','l','e',':','/','/','s','o','m','e','%','2','0','f','i','l','e',
+++ '.','j','p','g',0};
+++
+++static const WCHAR url4e[] = {'f','i','l','e',':','s','o','m','e',' ','f','i','l','e',
+++ '.','j','p','g',0};
+++
++++static const WCHAR winetestW[] = {'w','i','n','e','t','e','s','t',0};
++++static const WCHAR security_urlW[] = {'w','i','n','e','t','e','s','t',':','t','e','s','t','i','n','g',0};
++++static const WCHAR security_url2W[] = {'w','i','n','e','t','e','s','t',':','t','e','s','t','i','n','g','2',0};
++++static const WCHAR security_expectedW[] = {'w','i','n','e','t','e','s','t',':','z','i','p',0};
++++static const WCHAR winetest_to_httpW[] = {'w','i','n','e','t','e','s','t',':','h',0};
++++
++++static const char *szZoneMapDomainsKey = "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\ZoneMap\\Domains";
++++static const char *szInternetSettingsKey = "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
+++
+++static const BYTE secid1[] = {'f','i','l','e',':',0,0,0,0};
+++static const BYTE secid5[] = {'h','t','t','p',':','w','w','w','.','z','o','n','e','3',
+++ '.','w','i','n','e','t','e','s','t',3,0,0,0};
+++static const BYTE secid6[] = {'a','b','o','u','t',':','b','l','a','n','k',3,0,0,0};
+++static const BYTE secid7[] = {'f','t','p',':','z','o','n','e','3',
+++ '.','w','i','n','e','t','e','s','t',3,0,0,0};
+++static const BYTE secid10[] =
+++ {'f','i','l','e',':','s','o','m','e','%','2','0','f','i','l','e','.','j','p','g',3,0,0,0};
+++static const BYTE secid10_2[] =
+++ {'f','i','l','e',':','s','o','m','e',' ','f','i','l','e','.','j','p','g',3,0,0,0};
+++
+++static const GUID CLSID_TestActiveX =
+++ {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xfa,0xf8,0x06,0x46}};
+++
+++/* Defined as extern in urlmon.idl, but not exported by uuid.lib */
+++const GUID GUID_CUSTOM_CONFIRMOBJECTSAFETY =
+++ {0x10200490,0xfa38,0x11d0,{0xac,0x0e,0x00,0xa0,0xc9,0xf,0xff,0xc0}};
+++
++++static int called_securl_http;
++++
+++static struct secmgr_test {
+++ LPCWSTR url;
+++ DWORD zone;
+++ HRESULT zone_hres;
+++ DWORD secid_size;
+++ const BYTE *secid;
+++ HRESULT secid_hres;
+++} secmgr_tests[] = {
+++ {url1, 0, S_OK, sizeof(secid1),
projects / reactos.git / commitdiff