Skip to content

W
wine-cw
Commit 37263f57 authored by Jacek Caban's avatar Jacek Caban Committed by Alexandre Julliard
Browse files
Options

urlmon: Added http protocol tests (currently failing in Wine).

parent f54a59c0
Show whitespace changes
Inline Side-by-side
Showing with 402 additions and 19 deletions
dlls/urlmon/tests/protocol.c
View file @ 37263f57
......@@ -56,29 +56,173 @@
DEFINE_EXPECT(GetBindInfo);
DEFINE_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
DEFINE_EXPECT(ReportProgress_DIRECTBIND);
DEFINE_EXPECT(ReportProgress_FINDINGRESOURCE);
DEFINE_EXPECT(ReportProgress_CONNECTING);
DEFINE_EXPECT(ReportProgress_SENDINGREQUEST);
DEFINE_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
DEFINE_EXPECT(ReportProgress_VERIFIEDMIMETYPEAVAILABLE);
DEFINE_EXPECT(ReportData);
DEFINE_EXPECT(ReportResult);
DEFINE_EXPECT(GetBindString_ACCEPT_MIMES);
DEFINE_EXPECT(GetBindString_USER_AGENT);
DEFINE_EXPECT(QueryService_HttpNegotiate);
DEFINE_EXPECT(BeginningTransaction);
DEFINE_EXPECT(GetRootSecurityId);
DEFINE_EXPECT(OnResponse);
DEFINE_EXPECT(Switch);
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 HRESULT expect_hrResult;
static LPCWSTR file_name;
static LPCWSTR file_name, http_url;
static IInternetProtocol *http_protocol = NULL;
static BOOL first_data_notif = FALSE;
static HWND protocol_hwnd;
static int state = 0;
static DWORD bindf = 0;
static HRESULT WINAPI ProtocolSink_QueryInterface(IInternetProtocolSink *iface, REFIID riid, void **ppv)
static enum {
FILE_TEST,
HTTP_TEST
} tested_protocol;
static HRESULT WINAPI HttpNegotiate_QueryInterface(IHttpNegotiate2 *iface, REFIID riid, void **ppv)
{
if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
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)
{
CHECK_EXPECT(BeginningTransaction);
ok(!lstrcmpW(szURL, http_url), "szURL != http_url\n");
ok(szHeaders == NULL, "szHeaders != NULL\n");
if(szHeaders) {
static const WCHAR header[] =
{'A','c','c','e','p','t','-','E','n','c','o','d','i','n','g',':',
' ','g','z','i','p',',',' ','d','e','f','l','a','t','e',0};
ok(!lstrcmpW(header, szHeaders), "Unexpected szHeaders\n");
}
ok(!dwReserved, "dwReserved=%ld, expected 0\n", dwReserved);
ok(pszAdditionalHeaders != NULL, "pszAdditionalHeaders == NULL\n");
if(pszAdditionalHeaders)
ok(*pszAdditionalHeaders == NULL, "*pszAdditionalHeaders != NULL\n");
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=%ld, 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=%ld, 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);
}
ok(0, "unexpected call\n");
return E_FAIL;
}
static const IServiceProviderVtbl ServiceProviderVtbl = {
ServiceProvider_QueryInterface,
ServiceProvider_AddRef,
ServiceProvider_Release,
ServiceProvider_QueryService
};
static IServiceProvider service_provider = { &ServiceProviderVtbl };
static HRESULT WINAPI ProtocolSink_QueryInterface(IInternetProtocolSink *iface, REFIID riid, void **ppv)
{
return QueryInterface(riid, ppv);
}
static ULONG WINAPI ProtocolSink_AddRef(IInternetProtocolSink *iface)
{
return 2;
......@@ -91,14 +235,21 @@ static ULONG WINAPI ProtocolSink_Release(IInternetProtocolSink *iface)
static HRESULT WINAPI ProtocolSink_Switch(IInternetProtocolSink *iface, PROTOCOLDATA *pProtocolData)
{
ok(0, "unexpected call\n");
return E_NOTIMPL;
CHECK_EXPECT2(Switch);
ok(pProtocolData != NULL, "pProtocolData == NULL\n");
SendMessageW(protocol_hwnd, WM_USER, 0, (LPARAM)pProtocolData);
return S_OK;
}
static HRESULT WINAPI ProtocolSink_ReportProgress(IInternetProtocolSink *iface, ULONG ulStatusCode,
LPCWSTR szStatusText)
{
static const WCHAR text_html[] = {'t','e','x','t','/','h','t','m','l',0};
static const WCHAR host[] =
{'w','w','w','.','w','i','n','e','h','q','.','o','r','g',0};
static const WCHAR wszWineHQIP[] =
{'2','0','9','.','3','2','.','1','4','1','.','3',0};
/* I'm not sure if it's a good idea to hardcode here the IP address... */
switch(ulStatusCode) {
case BINDSTATUS_MIMETYPEAVAILABLE:
......@@ -108,8 +259,8 @@ static HRESULT WINAPI ProtocolSink_ReportProgress(IInternetProtocolSink *iface,
ok(!lstrcmpW(szStatusText, text_html), "szStatusText != text/html\n");
break;
case BINDSTATUS_DIRECTBIND:
CHECK_EXPECT(ReportProgress_DIRECTBIND);
ok(szStatusText == NULL, "szStatucText != NULL\n");
CHECK_EXPECT2(ReportProgress_DIRECTBIND);
ok(szStatusText == NULL, "szStatusText != NULL\n");
break;
case BINDSTATUS_CACHEFILENAMEAVAILABLE:
CHECK_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
......@@ -117,11 +268,27 @@ static HRESULT WINAPI ProtocolSink_ReportProgress(IInternetProtocolSink *iface,
if(szStatusText)
ok(!lstrcmpW(szStatusText, file_name), "szStatusText != file_name\n");
break;
case BINDSTATUS_FINDINGRESOURCE:
CHECK_EXPECT(ReportProgress_FINDINGRESOURCE);
ok(szStatusText != NULL, "szStatusText == NULL\n");
if(szStatusText)
ok(!lstrcmpW(szStatusText, host), "szStatustext != \"www.winehq.org\"\n");
break;
case BINDSTATUS_CONNECTING:
CHECK_EXPECT(ReportProgress_CONNECTING);
ok(szStatusText != NULL, "szStatusText == NULL\n");
if(szStatusText)
ok(!lstrcmpW(szStatusText, wszWineHQIP), "Unexpected szStatusText\n");
break;
case BINDSTATUS_SENDINGREQUEST:
CHECK_EXPECT(ReportProgress_SENDINGREQUEST);
if(tested_protocol == FILE_TEST) {
ok(szStatusText != NULL, "szStatusText == NULL\n");
if(szStatusText)
ok(!*szStatusText, "wrong szStatusText\n");
}else {
ok(szStatusText == NULL, "szStatusText != NULL\n");
}
break;
case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
CHECK_EXPECT(ReportProgress_VERIFIEDMIMETYPEAVAILABLE);
......@@ -139,13 +306,29 @@ static HRESULT WINAPI ProtocolSink_ReportProgress(IInternetProtocolSink *iface,
static HRESULT WINAPI ProtocolSink_ReportData(IInternetProtocolSink *iface, DWORD grfBSCF,
ULONG ulProgress, ULONG ulProgressMax)
{
if(tested_protocol == FILE_TEST) {
CHECK_EXPECT2(ReportData);
ok(ulProgress == ulProgressMax, "ulProgress != ulProgressMax\n");
ok(ulProgress == ulProgressMax, "ulProgress (%ld) != ulProgressMax (%ld)\n",
ulProgress, ulProgressMax);
ok(ulProgressMax == 13, "ulProgressMax=%ld, expected 13\n", ulProgressMax);
ok(grfBSCF == (BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION),
"grcf = %08lx\n", grfBSCF);
"grcfBSCF = %08lx\n", grfBSCF);
}else if(tested_protocol == HTTP_TEST) {
if(!(grfBSCF & BSCF_LASTDATANOTIFICATION))
CHECK_EXPECT(ReportData);
ok(ulProgress, "ulProgress == 0\n");
if(first_data_notif) {
ok(grfBSCF == BSCF_FIRSTDATANOTIFICATION, "grcfBSCF = %08lx\n", grfBSCF);
first_data_notif = FALSE;
} else {
ok(grfBSCF == BSCF_INTERMEDIATEDATANOTIFICATION
|| grfBSCF == (BSCF_LASTDATANOTIFICATION|BSCF_INTERMEDIATEDATANOTIFICATION),
"grcfBSCF = %08lx\n", grfBSCF);
}
}
return S_OK;
}
......@@ -177,6 +360,21 @@ static IInternetProtocolSinkVtbl protocol_sink_vtbl = {
static IInternetProtocolSink protocol_sink = { &protocol_sink_vtbl };
static HRESULT QueryInterface(REFIID riid, void **ppv)
{
*ppv = NULL;
if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocolSink, riid))
*ppv = &protocol_sink;
if(IsEqualGUID(&IID_IServiceProvider, riid))
*ppv = &service_provider;
if(*ppv)
return S_OK;
return E_NOINTERFACE;
}
static HRESULT WINAPI BindInfo_QueryInterface(IInternetBindInfo *iface, REFIID riid, void **ppv)
{
if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetBindInfo, riid)) {
......@@ -198,14 +396,18 @@ static ULONG WINAPI BindInfo_Release(IInternetBindInfo *iface)
static HRESULT WINAPI BindInfo_GetBindInfo(IInternetBindInfo *iface, DWORD *grfBINDF, BINDINFO *pbindinfo)
{
DWORD cbSize;
CHECK_EXPECT(GetBindInfo);
ok(grfBINDF != NULL, "grfBINDF == NULL\n");
ok(pbindinfo != NULL, "pbindinfo == NULL\n");
ok(pbindinfo->cbSize == sizeof(BINDINFO), "wrong size of pbindinfo: %ld\n",
pbindinfo->cbSize);
ok(pbindinfo->cbSize == sizeof(BINDINFO), "wrong size of pbindinfo: %ld\n", pbindinfo->cbSize);
*grfBINDF = bindf;
cbSize = pbindinfo->cbSize;
memset(pbindinfo, 0, cbSize);
pbindinfo->cbSize = cbSize;
return S_OK;
}
......@@ -213,7 +415,41 @@ static HRESULT WINAPI BindInfo_GetBindInfo(IInternetBindInfo *iface, DWORD *grfB
static HRESULT WINAPI BindInfo_GetBindString(IInternetBindInfo *iface, ULONG ulStringType,
LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
{
static const WCHAR acc_mime[] = {'*','/','*',0};
static const WCHAR user_agent[] = {'W','i','n','e',0};
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=%ld, expected 256\n", cEl);
if(pcElFetched) {
ok(*pcElFetched == 256, "*pcElFetched=%ld, expected 256\n", *pcElFetched);
*pcElFetched = 1;
}
if(ppwzStr) {
*ppwzStr = CoTaskMemAlloc(sizeof(acc_mime));
memcpy(*ppwzStr, acc_mime, sizeof(acc_mime));
}
return S_OK;
case BINDSTRING_USER_AGENT:
CHECK_EXPECT(GetBindString_USER_AGENT);
ok(cEl == 1, "cEl=%ld, expected 1\n", cEl);
if(pcElFetched) {
ok(*pcElFetched == 0, "*pcElFetch=%ld, expectd 0\n", *pcElFetched);
*pcElFetched = 1;
}
if(ppwzStr) {
*ppwzStr = CoTaskMemAlloc(sizeof(user_agent));
memcpy(*ppwzStr, user_agent, sizeof(user_agent));
}
return S_OK;
default:
ok(0, "unexpected call\n");
}
return E_NOTIMPL;
}
......@@ -233,7 +469,8 @@ static void test_priority(IInternetProtocol *protocol)
LONG pr;
HRESULT hres;
hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority, (void**)&priority);
hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority,
(void**)&priority);
ok(hres == S_OK, "QueryInterface(IID_IInternetPriority) failed: %08lx\n", hres);
if(FAILED(hres))
return;
......@@ -456,6 +693,8 @@ static void test_file_protocol(void) {
static const WCHAR wszFile3[] = {'f','i','l','e',':','/','/','/',0};
static const char html_doc[] = "<HTML></HTML>";
tested_protocol = FILE_TEST;
file = CreateFileW(wszIndexHtml, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL, NULL);
ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
......@@ -514,14 +753,45 @@ static void test_file_protocol(void) {
test_file_protocol_fail();
}
static void test_http_protocol(void)
static BOOL http_protocol_start(LPCWSTR url, BOOL is_first)
{
HRESULT hres;
first_data_notif = TRUE;
SET_EXPECT(GetBindInfo);
SET_EXPECT(GetBindString_USER_AGENT);
SET_EXPECT(GetBindString_ACCEPT_MIMES);
SET_EXPECT(QueryService_HttpNegotiate);
SET_EXPECT(BeginningTransaction);
SET_EXPECT(GetRootSecurityId);
hres = IInternetProtocol_Start(http_protocol, url, &protocol_sink, &bind_info, 0, 0);
todo_wine {
ok(hres == S_OK, "Start failed: %08lx\n", hres);
}
if(FAILED(hres))
return FALSE;
CHECK_CALLED(GetBindInfo);
CHECK_CALLED(GetBindString_USER_AGENT);
CHECK_CALLED(GetBindString_ACCEPT_MIMES);
CHECK_CALLED(QueryService_HttpNegotiate);
CHECK_CALLED(BeginningTransaction);
CHECK_CALLED(GetRootSecurityId);
return TRUE;
}
static void test_http_protocol_url(LPCWSTR url)
{
IInternetProtocol *protocol;
IInternetProtocolInfo *protocol_info;
IClassFactory *factory;
IUnknown *unk;
HRESULT hres;
http_url = url;
hres = CoGetClassObject(&CLSID_HttpProtocol, CLSCTX_INPROC_SERVER, NULL,
&IID_IUnknown, (void**)&unk);
ok(hres == S_OK, "CoGetClassObject failed: %08lx\n", hres);
......@@ -530,7 +800,8 @@ static void test_http_protocol(void)
hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
ok(hres == E_NOINTERFACE,
"Could not get IInternetProtocolInfo interface: %08lx, expected E_NOINTERFACE\n", hres);
"Could not get IInternetProtocolInfo interface: %08lx, expected E_NOINTERFACE\n",
hres);
hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
ok(hres == S_OK, "Could not get IClassFactory interface\n");
......@@ -539,20 +810,132 @@ static void test_http_protocol(void)
return;
hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol,
(void**)&protocol);
(void**)&http_protocol);
ok(hres == S_OK, "Could not get IInternetProtocol: %08lx\n", hres);
if(SUCCEEDED(hres)) {
BYTE buf[512];
DWORD cb;
MSG msg;
test_priority(protocol);
bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON;
IInternetProtocol_Release(protocol);
test_priority(http_protocol);
SET_EXPECT(ReportProgress_FINDINGRESOURCE);
SET_EXPECT(ReportProgress_CONNECTING);
SET_EXPECT(ReportProgress_SENDINGREQUEST);
if(!http_protocol_start(url, TRUE))
return;
hres = IInternetProtocol_Read(http_protocol, buf, 2, &cb);
ok(hres == E_PENDING, "Read failed: %08lx, expected E_PENDING\n", hres);
ok(!cb, "cb=%ld, expected 0\n", cb);
SET_EXPECT(Switch);
SET_EXPECT(ReportResult);
expect_hrResult = S_OK;
GetMessageW(&msg, NULL, 0, 0);
CHECK_CALLED(Switch);
CHECK_CALLED(ReportResult);
IInternetProtocol_Release(http_protocol);
}
IClassFactory_Release(factory);
}
static void test_http_protocol(void)
{
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};
tested_protocol = HTTP_TEST;
test_http_protocol_url(winehq_url);
}
static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if(msg == WM_USER) {
HRESULT hres;
DWORD cb;
BYTE buf[3600];
SET_EXPECT(ReportData);
if(!state) {
CHECK_CALLED(ReportProgress_FINDINGRESOURCE);
CHECK_CALLED(ReportProgress_CONNECTING);
CHECK_CALLED(ReportProgress_SENDINGREQUEST);
SET_EXPECT(OnResponse);
SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
}
hres = IInternetProtocol_Continue(http_protocol, (PROTOCOLDATA*)lParam);
ok(hres == S_OK, "Continue failed: %08lx\n", hres);
CHECK_CALLED(ReportData);
if(!state) {
CHECK_CALLED(OnResponse);
CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
}
do hres = IInternetProtocol_Read(http_protocol, buf, sizeof(buf), &cb);
while(cb);
ok(hres == S_FALSE || hres == E_PENDING, "Read failed: %08lx\n", hres);
if(hres == S_FALSE)
PostMessageW(protocol_hwnd, WM_USER+1, 0, 0);
if(!state) {
state = 1;
hres = IInternetProtocol_LockRequest(http_protocol, 0);
ok(hres == S_OK, "LockRequest failed: %08lx\n", hres);
do hres = IInternetProtocol_Read(http_protocol, buf, sizeof(buf), &cb);
while(cb);
ok(hres == S_FALSE || hres == E_PENDING, "Read failed: %08lx\n", hres);
}
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}
static HWND create_protocol_window(void)
{
static const WCHAR wszProtocolWindow[] =
{'P','r','o','t','o','c','o','l','W','i','n','d','o','w',0};
static WNDCLASSEXW wndclass = {
sizeof(WNDCLASSEXW),
0,
wnd_proc,
0, 0, NULL, NULL, NULL, NULL, NULL,
wszProtocolWindow,
NULL
};
RegisterClassExW(&wndclass);
return CreateWindowW(wszProtocolWindow, wszProtocolWindow,
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, NULL, NULL, NULL, NULL);
}
START_TEST(protocol)
{
OleInitialize(NULL);
protocol_hwnd = create_protocol_window();
test_file_protocol();
test_http_protocol();
DestroyWindow(protocol_hwnd);
OleUninitialize();
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment