[KMTestSuite]
authorThomas Faber <thomas.faber@reactos.org>
Mon, 6 Jun 2011 21:00:46 +0000 (21:00 +0000)
committerThomas Faber <thomas.faber@reactos.org>
Mon, 6 Jun 2011 21:00:46 +0000 (21:00 +0000)
- sync to rostests r52109 to fix CMake build with recent revisions

svn path=/branches/GSoC_2011/KMTestSuite/; revision=52123

125 files changed:
1  2  3  4 
apitests/dciman32/CMakeLists.txt
apitests/gdi32/CMakeLists.txt
apitests/gdi32/Rectangle.c
apitests/kernel32/CMakeLists.txt
apitests/msvcrt/CMakeLists.txt
apitests/msvcrt/msvcrt_apitest.rbuild
apitests/msvcrt/splitpath.c
apitests/msvcrt/testlist.c
apitests/ntdll/CMakeLists.txt
apitests/user32/CMakeLists.txt
apitests/user32/ScrollDC.c
apitests/user32/WndProc.c
apitests/user32/testlist.c
apitests/user32/user32_apitest.rbuild
apitests/w32knapi/w32knapi.h
apitests/ws2_32/CMakeLists.txt
drivers/kmtest/kmtest.h
dxtest/win32kdxtest/test.h
rosautotest/CMakeLists.txt
tests/DxHalTest/main.h
tests/mmixer_test/CMakeLists.txt
tests/pseh2/CMakeLists.txt
winetests/CMakeLists.txt
winetests/advapi32/CMakeLists.txt
winetests/advpack/CMakeLists.txt
winetests/amstream/CMakeLists.txt
winetests/atl/CMakeLists.txt
winetests/avifil32/CMakeLists.txt
winetests/browseui/CMakeLists.txt
winetests/cabinet/CMakeLists.txt
winetests/comcat/CMakeLists.txt
winetests/comctl32/CMakeLists.txt
winetests/comdlg32/CMakeLists.txt
winetests/credui/CMakeLists.txt
winetests/crypt32/CMakeLists.txt
winetests/cryptnet/CMakeLists.txt
winetests/cryptui/CMakeLists.txt
winetests/dnsapi/CMakeLists.txt
winetests/dsound/CMakeLists.txt
winetests/fusion/CMakeLists.txt
winetests/gdi32/CMakeLists.txt
winetests/gdiplus/CMakeLists.txt
winetests/hlink/CMakeLists.txt
winetests/icmp/CMakeLists.txt
winetests/imagehlp/CMakeLists.txt
winetests/imm32/CMakeLists.txt
winetests/inetcomm/CMakeLists.txt
winetests/inetmib1/CMakeLists.txt
winetests/iphlpapi/CMakeLists.txt
winetests/itss/CMakeLists.txt
winetests/jscript/CMakeLists.txt
winetests/kernel32/CMakeLists.txt
winetests/localspl/CMakeLists.txt
winetests/localui/CMakeLists.txt
winetests/lz32/CMakeLists.txt
winetests/mapi32/CMakeLists.txt
winetests/mlang/CMakeLists.txt
winetests/msacm32/CMakeLists.txt
winetests/mscms/CMakeLists.txt
winetests/msctf/CMakeLists.txt
winetests/mshtml/CMakeLists.txt
winetests/msi/CMakeLists.txt
winetests/mstask/CMakeLists.txt
winetests/msvcrt/CMakeLists.txt
winetests/msvcrtd/CMakeLists.txt
winetests/msvfw32/CMakeLists.txt
winetests/msxml3/CMakeLists.txt
winetests/netapi32/CMakeLists.txt
winetests/ntdll/CMakeLists.txt
winetests/ntdsapi/CMakeLists.txt
winetests/ntprint/CMakeLists.txt
winetests/odbccp32/CMakeLists.txt
winetests/ole32/CMakeLists.txt
winetests/oleacc/CMakeLists.txt
winetests/oleaut32/CMakeLists.txt
winetests/opengl32/CMakeLists.txt
winetests/pdh/CMakeLists.txt
winetests/powrprof/CMakeLists.txt
winetests/psapi/CMakeLists.txt
winetests/qmgr/CMakeLists.txt
winetests/quartz/CMakeLists.txt
winetests/rasapi32/CMakeLists.txt
winetests/riched20/CMakeLists.txt
winetests/riched32/CMakeLists.txt
winetests/rpcrt4/CMakeLists.txt
winetests/rsabase/CMakeLists.txt
winetests/rsaenh/CMakeLists.txt
winetests/schannel/CMakeLists.txt
winetests/secur32/CMakeLists.txt
winetests/serialui/CMakeLists.txt
winetests/setupapi/CMakeLists.txt
winetests/shdocvw/CMakeLists.txt
winetests/shell32/CMakeLists.txt
winetests/shlwapi/CMakeLists.txt
winetests/snmpapi/CMakeLists.txt
winetests/spoolss/CMakeLists.txt
winetests/twain_32/CMakeLists.txt
winetests/urlmon/CMakeLists.txt
winetests/urlmon/misc.c
winetests/urlmon/protocol.c
winetests/urlmon/sec_mgr.c
winetests/urlmon/stream.c
winetests/urlmon/uri.c
winetests/urlmon/url.c
winetests/user32/CMakeLists.txt
winetests/userenv/CMakeLists.txt
winetests/usp10/CMakeLists.txt
winetests/uxtheme/CMakeLists.txt
winetests/version/CMakeLists.txt
winetests/winhttp/CMakeLists.txt
winetests/winhttp/notification.c
winetests/winhttp/winhttp.c
winetests/wininet/CMakeLists.txt
winetests/wininet/ftp.c
winetests/wininet/http.c
winetests/wininet/internet.c
winetests/wininet/url.c
winetests/wininet/urlcache.c
winetests/wininet/wininet.rbuild
winetests/winmm/CMakeLists.txt
winetests/wintrust/CMakeLists.txt
winetests/wlanapi/CMakeLists.txt
winetests/wldap32/CMakeLists.txt
winetests/ws2_32/CMakeLists.txt
winetests/xmllite/CMakeLists.txt

Simple merge
Simple merge
index 2dde925,0000000,0000000,0000000..44030a9
mode 100644,000000,000000,000000..100644
--- /dev/null
--- /dev/null
--- /dev/null
@@@@@ -1,115 -1,0 -1,0 -1,0 +1,138 @@@@@
-       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();
 +++}
Simple merge
index 0000000,fc97971,0000000,0000000..fc97971
mode 000000,100644,000000,000000..100644
--- /dev/null
--- /dev/null
--- /dev/null
index 0000000,ce75877,0000000,0000000..ce75877
mode 000000,100644,000000,000000..100644
--- /dev/null
--- /dev/null
--- /dev/null
index 0000000,a8208e0,0000000,0000000..a8208e0
mode 000000,100644,000000,000000..100644
--- /dev/null
--- /dev/null
--- /dev/null
index 0000000,d54fb7e,0000000,0000000..d54fb7e
mode 000000,100644,000000,000000..100644
--- /dev/null
--- /dev/null
--- /dev/null
Simple merge
Simple merge
index 4697109,0000000,0000000,0000000..2bc1172
mode 100644,000000,000000,000000..100644
--- /dev/null
--- /dev/null
--- /dev/null
@@@@@ -1,72 -1,0 -1,0 -1,0 +1,77 @@@@@
-       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();
 +++}
 +++
Simple merge
Simple merge
index 4b15d05,764437b,0000000,764437b..764437b
mode 100644,100644,000000,100644..100644
--- /dev/null
@@@@@ -1,69 -1,69 -1,0 -1,69 +1,69 @@@@@
-   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 */
Simple merge
index f57e85d,eb02766,0000000,eb02766..eb02766
mode 100644,100644,000000,100644..100644
--- /dev/null
@@@@@ -1,54 -1,54 -1,0 -1,54 +1,54 @@@@@
-   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 */
index 7180ad6,a349d81,0000000,a349d81..a349d81
mode 100644,100644,000000,100644..100644
--- /dev/null
@@@@@ -1,61 -1,61 -1,0 -1,61 +1,61 @@@@@
-   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
Simple merge
index f431388,eb20d5f,0000000,eb20d5f..eb20d5f
mode 100644,100644,000000,100644..100644
--- /dev/null
@@@@@ -1,267 -1,267 -1,0 -1,267 +1,267 @@@@@
-   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 ";
  + }
  + 
Simple merge
Simple merge
index ca9b37a,dec178f,0000000,dec178f..dec178f
mode 100644,100644,000000,100644..100644
--- /dev/null
@@@@@ -1,90 -1,91 -1,0 -1,91 +1,91 @@@@@
  + 
  + 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)
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 0000000,ea3889c,0000000,ea3889c..ea3889c
mode 000000,100644,000000,100644..100644
--- /dev/null
--- /dev/null
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 7681b5c,0000000,0000000,0000000..e4dc200
mode 100644,000000,000000,000000..100644
--- /dev/null
--- /dev/null
--- /dev/null
@@@@@ -1,1547 -1,0 -1,0 -1,0 +1,1748 @@@@@
-   
 +++/*
 +++ * 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();
 +++}
index 19e1e98,0000000,0000000,0000000..4ca6da1
mode 100644,000000,000000,000000..100644
--- /dev/null
--- /dev/null
--- /dev/null
@@@@@ -1,3107 -1,0 -1,0 -1,0 +1,3506 @@@@@
-    * 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();
 +++}
index 5a1894b,0000000,0000000,0000000..c64dfe4
mode 100644,000000,000000,000000..100644
--- /dev/null
--- /dev/null
--- /dev/null
@@@@@ -1,734 -1,0 -1,0 -1,0 +1,1663 @@@@@
-    * 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),