Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- dlls/shlwapi/tests/Makefile.in | 1 dlls/shlwapi/tests/assoc.c | 50 +++---- dlls/shlwapi/tests/clist.c | 4 - dlls/shlwapi/tests/clsid.c | 10 + dlls/shlwapi/tests/istream.c | 258 +++++++++++++++++----------------- dlls/shlwapi/tests/ordinal.c | 306 ++++++++++++++++++++-------------------- dlls/shlwapi/tests/path.c | 210 ++++++++++++++------------- dlls/shlwapi/tests/shreg.c | 104 +++++++------- dlls/shlwapi/tests/string.c | 52 +++---- dlls/shlwapi/tests/thread.c | 34 ++-- dlls/shlwapi/tests/url.c | 276 ++++++++++++++++++------------------ 11 files changed, 652 insertions(+), 653 deletions(-)
diff --git a/dlls/shlwapi/tests/Makefile.in b/dlls/shlwapi/tests/Makefile.in index 5c026fd6e5d..450a3955489 100644 --- a/dlls/shlwapi/tests/Makefile.in +++ b/dlls/shlwapi/tests/Makefile.in @@ -1,4 +1,3 @@ -EXTRADEFS = -DWINE_NO_LONG_TYPES TESTDLL = shlwapi.dll IMPORTS = shlwapi shell32 mlang oleaut32 ole32 user32 advapi32
diff --git a/dlls/shlwapi/tests/assoc.c b/dlls/shlwapi/tests/assoc.c index 4b461128dc4..84eda1317bb 100644 --- a/dlls/shlwapi/tests/assoc.c +++ b/dlls/shlwapi/tests/assoc.c @@ -23,8 +23,8 @@ #include "shlwapi.h" #include "shlguid.h"
-#define expect(expected, got) ok ( expected == got, "Expected %d, got %d\n", expected, got) -#define expect_hr(expected, got) ok ( expected == got, "Expected %08x, got %08x\n", expected, got) +#define expect(expected, got) ok ( expected == got, "Expected %ld, got %ld\n", expected, got) +#define expect_hr(expected, got) ok ( expected == got, "Expected %08lx, got %08lx\n", expected, got)
static HRESULT (WINAPI *pAssocQueryStringA)(ASSOCF,ASSOCSTR,LPCSTR,LPCSTR,LPSTR,LPDWORD) = NULL; static HRESULT (WINAPI *pAssocQueryStringW)(ASSOCF,ASSOCSTR,LPCWSTR,LPCWSTR,LPWSTR,LPDWORD) = NULL; @@ -53,24 +53,24 @@ static void test_getstring_bad(void) len = 0xdeadbeef; hr = pAssocQueryStringW(0, ASSOCSTR_EXECUTABLE, NULL, open, NULL, &len); expect_hr(E_INVALIDARG, hr); - ok(len == 0xdeadbeef, "got %u\n", len); + ok(len == 0xdeadbeef, "got %lu\n", len);
len = 0xdeadbeef; hr = pAssocQueryStringW(0, ASSOCSTR_EXECUTABLE, badBad, open, NULL, &len); ok(hr == E_FAIL || hr == HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION), /* Win9x/WinMe/NT4/W2K/Vista/W2K8 */ - "Unexpected result : %08x\n", hr); - ok(len == 0xdeadbeef, "got %u\n", len); + "Unexpected result : %08lx\n", hr); + ok(len == 0xdeadbeef, "got %lu\n", len);
len = ARRAY_SIZE(buf); hr = pAssocQueryStringW(0, ASSOCSTR_EXECUTABLE, dotBad, open, buf, &len); ok(hr == E_FAIL || hr == HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION) /* Win9x/WinMe/NT4/W2K/Vista/W2K8 */ || hr == S_OK /* Win8 */, - "Unexpected result : %08x\n", hr); + "Unexpected result : %08lx\n", hr); if (hr == S_OK) { - ok(len < ARRAY_SIZE(buf), "got %u\n", len); + ok(len < ARRAY_SIZE(buf), "got %lu\n", len); ok(!lstrcmpiW(buf + len - ARRAY_SIZE(openwith), openwith), "wrong data\n"); }
@@ -78,25 +78,25 @@ static void test_getstring_bad(void) hr = pAssocQueryStringW(0, ASSOCSTR_EXECUTABLE, dotHtml, invalid, NULL, &len); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) || hr == HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION), /* Win9x/WinMe/NT4/W2K/Vista/W2K8 */ - "Unexpected result : %08x\n", hr); - ok(len == 0xdeadbeef, "got %u\n", len); + "Unexpected result : %08lx\n", hr); + ok(len == 0xdeadbeef, "got %lu\n", len);
hr = pAssocQueryStringW(0, ASSOCSTR_EXECUTABLE, dotHtml, open, NULL, NULL); ok(hr == E_UNEXPECTED || hr == E_INVALIDARG, /* Win9x/WinMe/NT4/W2K/Vista/W2K8 */ - "Unexpected result : %08x\n", hr); + "Unexpected result : %08lx\n", hr);
len = 0xdeadbeef; hr = pAssocQueryStringW(0, ASSOCSTR_FRIENDLYAPPNAME, NULL, open, NULL, &len); expect_hr(E_INVALIDARG, hr); - ok(len == 0xdeadbeef, "got %u\n", len); + ok(len == 0xdeadbeef, "got %lu\n", len);
len = 0xdeadbeef; hr = pAssocQueryStringW(0, ASSOCSTR_FRIENDLYAPPNAME, badBad, open, NULL, &len); ok(hr == E_FAIL || hr == HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION), /* Win9x/WinMe/NT4/W2K/Vista/W2K8 */ - "Unexpected result : %08x\n", hr); - ok(len == 0xdeadbeef, "got %u\n", len); + "Unexpected result : %08lx\n", hr); + ok(len == 0xdeadbeef, "got %lu\n", len);
len = 0xdeadbeef; hr = pAssocQueryStringW(0, ASSOCSTR_FRIENDLYAPPNAME, dotBad, open, NULL, &len); @@ -104,22 +104,22 @@ static void test_getstring_bad(void) hr == HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION) /* Win9x/WinMe/NT4/W2K/Vista/W2K8 */ || hr == HRESULT_FROM_WIN32(ERROR_NOT_FOUND) /* Win8 */ || hr == S_FALSE, /* Win10 */ - "Unexpected result : %08x\n", hr); + "Unexpected result : %08lx\n", hr); ok((hr == S_FALSE && len < ARRAY_SIZE(buf)) || len == 0xdeadbeef, - "got hr=%08x and len=%u\n", hr, len); + "got hr=%08lx and len=%lu\n", hr, len);
len = 0xdeadbeef; hr = pAssocQueryStringW(0, ASSOCSTR_FRIENDLYAPPNAME, dotHtml, invalid, NULL, &len); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) || hr == HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION) || /* W2K/Vista/W2K8 */ hr == E_FAIL, /* Win9x/WinMe/NT4 */ - "Unexpected result : %08x\n", hr); - ok(len == 0xdeadbeef, "got %u\n", len); + "Unexpected result : %08lx\n", hr); + ok(len == 0xdeadbeef, "got %lu\n", len);
hr = pAssocQueryStringW(0, ASSOCSTR_FRIENDLYAPPNAME, dotHtml, open, NULL, NULL); ok(hr == E_UNEXPECTED || hr == E_INVALIDARG, /* Win9x/WinMe/NT4/W2K/Vista/W2K8 */ - "Unexpected result : %08x\n", hr); + "Unexpected result : %08lx\n", hr); }
static void test_getstring_basic(void) @@ -164,7 +164,7 @@ static void test_getstring_basic(void) ok(hr == S_FALSE || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) /* Win9x/NT4 */ || hr == HRESULT_FROM_WIN32(ERROR_NOT_FOUND), /* Win8 */ - "Unexpected result : %08x\n", hr); + "Unexpected result : %08lx\n", hr); if (hr != S_FALSE) { HeapFree(GetProcessHeap(), 0, executableName); @@ -255,7 +255,7 @@ static void test_getstring_no_extra(void) hr = pAssocQueryStringA(0, ASSOCSTR_EXECUTABLE, dotWinetest, NULL, buf, &len); ok(hr == S_OK || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), /* XP and W2K3 */ - "Unexpected result : %08x\n", hr); + "Unexpected result : %08lx\n", hr); hr = pAssocQueryStringA(0, ASSOCSTR_EXECUTABLE, dotWinetest, "foo", buf, &len); expect_hr(S_OK, hr); ok(strstr(buf, action) != NULL, @@ -279,19 +279,19 @@ static void test_assoc_create(void) }
hr = pAssocCreate(IID_NULL, &IID_NULL, NULL); - ok(hr == E_INVALIDARG, "Unexpected result : %08x\n", hr); + ok(hr == E_INVALIDARG, "Unexpected result : %08lx\n", hr);
hr = pAssocCreate(CLSID_QueryAssociations, &IID_NULL, (LPVOID*)&pqa); ok(hr == CLASS_E_CLASSNOTAVAILABLE || hr == E_NOTIMPL || hr == E_NOINTERFACE - , "Unexpected result : %08x\n", hr); + , "Unexpected result : %08lx\n", hr);
hr = pAssocCreate(IID_NULL, &IID_IQueryAssociations, (LPVOID*)&pqa); ok(hr == CLASS_E_CLASSNOTAVAILABLE || hr == E_NOTIMPL || hr == E_INVALIDARG - , "Unexpected result : %08x\n", hr); + , "Unexpected result : %08lx\n", hr);
hr = pAssocCreate(CLSID_QueryAssociations, &IID_IQueryAssociations, (LPVOID*)&pqa); ok(hr == S_OK || hr == E_NOTIMPL /* win98 */ - , "Unexpected result : %08x\n", hr); + , "Unexpected result : %08lx\n", hr); if(hr == S_OK) { IQueryAssociations_Release(pqa); @@ -299,7 +299,7 @@ static void test_assoc_create(void)
hr = pAssocCreate(CLSID_QueryAssociations, &IID_IUnknown, (LPVOID*)&pqa); ok(hr == S_OK || hr == E_NOTIMPL /* win98 */ - , "Unexpected result : %08x\n", hr); + , "Unexpected result : %08lx\n", hr); if(hr == S_OK) { IQueryAssociations_Release(pqa); diff --git a/dlls/shlwapi/tests/clist.c b/dlls/shlwapi/tests/clist.c index 0c914d608e5..5f88e92a5a6 100644 --- a/dlls/shlwapi/tests/clist.c +++ b/dlls/shlwapi/tests/clist.c @@ -328,7 +328,7 @@ static void test_CList(void) else if (inserted) { ok(inserted->cbSize == item->cbSize + sizeof(DATABLOCK_HEADER), - "id %d wrong size %d\n", inserted->dwSignature, inserted->cbSize); + "id %ld wrong size %ld\n", inserted->dwSignature, inserted->cbSize); } if (inserted) { @@ -449,7 +449,7 @@ static void test_CList(void) else if (inserted) { ok(inserted->cbSize == item->cbSize + sizeof(DATABLOCK_HEADER), - "id %d wrong size %d\n", inserted->dwSignature, inserted->cbSize); + "id %ld wrong size %ld\n", inserted->dwSignature, inserted->cbSize); } ok(!inserted || inserted->dwSignature == item->dwSignature, "find got wrong item\n"); if (inserted) diff --git a/dlls/shlwapi/tests/clsid.c b/dlls/shlwapi/tests/clsid.c index 7f2d375a35b..46b2a0b0185 100644 --- a/dlls/shlwapi/tests/clsid.c +++ b/dlls/shlwapi/tests/clsid.c @@ -116,7 +116,7 @@ static void test_ClassIDs(void) { dwLen = pSHStringFromGUIDA(*guids, szBuff, 256); if (!i && dwLen == S_OK) is_vista = TRUE; /* seems to return an HRESULT on vista */ - ok(dwLen == (is_vista ? S_OK : 39), "wrong size %u for id %d\n", dwLen, i); + ok(dwLen == (is_vista ? S_OK : 39), "wrong size %lu for id %d\n", dwLen, i);
bRet = pGUIDFromStringA(szBuff, &guid); ok(bRet != FALSE, "created invalid string '%s'\n", szBuff); @@ -130,7 +130,7 @@ static void test_ClassIDs(void)
/* Test endianness */ dwLen = pSHStringFromGUIDA(&IID_Endianness, szBuff, 256); - ok(dwLen == (is_vista ? S_OK : 39), "wrong size %u for IID_Endianness\n", dwLen); + ok(dwLen == (is_vista ? S_OK : 39), "wrong size %lu for IID_Endianness\n", dwLen);
ok(!strcmp(szBuff, "{01020304-0506-0708-090A-0B0C0D0E0F0A}"), "Endianness Broken, got '%s'\n", szBuff); @@ -171,14 +171,14 @@ static void test_CLSIDFromProgIDWrap(void) pCLSIDFromProgIDWrap = (void*)GetProcAddress(hShlwapi,(char*)435);
hres = pCLSIDFromProgIDWrap(wszStdPicture, &clsid); - ok(hres == S_OK, "CLSIDFromProgIDWrap failed: %08x\n", hres); + ok(hres == S_OK, "CLSIDFromProgIDWrap failed: %08lx\n", hres); ok(IsEqualGUID(&CLSID_StdPicture, &clsid), "wrong clsid\n");
hres = pCLSIDFromProgIDWrap(NULL, &clsid); - ok(hres == E_INVALIDARG, "CLSIDFromProgIDWrap failed: %08x, expected E_INVALIDARG\n", hres); + ok(hres == E_INVALIDARG, "CLSIDFromProgIDWrap failed: %08lx, expected E_INVALIDARG\n", hres);
hres = pCLSIDFromProgIDWrap(wszStdPicture, NULL); - ok(hres == E_INVALIDARG, "CLSIDFromProgIDWrap failed: %08x, expected E_INVALIDARG\n", hres); + ok(hres == E_INVALIDARG, "CLSIDFromProgIDWrap failed: %08lx, expected E_INVALIDARG\n", hres); }
START_TEST(clsid) diff --git a/dlls/shlwapi/tests/istream.c b/dlls/shlwapi/tests/istream.c index 4894eabdf50..8ccb3775fa0 100644 --- a/dlls/shlwapi/tests/istream.c +++ b/dlls/shlwapi/tests/istream.c @@ -51,16 +51,16 @@ static void test_IStream_invalid_operations(IStream * stream, DWORD mode) /* IStream_Read from the COBJMACROS is undefined by shlwapi.h, replaced by the IStream_Read helper function. */
ret = stream->lpVtbl->Read(stream, NULL, 0, &count); - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
ret = stream->lpVtbl->Read(stream, data, 5, NULL); - ok(ret == S_FALSE || ret == S_OK, "expected S_FALSE or S_OK, got 0x%08x\n", ret); + ok(ret == S_FALSE || ret == S_OK, "expected S_FALSE or S_OK, got 0x%08lx\n", ret);
ret = stream->lpVtbl->Read(stream, data, 0, NULL); - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
ret = stream->lpVtbl->Read(stream, data, 3, &count); - ok(ret == S_FALSE || ret == S_OK, "expected S_FALSE or S_OK, got 0x%08x\n", ret); + ok(ret == S_FALSE || ret == S_OK, "expected S_FALSE or S_OK, got 0x%08lx\n", ret);
/* IStream::Write */
@@ -70,104 +70,104 @@ static void test_IStream_invalid_operations(IStream * stream, DWORD mode) if (mode == STGM_READ) { ok(ret == STG_E_ACCESSDENIED /* XP */ || broken(ret == S_OK) /* Win2000 + IE5 */, - "expected STG_E_ACCESSDENIED, got 0x%08x\n", ret); + "expected STG_E_ACCESSDENIED, got 0x%08lx\n", ret); } else - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
strcpy(data, "Hello"); ret = stream->lpVtbl->Write(stream, data, 5, NULL); if (mode == STGM_READ) ok(ret == STG_E_ACCESSDENIED, - "expected STG_E_ACCESSDENIED, got 0x%08x\n", ret); + "expected STG_E_ACCESSDENIED, got 0x%08lx\n", ret); else - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
strcpy(data, "Hello"); ret = stream->lpVtbl->Write(stream, data, 0, NULL); if (mode == STGM_READ) ok(ret == STG_E_ACCESSDENIED, - "expected STG_E_ACCESSDENIED, got 0x%08x\n", ret); + "expected STG_E_ACCESSDENIED, got 0x%08lx\n", ret); else - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
strcpy(data, "Hello"); ret = stream->lpVtbl->Write(stream, data, 0, &count); if (mode == STGM_READ) ok(ret == STG_E_ACCESSDENIED, - "expected STG_E_ACCESSDENIED, got 0x%08x\n", ret); + "expected STG_E_ACCESSDENIED, got 0x%08lx\n", ret); else - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
strcpy(data, "Hello"); ret = stream->lpVtbl->Write(stream, data, 3, &count); if (mode == STGM_READ) ok(ret == STG_E_ACCESSDENIED, - "expected STG_E_ACCESSDENIED, got 0x%08x\n", ret); + "expected STG_E_ACCESSDENIED, got 0x%08lx\n", ret); else - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
/* IStream::Seek */
ret = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL); - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
ret = IStream_Seek(stream, zero, 20, NULL); ok(ret == E_INVALIDARG, - "expected E_INVALIDARG, got 0x%08x\n", ret); + "expected E_INVALIDARG, got 0x%08lx\n", ret);
/* IStream::CopyTo */
ret = IStream_CopyTo(stream, NULL, uzero, &uret, &uret); - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
clone = NULL; ret = IStream_CopyTo(stream, clone, uzero, &uret, &uret); - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
ret = IStream_CopyTo(stream, stream, uzero, &uret, &uret); - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
ret = IStream_CopyTo(stream, stream, uzero, &uret, NULL); - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
ret = IStream_CopyTo(stream, stream, uzero, NULL, &uret); - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
/* IStream::Commit */
ret = IStream_Commit(stream, STGC_DEFAULT); - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
/* IStream::Revert */
ret = IStream_Revert(stream); - ok(ret == E_NOTIMPL, "expected E_NOTIMPL, got 0x%08x\n", ret); + ok(ret == E_NOTIMPL, "expected E_NOTIMPL, got 0x%08lx\n", ret);
/* IStream::LockRegion */
ret = IStream_LockRegion(stream, uzero, uzero, 0); ok(ret == E_NOTIMPL /* XP */ || ret == S_OK /* Vista */, - "expected E_NOTIMPL or S_OK, got 0x%08x\n", ret); + "expected E_NOTIMPL or S_OK, got 0x%08lx\n", ret);
/* IStream::UnlockRegion */
if (ret == E_NOTIMPL) /* XP */ { ret = IStream_UnlockRegion(stream, uzero, uzero, 0); - ok(ret == E_NOTIMPL, "expected E_NOTIMPL, got 0x%08x\n", ret); + ok(ret == E_NOTIMPL, "expected E_NOTIMPL, got 0x%08lx\n", ret); } else /* Vista */ { ret = IStream_UnlockRegion(stream, uzero, uzero, 0); - ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "expected S_OK, got 0x%08lx\n", ret);
ret = IStream_UnlockRegion(stream, uzero, uzero, 0); - ok(ret == STG_E_LOCKVIOLATION, "expected STG_E_LOCKVIOLATION, got 0x%08x\n", ret); + ok(ret == STG_E_LOCKVIOLATION, "expected STG_E_LOCKVIOLATION, got 0x%08lx\n", ret); }
/* IStream::Stat */
ret = IStream_Stat(stream, NULL, 0); ok(ret == STG_E_INVALIDPOINTER, - "expected STG_E_INVALIDPOINTER or E_NOTIMPL, got 0x%08x\n", ret); + "expected STG_E_INVALIDPOINTER or E_NOTIMPL, got 0x%08lx\n", ret);
/* IStream::Clone */
@@ -175,12 +175,12 @@ static void test_IStream_invalid_operations(IStream * stream, DWORD mode)
clone = NULL; ret = IStream_Clone(stream, &clone); - ok(ret == E_NOTIMPL, "expected E_NOTIMPL, got 0x%08x\n", ret); + ok(ret == E_NOTIMPL, "expected E_NOTIMPL, got 0x%08lx\n", ret); ok(clone == NULL, "expected a NULL IStream object, got %p\n", stream);
if (clone) { refcount = IStream_Release(clone); - ok(refcount == 0, "expected 0, got %d\n", refcount); + ok(refcount == 0, "expected 0, got %ld\n", refcount); } }
@@ -199,63 +199,63 @@ static void test_stream_read_write(IStream *stream, DWORD mode) ret = stream->lpVtbl->Write(stream, "\x5e\xa7", 2, &written); if (mode == STGM_WRITE || mode == STGM_READWRITE) { - ok(ret == S_OK, "IStream_Write error %#x (access %#x)\n", ret, mode); - ok(written == 2, "expected 2, got %u\n", written); + ok(ret == S_OK, "IStream_Write error %#lx (access %#lx)\n", ret, mode); + ok(written == 2, "expected 2, got %lu\n", written); } else { - ok(ret == STG_E_ACCESSDENIED || broken(ret == S_OK) /* win2000 */, "expected STG_E_ACCESSDENIED, got %#x (access %#x)\n", ret, mode); - ok(written == 0xdeadbeaf || broken(written == 2) /* win2000 */, "expected 0xdeadbeaf, got %#x\n", written); + ok(ret == STG_E_ACCESSDENIED || broken(ret == S_OK) /* win2000 */, "expected STG_E_ACCESSDENIED, got %#lx (access %#lx)\n", ret, mode); + ok(written == 0xdeadbeaf || broken(written == 2) /* win2000 */, "expected 0xdeadbeaf, got %#lx\n", written); written = 0; if (ret == S_OK) return; /* no point in further testing */ }
ret = stream->lpVtbl->Seek(stream, start, STREAM_SEEK_SET, NULL); - ok(ret == S_OK, "Seek error %#x\n", ret); + ok(ret == S_OK, "Seek error %#lx\n", ret);
count = 0xdeadbeaf; ret = stream->lpVtbl->Read(stream, buf, 2, &count); if (written != 0) { - ok(ret == S_OK || broken(ret == S_FALSE) /* win2000 */, "IStream_Read error %#x (access %#x, written %u)\n", ret, mode, written); + ok(ret == S_OK || broken(ret == S_FALSE) /* win2000 */, "IStream_Read error %#lx (access %#lx, written %lu)\n", ret, mode, written); if (ret == S_OK && (mode == STGM_WRITE || mode == STGM_READWRITE)) { - ok(count == 2, "expected 2, got %u\n", count); + ok(count == 2, "expected 2, got %lu\n", count); ok(buf[0] == 0x5e && buf[1] == 0xa7, "expected 5ea7, got %02x%02x\n", buf[0], buf[1]); } else - ok(count == 0, "expected 0, got %u\n", count); + ok(count == 0, "expected 0, got %lu\n", count); } else { - ok(ret == S_FALSE, "expected S_FALSE, got %#x (access %#x, written %u)\n", ret, mode, written); - ok(count == 0, "expected 0, got %u\n", count); + ok(ret == S_FALSE, "expected S_FALSE, got %#lx (access %#lx, written %lu)\n", ret, mode, written); + ok(count == 0, "expected 0, got %lu\n", count); }
ret = stream->lpVtbl->Seek(stream, start, STREAM_SEEK_SET, NULL); - ok(ret == S_OK, "Seek error %#x\n", ret); + ok(ret == S_OK, "Seek error %#lx\n", ret);
count = 0xdeadbeaf; ret = stream->lpVtbl->Read(stream, buf, 0, &count); - ok(ret == S_OK, "IStream_Read error %#x (access %#x, written %u)\n", ret, mode, written); - ok(count == 0, "expected 0, got %u\n", count); + ok(ret == S_OK, "IStream_Read error %#lx (access %#lx, written %lu)\n", ret, mode, written); + ok(count == 0, "expected 0, got %lu\n", count);
count = 0xdeadbeaf; ret = stream->lpVtbl->Read(stream, buf, sizeof(buf), &count); - ok(ret == S_FALSE, "expected S_FALSE, got %#x (access %#x, written %u)\n", ret, mode, written); - ok(count == written, "expected %u, got %u\n", written, count); + ok(ret == S_FALSE, "expected S_FALSE, got %#lx (access %#lx, written %lu)\n", ret, mode, written); + ok(count == written, "expected %lu, got %lu\n", written, count); if (count) ok(buf[0] == 0x5e && buf[1] == 0xa7, "expected 5ea7, got %02x%02x\n", buf[0], buf[1]);
memset(&statstg, 0xff, sizeof(statstg)); ret = IStream_Stat(stream, &statstg, 0); - ok(ret == S_OK, "Stat failed, hr %#x.\n", ret); + ok(ret == S_OK, "Stat failed, hr %#lx.\n", ret); ok(statstg.pwcsName != NULL, "Unexpected name %s.\n", wine_dbgstr_w(statstg.pwcsName)); CoTaskMemFree(statstg.pwcsName);
memset(&statstg, 0xff, sizeof(statstg)); ret = IStream_Stat(stream, &statstg, STATFLAG_NONAME); - ok(ret == S_OK, "Stat failed, hr %#x.\n", ret); + ok(ret == S_OK, "Stat failed, hr %#lx.\n", ret); ok(statstg.pwcsName == NULL, "Unexpected name %s.\n", wine_dbgstr_w(statstg.pwcsName)); }
@@ -265,17 +265,17 @@ static void test_stream_qi(IStream *stream) HRESULT hr;
hr = IStream_QueryInterface(stream, &IID_IStream, (void **)&unk); - ok(SUCCEEDED(hr), "Failed to get IStream interface, hr %#x.\n", hr); + ok(SUCCEEDED(hr), "Failed to get IStream interface, hr %#lx.\n", hr); IUnknown_Release(unk);
unk = NULL; hr = IStream_QueryInterface(stream, &IID_ISequentialStream, (void **)&unk); - ok(SUCCEEDED(hr) || broken(hr == E_NOINTERFACE) /* XP */, "Failed to get ISequentialStream interface, hr %#x.\n", hr); + ok(SUCCEEDED(hr) || broken(hr == E_NOINTERFACE) /* XP */, "Failed to get ISequentialStream interface, hr %#lx.\n", hr); if (unk) IUnknown_Release(unk);
hr = IStream_QueryInterface(stream, &IID_IUnknown, (void **)&unk); - ok(SUCCEEDED(hr), "Failed to get IUnknown interface, hr %#x.\n", hr); + ok(SUCCEEDED(hr), "Failed to get IUnknown interface, hr %#lx.\n", hr); IUnknown_Release(unk); }
@@ -287,7 +287,7 @@ static void test_SHCreateStreamOnFileA(DWORD mode, DWORD stgm) char test_file[MAX_PATH]; static const CHAR testA_txt[] = "\testA.txt";
- trace("SHCreateStreamOnFileA: testing mode %d, STGM flags %08x\n", mode, stgm); + trace("SHCreateStreamOnFileA: testing mode %ld, STGM flags %08lx\n", mode, stgm);
/* Don't used a fixed path for the testA.txt file */ GetTempPathA(MAX_PATH, test_file); @@ -305,40 +305,40 @@ static void test_SHCreateStreamOnFileA(DWORD mode, DWORD stgm) ok(ret == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) /* NT */ || ret == HRESULT_FROM_WIN32(ERROR_BAD_PATHNAME) /* 9x */, "SHCreateStreamOnFileA: expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) " - "or HRESULT_FROM_WIN32(ERROR_BAD_PATHNAME), got 0x%08x\n", ret); + "or HRESULT_FROM_WIN32(ERROR_BAD_PATHNAME), got 0x%08lx\n", ret); ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
if (0) /* This test crashes on WinXP SP2 */ { ret = SHCreateStreamOnFileA(test_file, mode | stgm, NULL); - ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08x\n", ret); + ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08lx\n", ret); }
stream = NULL; ret = SHCreateStreamOnFileA(test_file, mode | STGM_CONVERT | stgm, &stream); - ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08x\n", ret); + ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08lx\n", ret); ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
stream = NULL; ret = SHCreateStreamOnFileA(test_file, mode | STGM_DELETEONRELEASE | stgm, &stream); - ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08x\n", ret); + ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08lx\n", ret); ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
stream = NULL; ret = SHCreateStreamOnFileA(test_file, mode | STGM_TRANSACTED | stgm, &stream); - ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08x\n", ret); + ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08lx\n", ret); ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
/* file does not exist */
stream = NULL; ret = SHCreateStreamOnFileA(test_file, mode | STGM_FAILIFTHERE | stgm, &stream); - ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "SHCreateStreamOnFileA: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08x\n", ret); + ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "SHCreateStreamOnFileA: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08lx\n", ret); ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
stream = NULL; ret = SHCreateStreamOnFileA(test_file, mode | STGM_CREATE | stgm, &stream); - ok(ret == S_OK, "SHCreateStreamOnFileA: expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "SHCreateStreamOnFileA: expected S_OK, got 0x%08lx\n", ret); ok(stream != NULL, "SHCreateStreamOnFileA: expected a valid IStream object, got NULL\n");
if (stream) { @@ -346,7 +346,7 @@ if (0) /* This test crashes on WinXP SP2 */ test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream); - ok(refcount == 0, "SHCreateStreamOnFileA: expected 0, got %d\n", refcount); + ok(refcount == 0, "SHCreateStreamOnFileA: expected 0, got %ld\n", refcount); }
/* NOTE: don't delete the file, as it will be used for the file exists tests. */ @@ -355,19 +355,19 @@ if (0) /* This test crashes on WinXP SP2 */
stream = NULL; ret = SHCreateStreamOnFileA(test_file, mode | STGM_FAILIFTHERE | stgm, &stream); - ok(ret == S_OK, "SHCreateStreamOnFileA: expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "SHCreateStreamOnFileA: expected S_OK, got 0x%08lx\n", ret); ok(stream != NULL, "SHCreateStreamOnFileA: expected a valid IStream object, got NULL\n");
if (stream) { test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream); - ok(refcount == 0, "SHCreateStreamOnFileA: expected 0, got %d\n", refcount); + ok(refcount == 0, "SHCreateStreamOnFileA: expected 0, got %ld\n", refcount); }
stream = NULL; ret = SHCreateStreamOnFileA(test_file, mode | STGM_CREATE | stgm, &stream); - ok(ret == S_OK, "SHCreateStreamOnFileA: expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "SHCreateStreamOnFileA: expected S_OK, got 0x%08lx\n", ret); ok(stream != NULL, "SHCreateStreamOnFileA: expected a valid IStream object, got NULL\n");
if (stream) { @@ -377,10 +377,10 @@ if (0) /* This test crashes on WinXP SP2 */ test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream); - ok(refcount == 0, "SHCreateStreamOnFileA: expected 0, got %d\n", refcount); + ok(refcount == 0, "SHCreateStreamOnFileA: expected 0, got %ld\n", refcount);
delret = DeleteFileA(test_file); - ok(delret, "SHCreateStreamOnFileA: could not delete file '%s', got error %d\n", + ok(delret, "SHCreateStreamOnFileA: could not delete file '%s', got error %ld\n", test_file, GetLastError()); } } @@ -395,7 +395,7 @@ static void test_SHCreateStreamOnFileW(DWORD mode, DWORD stgm) CHAR test_fileA[MAX_PATH]; static const CHAR testW_txt[] = "\testW.txt";
- trace("SHCreateStreamOnFileW: testing mode %d, STGM flags %08x\n", mode, stgm); + trace("SHCreateStreamOnFileW: testing mode %ld, STGM flags %08lx\n", mode, stgm);
/* Don't used a fixed path for the testW.txt file */ GetTempPathA(MAX_PATH, test_fileA); @@ -411,7 +411,7 @@ static void test_SHCreateStreamOnFileW(DWORD mode, DWORD stgm) ret = SHCreateStreamOnFileW(NULL, mode | stgm, &stream); ok(ret == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) || /* XP */ ret == E_INVALIDARG /* Vista */, - "SHCreateStreamOnFileW: expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) or E_INVALIDARG, got 0x%08x\n", ret); + "SHCreateStreamOnFileW: expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) or E_INVALIDARG, got 0x%08lx\n", ret); ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream); }
@@ -419,22 +419,22 @@ static void test_SHCreateStreamOnFileW(DWORD mode, DWORD stgm) { /* This test crashes on WinXP SP2 */ ret = SHCreateStreamOnFileW(test_file, mode | stgm, NULL); - ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret); + ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08lx\n", ret); }
stream = NULL; ret = SHCreateStreamOnFileW(test_file, mode | STGM_CONVERT | stgm, &stream); - ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret); + ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08lx\n", ret); ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
stream = NULL; ret = SHCreateStreamOnFileW(test_file, mode | STGM_DELETEONRELEASE | stgm, &stream); - ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret); + ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08lx\n", ret); ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
stream = NULL; ret = SHCreateStreamOnFileW(test_file, mode | STGM_TRANSACTED | stgm, &stream); - ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret); + ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08lx\n", ret); ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
/* file does not exist */ @@ -446,12 +446,12 @@ static void test_SHCreateStreamOnFileW(DWORD mode, DWORD stgm) return; }
- ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "SHCreateStreamOnFileW: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08x\n", ret); + ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "SHCreateStreamOnFileW: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08lx\n", ret); ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
stream = NULL; ret = SHCreateStreamOnFileW(test_file, mode | STGM_CREATE | stgm, &stream); - ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08lx\n", ret); ok(stream != NULL, "SHCreateStreamOnFileW: expected a valid IStream object, got NULL\n");
if (stream) { @@ -459,7 +459,7 @@ static void test_SHCreateStreamOnFileW(DWORD mode, DWORD stgm) test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream); - ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %d\n", refcount); + ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %ld\n", refcount); }
/* NOTE: don't delete the file, as it will be used for the file exists tests. */ @@ -468,19 +468,19 @@ static void test_SHCreateStreamOnFileW(DWORD mode, DWORD stgm)
stream = NULL; ret = SHCreateStreamOnFileW(test_file, mode | STGM_FAILIFTHERE | stgm, &stream); - ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08lx\n", ret); ok(stream != NULL, "SHCreateStreamOnFileW: expected a valid IStream object, got NULL\n");
if (stream) { test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream); - ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %d\n", refcount); + ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %ld\n", refcount); }
stream = NULL; ret = SHCreateStreamOnFileW(test_file, mode | STGM_CREATE | stgm, &stream); - ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08lx\n", ret); ok(stream != NULL, "SHCreateStreamOnFileW: expected a valid IStream object, got NULL\n");
if (stream) { @@ -490,10 +490,10 @@ static void test_SHCreateStreamOnFileW(DWORD mode, DWORD stgm) test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream); - ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %d\n", refcount); + ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %ld\n", refcount);
delret = DeleteFileA(test_fileA); - ok(delret, "SHCreateStreamOnFileW: could not delete the test file, got error %d\n", + ok(delret, "SHCreateStreamOnFileW: could not delete the test file, got error %ld\n", GetLastError()); } } @@ -511,7 +511,7 @@ static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm) BOOL delret;
if (winetest_debug > 1) - trace("SHCreateStreamOnFileEx: testing mode %d, STGM flags %08x\n", mode, stgm); + trace("SHCreateStreamOnFileEx: testing mode %ld, STGM flags %08lx\n", mode, stgm);
/* Don't used a fixed path for the testEx.txt file */ GetTempPathA(MAX_PATH, test_fileA); @@ -527,7 +527,7 @@ static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm) ret = SHCreateStreamOnFileEx(NULL, mode, 0, FALSE, NULL, &stream); ok(ret == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) || /* XP */ ret == E_INVALIDARG /* Vista */, - "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) or E_INVALIDARG, got 0x%08x\n", ret); + "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) or E_INVALIDARG, got 0x%08lx\n", ret); ok(stream == NULL, "SHCreateStreamOnFileEx: expected a NULL IStream object, got %p\n", stream); }
@@ -541,7 +541,7 @@ static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm) ok( ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) || ret == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) or " - "HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got 0x%08x\n", ret); + "HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got 0x%08lx\n", ret);
ok(stream == NULL, "SHCreateStreamOnFileEx: expected a NULL IStream object, got %p\n", stream);
@@ -549,7 +549,7 @@ static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm) { /* This test crashes on WinXP SP2 */ ret = SHCreateStreamOnFileEx(test_file, mode, 0, FALSE, NULL, NULL); - ok(ret == E_INVALIDARG, "SHCreateStreamOnFileEx: expected E_INVALIDARG, got 0x%08x\n", ret); + ok(ret == E_INVALIDARG, "SHCreateStreamOnFileEx: expected E_INVALIDARG, got 0x%08lx\n", ret); }
/* file does not exist */ @@ -558,7 +558,7 @@ static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm) ret = SHCreateStreamOnFileEx(test_file, mode | STGM_FAILIFTHERE | stgm, 0, FALSE, NULL, &stream); if ((stgm & STGM_TRANSACTED) == STGM_TRANSACTED && mode == STGM_READ) { ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) /* XP */ || ret == E_INVALIDARG /* Vista */, - "SHCreateStreamOnFileEx: expected E_INVALIDARG or HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08x\n", ret); + "SHCreateStreamOnFileEx: expected E_INVALIDARG or HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08lx\n", ret);
if (ret == E_INVALIDARG) { skip("SHCreateStreamOnFileEx: STGM_TRANSACTED not supported in this configuration.\n"); @@ -568,7 +568,7 @@ static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm) ok( ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) || ret == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) or " - "HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got 0x%08x\n", ret); + "HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got 0x%08lx\n", ret); } ok(stream == NULL, "SHCreateStreamOnFileEx: expected a NULL IStream object, got %p\n", stream);
@@ -581,7 +581,7 @@ static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm) return; }
- ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08lx\n", ret); ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
if (stream) { @@ -589,10 +589,10 @@ static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm) test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream); - ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount); + ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %ld\n", refcount);
delret = DeleteFileA(test_fileA); - ok(delret, "SHCreateStreamOnFileEx: could not delete the test file, got error %d\n", + ok(delret, "SHCreateStreamOnFileEx: could not delete the test file, got error %ld\n", GetLastError()); }
@@ -603,17 +603,17 @@ static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm) Sleep(1000); ret = SHCreateStreamOnFileEx(test_file, mode | STGM_CREATE | stgm, 0, FALSE, NULL, &stream); } - ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08lx\n", ret); ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
if (stream) { test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream); - ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount); + ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %ld\n", refcount);
delret = DeleteFileA(test_fileA); - ok(delret, "SHCreateStreamOnFileEx: could not delete the test file, got error %d\n", + ok(delret, "SHCreateStreamOnFileEx: could not delete the test file, got error %ld\n", GetLastError()); }
@@ -624,14 +624,14 @@ static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm) Sleep(1000); ret = SHCreateStreamOnFileEx(test_file, mode | STGM_CREATE | stgm, 0, TRUE, NULL, &stream); } - ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08lx\n", ret); ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
if (stream) { test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream); - ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount); + ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %ld\n", refcount); }
/* NOTE: don't delete the file, as it will be used for the file exists tests. */ @@ -640,47 +640,47 @@ static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm)
stream = NULL; ret = SHCreateStreamOnFileEx(test_file, mode | STGM_FAILIFTHERE | stgm, 0, FALSE, NULL, &stream); - ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08lx\n", ret); ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
if (stream) { test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream); - ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount); + ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %ld\n", refcount); }
stream = NULL; ret = SHCreateStreamOnFileEx(test_file, mode | STGM_FAILIFTHERE | stgm, 0, TRUE, NULL, &stream); - ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), got 0x%08x\n", ret); + ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), got 0x%08lx\n", ret); ok(stream == NULL, "SHCreateStreamOnFileEx: expected a NULL IStream object, got %p\n", stream);
stream = NULL; ret = SHCreateStreamOnFileEx(test_file, mode | STGM_CREATE | stgm, 0, FALSE, NULL, &stream); - ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08lx\n", ret); ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
if (stream) { test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream); - ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount); + ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %ld\n", refcount); }
stream = NULL; ret = SHCreateStreamOnFileEx(test_file, mode | STGM_CREATE | stgm, 0, TRUE, NULL, &stream); - ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret); + ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08lx\n", ret); ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
if (stream) { test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream); - ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount); + ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %ld\n", refcount); }
delret = DeleteFileA(test_fileA); - ok(delret, "SHCreateStreamOnFileEx: could not delete the test file, got error %d\n", + ok(delret, "SHCreateStreamOnFileEx: could not delete the test file, got error %ld\n", GetLastError()); }
@@ -699,32 +699,32 @@ static void test_SHCreateStreamOnFileEx_CopyTo(void)
GetTempPathW(MAX_PATH, tmpPath); ret = GetTempFileNameW(tmpPath, prefix, 0, srcFileName); - ok(ret != 0, "GetTempFileName failed, got error %d\n", GetLastError()); + ok(ret != 0, "GetTempFileName failed, got error %ld\n", GetLastError()); ret = GetTempFileNameW(tmpPath, prefix, 0, dstFileName); - ok(ret != 0, "GetTempFileName failed, got error %d\n", GetLastError()); + ok(ret != 0, "GetTempFileName failed, got error %ld\n", GetLastError());
ret = SHCreateStreamOnFileEx(srcFileName, STGM_CREATE | STGM_READWRITE | STGM_DELETEONRELEASE, FILE_ATTRIBUTE_TEMPORARY, FALSE, NULL, &src); - ok(SUCCEEDED(ret), "SHCreateStreamOnFileEx failed with ret=0x%08x\n", ret); + ok(SUCCEEDED(ret), "SHCreateStreamOnFileEx failed with ret=0x%08lx\n", ret);
written.QuadPart = 0; ret = IStream_Write(src, srcContents, sizeof(srcContents), &U(written).LowPart); - ok(SUCCEEDED(ret), "ISequentialStream_Write failed with ret=0x%08x\n", ret); + ok(SUCCEEDED(ret), "ISequentialStream_Write failed with ret=0x%08lx\n", ret);
distance.QuadPart = 0; ret = IStream_Seek(src, distance, STREAM_SEEK_SET, &written); - ok(SUCCEEDED(ret), "ISequentialStream_Seek failed with ret=0x%08x\n", ret); + ok(SUCCEEDED(ret), "ISequentialStream_Seek failed with ret=0x%08lx\n", ret);
ret = SHCreateStreamOnFileEx(dstFileName, STGM_CREATE | STGM_READWRITE | STGM_DELETEONRELEASE, FILE_ATTRIBUTE_TEMPORARY, FALSE, NULL, &dst); - ok(SUCCEEDED(ret), "SHCreateStreamOnFileEx failed with ret=0x%08x\n", ret); + ok(SUCCEEDED(ret), "SHCreateStreamOnFileEx failed with ret=0x%08lx\n", ret);
/* Test using a count larger than the source file, so that the Read operation will fall short */ count.QuadPart = 2;
ret = IStream_CopyTo(src, dst, count, &read, &written); - ok(SUCCEEDED(ret), "CopyTo failed with ret=0x%08x\n", ret); + ok(SUCCEEDED(ret), "CopyTo failed with ret=0x%08lx\n", ret);
- ok(read.QuadPart == 1, "read does not match size: %d != 1\n", U(read).LowPart); - ok(written.QuadPart == 1, "written does not match size: %d != 1\n", U(written).LowPart); + ok(read.QuadPart == 1, "read does not match size: %ld != 1\n", U(read).LowPart); + ok(written.QuadPart == 1, "written does not match size: %ld != 1\n", U(written).LowPart);
IStream_Release(dst); IStream_Release(src); @@ -754,64 +754,64 @@ static void test_SHCreateMemStream(void) ok(stream != NULL, "Failed to create a stream.\n");
hr = IStream_QueryInterface(stream, &IID_ISequentialStream, (void **)&unk); - ok(hr == S_OK || broken(hr == E_NOINTERFACE) /* WinXP */, "Failed to QI, hr %#x.\n", hr); + ok(hr == S_OK || broken(hr == E_NOINTERFACE) /* WinXP */, "Failed to QI, hr %#lx.\n", hr); if (unk) IUnknown_Release(unk);
num = ~0; hr = IStream_Read(stream, buff, sizeof(buff), &num); - ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr); - ok(num == 0, "expected 0, got 0x%08x\n", num); + ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr); + ok(num == 0, "expected 0, got 0x%08lx\n", num);
num = ~0; memset(buff, 0x55, sizeof(buff)); hr = IStream_Write(stream, buff, sizeof(buff), &num); - ok(hr == S_OK, "Failed to write, hr %#x.\n", hr); - ok(num == sizeof(buff), "expected %u, got %u\n", sizeof(buff), num); + ok(hr == S_OK, "Failed to write, hr %#lx.\n", hr); + ok(num == sizeof(buff), "expected %Iu, got %lu\n", sizeof(buff), num);
off.QuadPart = 0; hr = IStream_Seek(stream, off, STREAM_SEEK_SET, NULL); - ok(hr == S_OK, "Failed to seek, hr %#x.\n", hr); + ok(hr == S_OK, "Failed to seek, hr %#lx.\n", hr);
num = ~0; memset(buff, 0, sizeof(buff)); hr = IStream_Read(stream, buff, sizeof(buff), &num); - ok(hr == S_OK, "Failed to read, hr %#x.\n", hr); - ok(num == sizeof(buff), "expected %u, got %u\n", sizeof(buff), num); + ok(hr == S_OK, "Failed to read, hr %#lx.\n", hr); + ok(num == sizeof(buff), "expected %Iu, got %lu\n", sizeof(buff), num); for (i = 0; i < ARRAY_SIZE(buff); i++) - ok(buff[i] == 0x55, "expected 0x55, got 0x%02x at %u\n", buff[i], i); + ok(buff[i] == 0x55, "expected 0x55, got 0x%02x at %lu\n", buff[i], i);
num = ~0; hr = IStream_Read(stream, buff, sizeof(buff), &num); - ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr); - ok(num == 0, "expected 0, got 0x%08x\n", num); + ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr); + ok(num == 0, "expected 0, got 0x%08lx\n", num);
num = ~0; memset(buff, 0x11, sizeof(buff)); hr = IStream_Write(stream, buff, sizeof(buff), &num); - ok(hr == S_OK, "Failed to write, hr %#x.\n", hr); - ok(num == sizeof(buff), "expected %u, got %u\n", sizeof(buff), num); + ok(hr == S_OK, "Failed to write, hr %#lx.\n", hr); + ok(num == sizeof(buff), "expected %Iu, got %lu\n", sizeof(buff), num);
off.QuadPart = -sizeof(buff); hr = IStream_Seek(stream, off, STREAM_SEEK_CUR, NULL); - ok(hr == S_OK, "Failed to seek, hr %#x.\n", hr); + ok(hr == S_OK, "Failed to seek, hr %#lx.\n", hr);
num = ~0; memset(buff, 0, sizeof(buff)); hr = IStream_Read(stream, buff, sizeof(buff), &num); - ok(hr == S_OK, "Failed to read, hr %#x.\n", hr); - ok(num == sizeof(buff), "expected %u, got %u\n", sizeof(buff), num); + ok(hr == S_OK, "Failed to read, hr %#lx.\n", hr); + ok(num == sizeof(buff), "expected %Iu, got %lu\n", sizeof(buff), num); for (i = 0; i < ARRAY_SIZE(buff); i++) - ok(buff[i] == 0x11, "expected 0x11, got 0x%02x at %u\n", buff[i], i); + ok(buff[i] == 0x11, "expected 0x11, got 0x%02x at %lu\n", buff[i], i);
num = ~0; hr = IStream_Read(stream, buff, sizeof(buff), &num); - ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr); - ok(num == 0, "expected 0, got 0x%08x\n", num); + ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr); + ok(num == 0, "expected 0, got 0x%08lx\n", num);
hr = IStream_Clone(stream, &stream2); todo_wine - ok(hr == S_OK || broken(hr == E_NOTIMPL) /* < Win8 */, "Failed to clone a stream, hr %#x.\n", hr); + ok(hr == S_OK || broken(hr == E_NOTIMPL) /* < Win8 */, "Failed to clone a stream, hr %#lx.\n", hr); if (hr == S_OK) IStream_Release(stream2);
diff --git a/dlls/shlwapi/tests/ordinal.c b/dlls/shlwapi/tests/ordinal.c index bac91c4c9d8..603a2ac2a76 100644 --- a/dlls/shlwapi/tests/ordinal.c +++ b/dlls/shlwapi/tests/ordinal.c @@ -197,7 +197,7 @@ static void test_GetAcceptLanguagesA(void) /* Get the original Value */ lres = RegOpenKeyA(HKEY_CURRENT_USER, ie_international, &hroot); if (lres) { - skip("RegOpenKey(%s) failed: %d\n", ie_international, lres); + skip("RegOpenKey(%s) failed: %ld\n", ie_international, lres); return; } len = sizeof(original); @@ -230,7 +230,7 @@ static void test_GetAcceptLanguagesA(void) hr = pGetAcceptLanguagesA( buffer, &len);
if (hr != S_OK) { - win_skip("GetAcceptLanguagesA failed with 0x%x\n", hr); + win_skip("GetAcceptLanguagesA failed with 0x%lx\n", hr); goto restore_original; }
@@ -238,7 +238,7 @@ static void test_GetAcceptLanguagesA(void) /* some windows versions use "lang" or "lang-country" as default */ language[0] = 0; hr = LcidToRfc1766A(lcid, language, sizeof(language)); - ok(hr == S_OK, "LcidToRfc1766A returned 0x%x and %s\n", hr, language); + ok(hr == S_OK, "LcidToRfc1766A returned 0x%lx and %s\n", hr, language); }
ok(!lstrcmpA(buffer, language), @@ -255,7 +255,7 @@ static void test_GetAcceptLanguagesA(void) exactsize = lstrlenA(entry);
lres = RegSetValueExA(hroot, acceptlanguage, 0, REG_SZ, (const BYTE *) entry, exactsize + 1); - ok(!lres, "got %d for RegSetValueExA: %s\n", lres, entry); + ok(!lres, "got %ld for RegSetValueExA: %s\n", lres, entry);
/* len includes space for the terminating 0 before vista/w2k8 */ len = exactsize + 2; @@ -266,7 +266,7 @@ static void test_GetAcceptLanguagesA(void) (SUCCEEDED(hr) && ((len == exactsize) || (len == exactsize+1)) && !lstrcmpA(buffer, entry)), - "+2_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer); + "+2_#%d: got 0x%lx with %ld and %s\n", i, hr, len, buffer);
len = exactsize + 1; memset(buffer, '#', maxlen); @@ -276,7 +276,7 @@ static void test_GetAcceptLanguagesA(void) (SUCCEEDED(hr) && ((len == exactsize) || (len == exactsize+1)) && !lstrcmpA(buffer, entry)), - "+1_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer); + "+1_#%d: got 0x%lx with %ld and %s\n", i, hr, len, buffer);
len = exactsize; memset(buffer, '#', maxlen); @@ -296,7 +296,7 @@ static void test_GetAcceptLanguagesA(void) ((hr == S_OK) && !memcmp(buffer, language, len)) || ((hr == E_NOT_SUFFICIENT_BUFFER) && !len) || ((hr == __HRESULT_FROM_WIN32(ERROR_MORE_DATA)) && len == exactsize)), - "==_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer); + "==_#%d: got 0x%lx with %ld and %s\n", i, hr, len, buffer);
if (exactsize > 1) { len = exactsize - 1; @@ -308,7 +308,7 @@ static void test_GetAcceptLanguagesA(void) ((hr == S_OK) && !memcmp(buffer, language, len)) || ((hr == E_NOT_SUFFICIENT_BUFFER) && !len) || ((hr == __HRESULT_FROM_WIN32(ERROR_MORE_DATA)) && len == exactsize - 1)), - "-1_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer); + "-1_#%d: got 0x%lx with %ld and %s\n", i, hr, len, buffer); }
len = 1; @@ -320,7 +320,7 @@ static void test_GetAcceptLanguagesA(void) ((hr == S_OK) && !memcmp(buffer, language, len)) || ((hr == E_NOT_SUFFICIENT_BUFFER) && !len) || ((hr == __HRESULT_FROM_WIN32(ERROR_MORE_DATA)) && len == 1)), - "=1_#%d: got 0x%x with %d and %s\n", i, hr, len, buffer); + "=1_#%d: got 0x%lx with %ld and %s\n", i, hr, len, buffer);
len = maxlen; hr = pGetAcceptLanguagesA( NULL, &len); @@ -329,7 +329,7 @@ static void test_GetAcceptLanguagesA(void) since w2k8: S_OK and needed size (excluding 0), win8 S_OK and size including 0. */ ok( ((hr == S_OK) && ((len == exactsize) || (len == exactsize + 1))) || ((hr == E_FAIL) && (len == maxlen)), - "NULL,max #%d: got 0x%x with %d and %s\n", i, hr, len, buffer); + "NULL,max #%d: got 0x%lx with %ld and %s\n", i, hr, len, buffer);
i++; } @@ -342,7 +342,7 @@ static void test_GetAcceptLanguagesA(void) buffer[maxlen] = 0; hr = pGetAcceptLanguagesA( buffer, &len); ok( ((hr == S_OK) && (len == lstrlenA(language))), - "max: got 0x%x with %d and %s (expected S_OK with %d and '%s'\n", + "max: got 0x%lx with %ld and %s (expected S_OK with %d and '%s'\n", hr, len, buffer, lstrlenA(language), language);
len = 2; @@ -352,7 +352,7 @@ static void test_GetAcceptLanguagesA(void) ok( (((hr == S_OK) || (hr == E_INVALIDARG)) && !memcmp(buffer, language, len)) || ((hr == E_NOT_SUFFICIENT_BUFFER) && !len) || ((hr == __HRESULT_FROM_WIN32(ERROR_CANNOT_COPY)) && !len), - "=2: got 0x%x with %d and %s\n", hr, len, buffer); + "=2: got 0x%lx with %ld and %s\n", hr, len, buffer);
len = 1; memset(buffer, '#', maxlen); @@ -365,7 +365,7 @@ static void test_GetAcceptLanguagesA(void) ok( (((hr == S_OK) || (hr == E_INVALIDARG)) && !memcmp(buffer, language, len)) || ((hr == E_NOT_SUFFICIENT_BUFFER) && !len) || ((hr == __HRESULT_FROM_WIN32(ERROR_CANNOT_COPY)) && !len), - "=1: got 0x%x with %d and %s\n", hr, len, buffer); + "=1: got 0x%lx with %ld and %s\n", hr, len, buffer);
len = 0; memset(buffer, '#', maxlen); @@ -373,26 +373,26 @@ static void test_GetAcceptLanguagesA(void) hr = pGetAcceptLanguagesA( buffer, &len); /* w2k3 and below: E_FAIL, since w2k8: E_INVALIDARG, win8 ERROR_CANNOT_COPY */ ok((hr == E_FAIL) || (hr == E_INVALIDARG) || (hr == __HRESULT_FROM_WIN32(ERROR_CANNOT_COPY)), - "got 0x%x\n", hr); + "got 0x%lx\n", hr);
memset(buffer, '#', maxlen); buffer[maxlen] = 0; hr = pGetAcceptLanguagesA( buffer, NULL); /* w2k3 and below: E_FAIL, since w2k8: E_INVALIDARG */ ok((hr == E_FAIL) || (hr == E_INVALIDARG), - "got 0x%x (expected E_FAIL or E_INVALIDARG)\n", hr); + "got 0x%lx (expected E_FAIL or E_INVALIDARG)\n", hr);
hr = pGetAcceptLanguagesA( NULL, NULL); /* w2k3 and below: E_FAIL, since w2k8: E_INVALIDARG */ ok((hr == E_FAIL) || (hr == E_INVALIDARG), - "got 0x%x (expected E_FAIL or E_INVALIDARG)\n", hr); + "got 0x%lx (expected E_FAIL or E_INVALIDARG)\n", hr);
restore_original: if (!res_query) { len = lstrlenA(original); lres = RegSetValueExA(hroot, acceptlanguage, 0, REG_SZ, (const BYTE *) original, len ? len + 1: 0); - ok(!lres, "RegSetValueEx(%s) failed: %d\n", original, lres); + ok(!lres, "RegSetValueEx(%s) failed: %ld\n", original, lres); } else { @@ -460,25 +460,25 @@ static void test_alloc_shared(int argc, char **argv)
procid=GetCurrentProcessId(); hmem=pSHAllocShared(NULL,10,procid); - ok(hmem!=NULL,"SHAllocShared(NULL...) failed: %u\n", GetLastError()); + ok(hmem!=NULL,"SHAllocShared(NULL...) failed: %lu\n", GetLastError()); ret = pSHFreeShared(hmem, procid); - ok( ret, "SHFreeShared failed: %u\n", GetLastError()); + ok( ret, "SHFreeShared failed: %lu\n", GetLastError());
val.value = 0x12345678; val.handle = 0; hmem = pSHAllocShared(&val, sizeof(val), procid); - ok(hmem!=NULL,"SHAllocShared(NULL...) failed: %u\n", GetLastError()); + ok(hmem!=NULL,"SHAllocShared(NULL...) failed: %lu\n", GetLastError());
p=pSHLockShared(hmem,procid); - ok(p!=NULL,"SHLockShared failed: %u\n", GetLastError()); + ok(p!=NULL,"SHLockShared failed: %lu\n", GetLastError()); if (p!=NULL) - ok(p->value == 0x12345678, "Wrong value in shared memory: %d instead of %d\n", p->value, 0x12345678); + ok(p->value == 0x12345678, "Wrong value in shared memory: %ld instead of %d\n", p->value, 0x12345678); ret = pSHUnlockShared(p); - ok( ret, "SHUnlockShared failed: %u\n", GetLastError()); + ok( ret, "SHUnlockShared failed: %lu\n", GetLastError());
- sprintf(cmdline, "%s %s %d %p", argv[0], argv[1], procid, hmem); + sprintf(cmdline, "%s %s %ld %p", argv[0], argv[1], procid, hmem); ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi); - ok(ret, "could not create child process error: %u\n", GetLastError()); + ok(ret, "could not create child process error: %lu\n", GetLastError()); if (ret) { wait_child_process(pi.hProcess); @@ -486,37 +486,37 @@ static void test_alloc_shared(int argc, char **argv) CloseHandle(pi.hProcess);
p = pSHLockShared(hmem, procid); - ok(p != NULL,"SHLockShared failed: %u\n", GetLastError()); + ok(p != NULL,"SHLockShared failed: %lu\n", GetLastError()); if (p != NULL && p->value != 0x12345678) { - ok(p->value == 0x12345679, "Wrong value in shared memory: %d instead of %d\n", p->value, 0x12345679); + ok(p->value == 0x12345679, "Wrong value in shared memory: %ld instead of %d\n", p->value, 0x12345679); hmem2 = p->handle; ok(hmem2 != NULL, "Expected handle in shared memory\n"); } ret = pSHUnlockShared(p); - ok(ret, "SHUnlockShared failed: %u\n", GetLastError()); + ok(ret, "SHUnlockShared failed: %lu\n", GetLastError()); }
ret = pSHFreeShared(hmem, procid); - ok( ret, "SHFreeShared failed: %u\n", GetLastError()); + ok( ret, "SHFreeShared failed: %lu\n", GetLastError());
if (hmem2) { p = pSHLockShared(hmem2, procid); - ok(p != NULL,"SHLockShared failed: %u\n", GetLastError()); + ok(p != NULL,"SHLockShared failed: %lu\n", GetLastError()); if (p != NULL) - ok(p->value == 0xDEADBEEF, "Wrong value in shared memory: %d instead of %d\n", p->value, 0xDEADBEEF); + ok(p->value == 0xDEADBEEF, "Wrong value in shared memory: %ld instead of %d\n", p->value, 0xDEADBEEF); ret = pSHUnlockShared(p); - ok(ret, "SHUnlockShared failed: %u\n", GetLastError()); + ok(ret, "SHUnlockShared failed: %lu\n", GetLastError());
ret = pSHFreeShared(hmem2, procid); - ok(ret, "SHFreeShared failed: %u\n", GetLastError()); + ok(ret, "SHFreeShared failed: %lu\n", GetLastError()); }
SetLastError(0xdeadbeef); ret = pSHFreeShared(NULL, procid); - ok(ret, "SHFreeShared failed: %u\n", GetLastError()); - ok(GetLastError() == 0xdeadbeef, "last error should not have changed, got %u\n", GetLastError()); + ok(ret, "SHFreeShared failed: %lu\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "last error should not have changed, got %lu\n", GetLastError()); }
static void test_alloc_shared_remote(DWORD procid, HANDLE hmem) @@ -527,36 +527,36 @@ static void test_alloc_shared_remote(DWORD procid, HANDLE hmem)
/* test directly accessing shared memory of a remote process */ p = pSHLockShared(hmem, procid); - ok(p != NULL || broken(p == NULL) /* Windows 7/8 */, "SHLockShared failed: %u\n", GetLastError()); + ok(p != NULL || broken(p == NULL) /* Windows 7/8 */, "SHLockShared failed: %lu\n", GetLastError()); if (p == NULL) { win_skip("Subprocess failed to modify shared memory, skipping test\n"); return; }
- ok(p->value == 0x12345678, "Wrong value in shared memory: %d instead of %d\n", p->value, 0x12345678); + ok(p->value == 0x12345678, "Wrong value in shared memory: %ld instead of %d\n", p->value, 0x12345678); p->value++;
val.value = 0xDEADBEEF; val.handle = 0; p->handle = pSHAllocShared(&val, sizeof(val), procid); - ok(p->handle != NULL, "SHAllocShared failed: %u\n", GetLastError()); + ok(p->handle != NULL, "SHAllocShared failed: %lu\n", GetLastError());
ret = pSHUnlockShared(p); - ok(ret, "SHUnlockShared failed: %u\n", GetLastError()); + ok(ret, "SHUnlockShared failed: %lu\n", GetLastError());
/* test SHMapHandle */ SetLastError(0xdeadbeef); hmem2 = pSHMapHandle(NULL, procid, GetCurrentProcessId(), 0, 0); ok(hmem2 == NULL, "expected NULL, got new handle\n"); - ok(GetLastError() == 0xdeadbeef, "last error should not have changed, got %u\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "last error should not have changed, got %lu\n", GetLastError());
hmem2 = pSHMapHandle(hmem, procid, GetCurrentProcessId(), 0, 0);
/* It seems like Windows Vista/2008 uses a different internal implementation * for shared memory, and calling SHMapHandle fails. */ ok(hmem2 != NULL || broken(hmem2 == NULL), - "SHMapHandle failed: %u\n", GetLastError()); + "SHMapHandle failed: %lu\n", GetLastError()); if (hmem2 == NULL) { win_skip("Subprocess failed to map shared memory, skipping test\n"); @@ -564,16 +564,16 @@ static void test_alloc_shared_remote(DWORD procid, HANDLE hmem) }
p = pSHLockShared(hmem2, GetCurrentProcessId()); - ok(p != NULL, "SHLockShared failed: %u\n", GetLastError()); + ok(p != NULL, "SHLockShared failed: %lu\n", GetLastError());
if (p != NULL) - ok(p->value == 0x12345679, "Wrong value in shared memory: %d instead of %d\n", p->value, 0x12345679); + ok(p->value == 0x12345679, "Wrong value in shared memory: %ld instead of %d\n", p->value, 0x12345679);
ret = pSHUnlockShared(p); - ok(ret, "SHUnlockShared failed: %u\n", GetLastError()); + ok(ret, "SHUnlockShared failed: %lu\n", GetLastError());
ret = pSHFreeShared(hmem2, GetCurrentProcessId()); - ok(ret, "SHFreeShared failed: %u\n", GetLastError()); + ok(ret, "SHFreeShared failed: %lu\n", GetLastError()); }
static void test_fdsa(void) @@ -608,52 +608,52 @@ static void test_fdsa(void) memset(&info, 0, sizeof(info));
ok(pFDSA_Initialize(block_size, inc, &info, mem, init_blocks), "FDSA_Initialize rets FALSE\n"); - ok(info.num_items == 0, "num_items = %d\n", info.num_items); + ok(info.num_items == 0, "num_items = %ld\n", info.num_items); ok(info.mem == mem, "mem = %p\n", info.mem); - ok(info.blocks_alloced == init_blocks, "blocks_alloced = %d\n", info.blocks_alloced); + ok(info.blocks_alloced == init_blocks, "blocks_alloced = %ld\n", info.blocks_alloced); ok(info.inc == inc, "inc = %d\n", info.inc); ok(info.block_size == block_size, "block_size = %d\n", info.block_size); ok(info.flags == 0, "flags = %d\n", info.flags);
ret = pFDSA_InsertItem(&info, 1234, "1234567890"); - ok(ret == 0, "ret = %d\n", ret); - ok(info.num_items == 1, "num_items = %d\n", info.num_items); + ok(ret == 0, "ret = %ld\n", ret); + ok(info.num_items == 1, "num_items = %ld\n", info.num_items); ok(info.mem == mem, "mem = %p\n", info.mem); - ok(info.blocks_alloced == init_blocks, "blocks_alloced = %d\n", info.blocks_alloced); + ok(info.blocks_alloced == init_blocks, "blocks_alloced = %ld\n", info.blocks_alloced); ok(info.inc == inc, "inc = %d\n", info.inc); ok(info.block_size == block_size, "block_size = %d\n", info.block_size); ok(info.flags == 0, "flags = %d\n", info.flags);
ret = pFDSA_InsertItem(&info, 1234, "abcdefghij"); - ok(ret == 1, "ret = %d\n", ret); + ok(ret == 1, "ret = %ld\n", ret);
ret = pFDSA_InsertItem(&info, 1, "klmnopqrst"); - ok(ret == 1, "ret = %d\n", ret); + ok(ret == 1, "ret = %ld\n", ret);
ret = pFDSA_InsertItem(&info, 0, "uvwxyzABCD"); - ok(ret == 0, "ret = %d\n", ret); + ok(ret == 0, "ret = %ld\n", ret); ok(info.mem == mem, "mem = %p\n", info.mem); ok(info.flags == 0, "flags = %d\n", info.flags);
/* This next InsertItem will cause shlwapi to allocate its own mem buffer */ ret = pFDSA_InsertItem(&info, 0, "EFGHIJKLMN"); - ok(ret == 0, "ret = %d\n", ret); + ok(ret == 0, "ret = %ld\n", ret); ok(info.mem != mem, "mem = %p\n", info.mem); - ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %d\n", info.blocks_alloced); + ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %ld\n", info.blocks_alloced); ok(info.flags == 0x1, "flags = %d\n", info.flags);
ok(!memcmp(info.mem, "EFGHIJKLMNuvwxyzABCD1234567890klmnopqrstabcdefghij", 50), "mem %s\n", (char*)info.mem);
ok(pFDSA_DeleteItem(&info, 2), "rets FALSE\n"); ok(info.mem != mem, "mem = %p\n", info.mem); - ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %d\n", info.blocks_alloced); + ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %ld\n", info.blocks_alloced); ok(info.flags == 0x1, "flags = %d\n", info.flags);
ok(!memcmp(info.mem, "EFGHIJKLMNuvwxyzABCDklmnopqrstabcdefghij", 40), "mem %s\n", (char*)info.mem);
ok(pFDSA_DeleteItem(&info, 3), "rets FALSE\n"); ok(info.mem != mem, "mem = %p\n", info.mem); - ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %d\n", info.blocks_alloced); + ok(info.blocks_alloced == init_blocks + inc, "blocks_alloced = %ld\n", info.blocks_alloced); ok(info.flags == 0x1, "flags = %d\n", info.flags);
ok(!memcmp(info.mem, "EFGHIJKLMNuvwxyzABCDklmnopqrst", 30), "mem %s\n", (char*)info.mem); @@ -716,11 +716,11 @@ static void test_GetShellSecurityDescriptor(void) ok(IsValidSecurityDescriptor(psd), "returned value is not valid SD\n");
ret = GetSecurityDescriptorControl(psd, &control, &dwRev); - ok(ret, "GetSecurityDescriptorControl failed with error %u\n", GetLastError()); + ok(ret, "GetSecurityDescriptorControl failed with error %lu\n", GetLastError()); ok(0 == (control & SE_SELF_RELATIVE), "SD should be absolute\n");
ret = GetSecurityDescriptorDacl(psd, &bHasDacl, &pAcl, &bDefaulted); - ok(ret, "GetSecurityDescriptorDacl failed with error %u\n", GetLastError()); + ok(ret, "GetSecurityDescriptorDacl failed with error %lu\n", GetLastError());
ok(bHasDacl, "SD has no DACL\n"); if (bHasDacl) @@ -735,36 +735,36 @@ static void test_GetShellSecurityDescriptor(void) ok(IsValidAcl(pAcl), "DACL is not valid\n");
ret = GetAclInformation(pAcl, &asiSize, sizeof(asiSize), AclSizeInformation); - ok(ret, "GetAclInformation failed with error %u\n", GetLastError()); + ok(ret, "GetAclInformation failed with error %lu\n", GetLastError());
- ok(asiSize.AceCount == 3, "Incorrect number of ACEs: %d entries\n", asiSize.AceCount); + ok(asiSize.AceCount == 3, "Incorrect number of ACEs: %ld entries\n", asiSize.AceCount); if (asiSize.AceCount == 3) { ACCESS_ALLOWED_ACE *paaa; /* will use for DENIED too */
ret = GetAce(pAcl, 0, (LPVOID*)&paaa); - ok(ret, "GetAce failed with error %u\n", GetLastError()); + ok(ret, "GetAce failed with error %lu\n", GetLastError()); ok(paaa->Header.AceType == ACCESS_ALLOWED_ACE_TYPE, "Invalid ACE type %d\n", paaa->Header.AceType); ok(paaa->Header.AceFlags == 0, "Invalid ACE flags %x\n", paaa->Header.AceFlags); - ok(paaa->Mask == GENERIC_ALL, "Invalid ACE mask %x\n", paaa->Mask); + ok(paaa->Mask == GENERIC_ALL, "Invalid ACE mask %lx\n", paaa->Mask);
ret = GetAce(pAcl, 1, (LPVOID*)&paaa); - ok(ret, "GetAce failed with error %u\n", GetLastError()); + ok(ret, "GetAce failed with error %lu\n", GetLastError()); ok(paaa->Header.AceType == ACCESS_DENIED_ACE_TYPE, "Invalid ACE type %d\n", paaa->Header.AceType); /* first one of two ACEs generated from inheritable entry - without inheritance */ ok(paaa->Header.AceFlags == 0, "Invalid ACE flags %x\n", paaa->Header.AceFlags); - ok(paaa->Mask == GENERIC_WRITE, "Invalid ACE mask %x\n", paaa->Mask); + ok(paaa->Mask == GENERIC_WRITE, "Invalid ACE mask %lx\n", paaa->Mask);
ret = GetAce(pAcl, 2, (LPVOID*)&paaa); - ok(ret, "GetAce failed with error %u\n", GetLastError()); + ok(ret, "GetAce failed with error %lu\n", GetLastError()); ok(paaa->Header.AceType == ACCESS_DENIED_ACE_TYPE, "Invalid ACE type %d\n", paaa->Header.AceType); /* second ACE - with inheritance */ ok(paaa->Header.AceFlags == MY_INHERITANCE, "Invalid ACE flags %x\n", paaa->Header.AceFlags); - ok(paaa->Mask == GENERIC_READ, "Invalid ACE mask %x\n", paaa->Mask); + ok(paaa->Mask == GENERIC_READ, "Invalid ACE mask %lx\n", paaa->Mask); } } } @@ -782,17 +782,17 @@ static void test_SHPackDispParams(void) memset(¶ms, 0xc0, sizeof(params)); memset(vars, 0xc0, sizeof(vars)); hres = pSHPackDispParams(¶ms, vars, 1, VT_I4, 0xdeadbeef); - ok(hres == S_OK, "SHPackDispParams failed: %08x\n", hres); + ok(hres == S_OK, "SHPackDispParams failed: %08lx\n", hres); ok(params.cArgs == 1, "params.cArgs = %d\n", params.cArgs); ok(params.cNamedArgs == 0, "params.cNamedArgs = %d\n", params.cArgs); ok(params.rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", params.rgdispidNamedArgs); ok(params.rgvarg == vars, "params.rgvarg = %p\n", params.rgvarg); ok(V_VT(vars) == VT_I4, "V_VT(var) = %d\n", V_VT(vars)); - ok(V_I4(vars) == 0xdeadbeef, "failed %x\n", V_I4(vars)); + ok(V_I4(vars) == 0xdeadbeef, "failed %lx\n", V_I4(vars));
memset(¶ms, 0xc0, sizeof(params)); hres = pSHPackDispParams(¶ms, NULL, 0, 0); - ok(hres == S_OK, "SHPackDispParams failed: %08x\n", hres); + ok(hres == S_OK, "SHPackDispParams failed: %08lx\n", hres); ok(params.cArgs == 0, "params.cArgs = %d\n", params.cArgs); ok(params.cNamedArgs == 0, "params.cNamedArgs = %d\n", params.cArgs); ok(params.rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", params.rgdispidNamedArgs); @@ -802,17 +802,17 @@ static void test_SHPackDispParams(void) memset(¶ms, 0xc0, sizeof(params)); hres = pSHPackDispParams(¶ms, vars, 4, VT_BSTR, (void*)0xdeadbeef, VT_EMPTY, 10, VT_I4, 100, VT_DISPATCH, (void*)0xdeadbeef); - ok(hres == S_OK, "SHPackDispParams failed: %08x\n", hres); + ok(hres == S_OK, "SHPackDispParams failed: %08lx\n", hres); ok(params.cArgs == 4, "params.cArgs = %d\n", params.cArgs); ok(params.cNamedArgs == 0, "params.cNamedArgs = %d\n", params.cArgs); ok(params.rgdispidNamedArgs == NULL, "params.rgdispidNamedArgs = %p\n", params.rgdispidNamedArgs); ok(params.rgvarg == vars, "params.rgvarg = %p\n", params.rgvarg); ok(V_VT(vars) == VT_DISPATCH, "V_VT(vars[0]) = %x\n", V_VT(vars)); - ok(V_I4(vars) == 0xdeadbeef, "V_I4(vars[0]) = %x\n", V_I4(vars)); + ok(V_I4(vars) == 0xdeadbeef, "V_I4(vars[0]) = %lx\n", V_I4(vars)); ok(V_VT(vars+1) == VT_I4, "V_VT(vars[1]) = %d\n", V_VT(vars+1)); - ok(V_I4(vars+1) == 100, "V_I4(vars[1]) = %x\n", V_I4(vars+1)); + ok(V_I4(vars+1) == 100, "V_I4(vars[1]) = %lx\n", V_I4(vars+1)); ok(V_VT(vars+2) == VT_I4, "V_VT(vars[2]) = %d\n", V_VT(vars+2)); - ok(V_I4(vars+2) == 10, "V_I4(vars[2]) = %x\n", V_I4(vars+2)); + ok(V_I4(vars+2) == 10, "V_I4(vars[2]) = %lx\n", V_I4(vars+2)); ok(V_VT(vars+3) == VT_BSTR, "V_VT(vars[3]) = %d\n", V_VT(vars+3)); ok(V_BSTR(vars+3) == (void*)0xdeadbeef, "V_BSTR(vars[3]) = %p\n", V_BSTR(vars+3)); } @@ -964,13 +964,13 @@ static HRESULT WINAPI Disp_Invoke( EXCEPINFO *pExcepInfo, UINT *puArgErr) { - trace("%p %x %s %x %x %p %p %p %p\n", This, dispIdMember, wine_dbgstr_guid(riid), lcid, wFlags, + trace("%p %lx %s %lx %x %p %p %p %p\n", This, dispIdMember, wine_dbgstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
ok(dispIdMember == 0xa0 || dispIdMember == 0xa1, "Unknown dispIdMember\n"); ok(pDispParams != NULL, "Invoked with NULL pDispParams\n"); ok(wFlags == DISPATCH_METHOD, "Wrong flags %x\n",wFlags); - ok(lcid == 0,"Wrong lcid %x\n",lcid); + ok(lcid == 0,"Wrong lcid %lx\n",lcid); if (dispIdMember == 0xa0) { ok(pDispParams->cArgs == 0, "params.cArgs = %d\n", pDispParams->cArgs); @@ -986,7 +986,7 @@ static HRESULT WINAPI Disp_Invoke( ok(V_VT(pDispParams->rgvarg) == VT_BSTR, "V_VT(var) = %d\n", V_VT(pDispParams->rgvarg)); ok(V_I4(pDispParams->rgvarg) == 0xdeadcafe , "failed %p\n", V_BSTR(pDispParams->rgvarg)); ok(V_VT(pDispParams->rgvarg+1) == VT_I4, "V_VT(var) = %d\n", V_VT(pDispParams->rgvarg+1)); - ok(V_I4(pDispParams->rgvarg+1) == 0xdeadbeef, "failed %x\n", V_I4(pDispParams->rgvarg+1)); + ok(V_I4(pDispParams->rgvarg+1) == 0xdeadbeef, "failed %lx\n", V_I4(pDispParams->rgvarg+1)); }
return ERROR_SUCCESS; @@ -1461,32 +1461,32 @@ static void test_IConnectionPoint(void)
rc = pConnectToConnectionPoint((IUnknown*)&dispatch->IDispatch_iface, &IID_NULL, TRUE, (IUnknown*)&container->IConnectionPointContainer_iface, &cookie, &point); - ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc); + ok(rc == S_OK, "pConnectToConnectionPoint failed with %lx\n",rc); ok(point != NULL, "returned ConnectionPoint is NULL\n"); ok(cookie != 0xffffffff, "invalid cookie returned\n");
rc = pIConnectionPoint_SimpleInvoke(point,0xa0,NULL); - ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc); + ok(rc == S_OK, "pConnectToConnectionPoint failed with %lx\n",rc);
memset(¶ms, 0xc0, sizeof(params)); memset(vars, 0xc0, sizeof(vars)); rc = pSHPackDispParams(¶ms, vars, 2, VT_I4, 0xdeadbeef, VT_BSTR, 0xdeadcafe); - ok(rc == S_OK, "SHPackDispParams failed: %08x\n", rc); + ok(rc == S_OK, "SHPackDispParams failed: %08lx\n", rc);
rc = pIConnectionPoint_SimpleInvoke(point,0xa1,¶ms); - ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc); + ok(rc == S_OK, "pConnectToConnectionPoint failed with %lx\n",rc);
rc = pConnectToConnectionPoint(NULL, &IID_NULL, FALSE, (IUnknown*)&container->IConnectionPointContainer_iface, &cookie, NULL); - ok(rc == S_OK, "pConnectToConnectionPoint failed with %x\n",rc); + ok(rc == S_OK, "pConnectToConnectionPoint failed with %lx\n",rc);
/* MSDN says this should be required but it crashes on XP IUnknown_Release(point); */ ref = IConnectionPointContainer_Release(&container->IConnectionPointContainer_iface); - ok(ref == 0, "leftover IConnectionPointContainer reference %i\n",ref); + ok(ref == 0, "leftover IConnectionPointContainer reference %li\n",ref); ref = IDispatch_Release(&dispatch->IDispatch_iface); - ok(ref == 0, "leftover IDispatch reference %i\n",ref); + ok(ref == 0, "leftover IDispatch reference %li\n",ref); }
typedef struct _propbag @@ -1585,16 +1585,16 @@ static void test_SHPropertyBag_ReadLONG(void)
out = 0xfeedface; rc = pSHPropertyBag_ReadLONG(NULL, szName1, &out); - ok(rc == E_INVALIDARG || broken(rc == S_OK), "incorrect return %x\n",rc); + ok(rc == E_INVALIDARG || broken(rc == S_OK), "incorrect return %lx\n",rc); ok(out == 0xfeedface, "value should not have changed\n"); rc = pSHPropertyBag_ReadLONG(&pb->IPropertyBag_iface, NULL, &out); - ok(rc == E_INVALIDARG || broken(rc == S_OK) || broken(rc == S_FALSE), "incorrect return %x\n",rc); + ok(rc == E_INVALIDARG || broken(rc == S_OK) || broken(rc == S_FALSE), "incorrect return %lx\n",rc); ok(out == 0xfeedface, "value should not have changed\n"); rc = pSHPropertyBag_ReadLONG(&pb->IPropertyBag_iface, szName1, NULL); - ok(rc == E_INVALIDARG || broken(rc == S_OK) || broken(rc == S_FALSE), "incorrect return %x\n",rc); + ok(rc == E_INVALIDARG || broken(rc == S_OK) || broken(rc == S_FALSE), "incorrect return %lx\n",rc); rc = pSHPropertyBag_ReadLONG(&pb->IPropertyBag_iface, szName1, &out); - ok(rc == DISP_E_BADVARTYPE || broken(rc == S_OK) || broken(rc == S_FALSE), "incorrect return %x\n",rc); - ok(out == 0xfeedface || broken(out == 0xfeedfa00), "value should not have changed %x\n",out); + ok(rc == DISP_E_BADVARTYPE || broken(rc == S_OK) || broken(rc == S_FALSE), "incorrect return %lx\n",rc); + ok(out == 0xfeedface || broken(out == 0xfeedfa00), "value should not have changed %lx\n",out); IPropertyBag_Release(&pb->IPropertyBag_iface); }
@@ -1623,9 +1623,9 @@ static void test_SHSetWindowBits(void) /* null window */ SetLastError(0xdeadbeef); style = pSHSetWindowBits(NULL, GWL_STYLE, 0, 0); - ok(style == 0, "expected 0 retval, got %d\n", style); + ok(style == 0, "expected 0 retval, got %ld\n", style); ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, - "expected ERROR_INVALID_WINDOW_HANDLE, got %d\n", GetLastError()); + "expected ERROR_INVALID_WINDOW_HANDLE, got %ld\n", GetLastError());
/* zero mask, zero flags */ styleold = GetWindowLongA(hwnd, GWL_STYLE); @@ -1638,19 +1638,19 @@ static void test_SHSetWindowBits(void) ok(styleold & WS_VISIBLE, "expected WS_VISIBLE\n"); style = pSHSetWindowBits(hwnd, GWL_STYLE, WS_VISIBLE, 0);
- ok(style == styleold, "expected previous style, got %x\n", style); + ok(style == styleold, "expected previous style, got %lx\n", style); ok((GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE) == 0, "expected updated style\n");
/* test mask, unset style bit used */ styleold = GetWindowLongA(hwnd, GWL_STYLE); style = pSHSetWindowBits(hwnd, GWL_STYLE, WS_VISIBLE, 0); - ok(style == styleold, "expected previous style, got %x\n", style); + ok(style == styleold, "expected previous style, got %lx\n", style); ok(styleold == GetWindowLongA(hwnd, GWL_STYLE), "expected to keep old style\n");
/* set back with flags */ styleold = GetWindowLongA(hwnd, GWL_STYLE); style = pSHSetWindowBits(hwnd, GWL_STYLE, WS_VISIBLE, WS_VISIBLE); - ok(style == styleold, "expected previous style, got %x\n", style); + ok(style == styleold, "expected previous style, got %lx\n", style); ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "expected updated style\n");
/* reset and try to set without a mask */ @@ -1658,7 +1658,7 @@ static void test_SHSetWindowBits(void) ok((GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE) == 0, "expected updated style\n"); styleold = GetWindowLongA(hwnd, GWL_STYLE); style = pSHSetWindowBits(hwnd, GWL_STYLE, 0, WS_VISIBLE); - ok(style == styleold, "expected previous style, got %x\n", style); + ok(style == styleold, "expected previous style, got %lx\n", style); ok((GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE) == 0, "expected updated style\n");
DestroyWindow(hwnd); @@ -1687,7 +1687,7 @@ static void test_SHFormatDateTimeA(void) buff[0] = 'a'; buff[1] = 0; ret = pSHFormatDateTimeA(&filetime, NULL, buff, 0); ok(ret == 0, "got %d\n", ret); - ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n", GetLastError()); ok(buff[0] == 'a', "expected same string, got %s\n", buff);
/* flags needs to have FDTF_NOAUTOREADINGORDER for these tests to succeed on Vista+ */ @@ -1697,20 +1697,20 @@ static void test_SHFormatDateTimeA(void) SetLastError(0xdeadbeef); ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff)); ok(ret == lstrlenA(buff)+1, "got %d\n", ret); - ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n", GetLastError());
flags = FDTF_NOAUTOREADINGORDER | FDTF_SHORTDATE | FDTF_LONGDATE; SetLastError(0xdeadbeef); ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff)); ok(ret == lstrlenA(buff)+1, "got %d\n", ret); - ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n", GetLastError());
flags = FDTF_SHORTDATE | FDTF_LTRDATE | FDTF_RTLDATE; SetLastError(0xdeadbeef); ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff)); ok(ret == lstrlenA(buff)+1, "got %d\n", ret); ok(GetLastError() == 0xdeadbeef, - "expected 0xdeadbeef, got %d\n", GetLastError()); + "expected 0xdeadbeef, got %ld\n", GetLastError());
flags = FDTF_DEFAULT; ret = pSHFormatDateTimeA(&filetime, &flags, buff, sizeof(buff)); @@ -1850,13 +1850,13 @@ if (0) SetLastError(0xdeadbeef); ret = pSHFormatDateTimeW(&filetime, NULL, NULL, 0); ok(ret == 0, "expected 0, got %d\n", ret); - ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n", GetLastError());
SetLastError(0xdeadbeef); buff[0] = 'a'; buff[1] = 0; ret = pSHFormatDateTimeW(&filetime, NULL, buff, 0); ok(ret == 0, "expected 0, got %d\n", ret); - ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n", GetLastError()); ok(buff[0] == 'a', "expected same string\n");
/* all combinations documented as invalid succeeded */ @@ -1865,14 +1865,14 @@ if (0) ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff)); ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff), "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret); - ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n", GetLastError());
flags = FDTF_SHORTDATE | FDTF_LONGDATE; SetLastError(0xdeadbeef); ret = pSHFormatDateTimeW(&filetime, &flags, buff, ARRAY_SIZE(buff)); ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff), "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret); - ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n", GetLastError());
flags = FDTF_SHORTDATE | FDTF_LTRDATE | FDTF_RTLDATE; SetLastError(0xdeadbeef); @@ -1881,7 +1881,7 @@ if (0) ok(ret == lstrlenW(buff)+1 || ret == lstrlenW(buff), "expected %d or %d, got %d\n", lstrlenW(buff)+1, lstrlenW(buff), ret); ok(GetLastError() == 0xdeadbeef, - "expected 0xdeadbeef, got %d\n", GetLastError()); + "expected 0xdeadbeef, got %ld\n", GetLastError());
/* now check returned strings */ flags = FDTF_SHORTTIME; @@ -2044,7 +2044,7 @@ static void test_SHGetObjectCompatFlags(void)
/* null args */ ret = pSHGetObjectCompatFlags(NULL, NULL); - ok(ret == 0, "got %d\n", ret); + ok(ret == 0, "got %ld\n", ret);
ret = RegOpenKeyA(HKEY_LOCAL_MACHINE, compat_path, &root); if (ret != ERROR_SUCCESS) @@ -2080,7 +2080,7 @@ static void test_SHGetObjectCompatFlags(void)
pGUIDFromStringA(keyA, &clsid); got = pSHGetObjectCompatFlags(NULL, &clsid); - ok(got == expected, "got 0x%08x, expected 0x%08x. Key %s\n", got, expected, keyA); + ok(got == expected, "got 0x%08lx, expected 0x%08lx. Key %s\n", got, expected, keyA);
RegCloseKey(clsid_key); } @@ -2304,7 +2304,7 @@ static void test_IUnknown_QueryServiceExec(void) hr = pIUnknown_QueryServiceExec(NULL, &dummy_serviceid, &dummy_groupid, 0, 0, 0, 0); ok(hr == E_FAIL || hr == E_NOTIMPL, /* win 8 */ - "got 0x%08x\n", hr); + "got 0x%08lx\n", hr);
/* expected trace: IUnknown_QueryServiceExec( ptr1, serviceid, groupid, arg1, arg2, arg3, arg4); @@ -2320,7 +2320,7 @@ static void test_IUnknown_QueryServiceExec(void)
init_call_trace(&trace_got); hr = pIUnknown_QueryServiceExec((IUnknown*)provider, &dummy_serviceid, &dummy_groupid, 0x1, 0x2, (void*)0x3, (void*)0x4); - ok(hr == S_OK, "got 0x%08x\n", hr); + ok(hr == S_OK, "got 0x%08lx\n", hr);
ok_trace(&trace_expected, &trace_got);
@@ -2414,7 +2414,7 @@ static void test_IUnknown_ProfferService(void) hr = pIUnknown_ProfferService(NULL, &dummy_serviceid, 0, 0); ok(hr == E_FAIL || hr == E_NOTIMPL, /* win 8 */ - "got 0x%08x\n", hr); + "got 0x%08lx\n", hr);
/* expected trace: IUnknown_ProfferService( ptr1, serviceid, arg1, arg2); @@ -2435,8 +2435,8 @@ static void test_IUnknown_ProfferService(void) init_call_trace(&trace_got); cookie = 0; hr = pIUnknown_ProfferService((IUnknown*)proff, &dummy_serviceid, provider, &cookie); - ok(hr == S_OK, "got 0x%08x\n", hr); - ok(cookie == 0xdeadbeef, "got %x\n", cookie); + ok(hr == S_OK, "got 0x%08lx\n", hr); + ok(cookie == 0xdeadbeef, "got %lx\n", cookie);
ok_trace(&trace_expected, &trace_got); free_call_trace(&trace_got); @@ -2450,10 +2450,10 @@ static void test_IUnknown_ProfferService(void) add_call(&trace_expected, 4, (void*)(DWORD_PTR)cookie, 0, 0, 0, 0);
init_call_trace(&trace_got); - ok(cookie != 0, "got %x\n", cookie); + ok(cookie != 0, "got %lx\n", cookie); hr = pIUnknown_ProfferService((IUnknown*)proff, &dummy_serviceid, 0, &cookie); - ok(hr == S_OK, "got 0x%08x\n", hr); - ok(cookie == 0, "got %x\n", cookie); + ok(hr == S_OK, "got 0x%08lx\n", hr); + ok(cookie == 0, "got %lx\n", cookie); ok_trace(&trace_expected, &trace_got); free_call_trace(&trace_got); free_call_trace(&trace_expected); @@ -2477,7 +2477,7 @@ static void test_SHCreateWorkerWindowA(void) ok(lstrcmpA(classA, "WorkerA") == 0, "expected WorkerA class, got %s\n", classA);
ret = GetWindowLongPtrA(hwnd, 0); - ok(ret == 0, "got %ld\n", ret); + ok(ret == 0, "got %Id\n", ret);
/* class info */ memset(&cliA, 0, sizeof(cliA)); @@ -2498,19 +2498,19 @@ static void test_SHCreateWorkerWindowA(void) ok(lstrcmpA(classA, "WorkerA") == 0, "expected WorkerA class, got %s\n", classA);
ret = GetWindowLongPtrA(hwnd, 0); - ok(ret == 0xdeadbeef, "got %ld\n", ret); + ok(ret == 0xdeadbeef, "got %Id\n", ret);
/* test exstyle */ ret = GetWindowLongA(hwnd, GWL_EXSTYLE); ok(ret == WS_EX_WINDOWEDGE || - ret == (WS_EX_WINDOWEDGE|WS_EX_LAYOUTRTL) /* systems with RTL locale */, "0x%08lx\n", ret); + ret == (WS_EX_WINDOWEDGE|WS_EX_LAYOUTRTL) /* systems with RTL locale */, "0x%08Ix\n", ret);
DestroyWindow(hwnd);
hwnd = pSHCreateWorkerWindowA(0, NULL, WS_EX_TOOLWINDOW, 0, 0, 0); ret = GetWindowLongA(hwnd, GWL_EXSTYLE); ok(ret == (WS_EX_WINDOWEDGE|WS_EX_TOOLWINDOW) || - ret == (WS_EX_WINDOWEDGE|WS_EX_TOOLWINDOW|WS_EX_LAYOUTRTL) /* systems with RTL locale */, "0x%08lx\n", ret); + ret == (WS_EX_WINDOWEDGE|WS_EX_TOOLWINDOW|WS_EX_LAYOUTRTL) /* systems with RTL locale */, "0x%08Ix\n", ret); DestroyWindow(hwnd); }
@@ -2643,16 +2643,16 @@ static void test_SHIShellFolder_EnumObjects(void) /* SHIShellFolder_EnumObjects doesn't QI the object for IShellFolder */ enm = (IEnumIDList*)0xdeadbeef; hres = pSHIShellFolder_EnumObjects(&ShellFolder, NULL, 0, &enm); - ok(hres == S_OK, "SHIShellFolder_EnumObjects failed: 0x%08x\n", hres); + ok(hres == S_OK, "SHIShellFolder_EnumObjects failed: 0x%08lx\n", hres); ok(enm == (IEnumIDList*)0xcafebabe, "Didn't get expected enumerator location, instead: %p\n", enm);
/* SHIShellFolder_EnumObjects isn't strict about the IShellFolder object */ hres = SHGetDesktopFolder(&folder); - ok(hres == S_OK, "SHGetDesktopFolder failed: 0x%08x\n", hres); + ok(hres == S_OK, "SHGetDesktopFolder failed: 0x%08lx\n", hres);
enm = NULL; hres = pSHIShellFolder_EnumObjects(folder, NULL, 0, &enm); - ok(hres == S_OK, "SHIShellFolder_EnumObjects failed: 0x%08x\n", hres); + ok(hres == S_OK, "SHIShellFolder_EnumObjects failed: 0x%08lx\n", hres); ok(enm != NULL, "Didn't get an enumerator\n"); if(enm) IEnumIDList_Release(enm); @@ -2729,27 +2729,27 @@ static void test_SHGetIniString(void) }
ret = pSHGetIniStringW(TestAppW, AKeyW, out, 0, pathW); - ok(ret == 0, "SHGetIniStringW should have given 0, instead: %d\n", ret); + ok(ret == 0, "SHGetIniStringW should have given 0, instead: %ld\n", ret);
/* valid arguments */ out[0] = 0; SetLastError(0xdeadbeef); ret = pSHGetIniStringW(TestAppW, NULL, out, ARRAY_SIZE(out), pathW); - ok(ret == 4, "SHGetIniStringW should have given 4, instead: %d\n", ret); - ok(!lstrcmpW(out, AKeyW), "Expected %s, got: %s, %d\n", + ok(ret == 4, "SHGetIniStringW should have given 4, instead: %ld\n", ret); + ok(!lstrcmpW(out, AKeyW), "Expected %s, got: %s, %ld\n", wine_dbgstr_w(AKeyW), wine_dbgstr_w(out), GetLastError());
ret = pSHGetIniStringW(TestAppW, AKeyW, out, ARRAY_SIZE(out), pathW); - ok(ret == 1, "SHGetIniStringW should have given 1, instead: %d\n", ret); + ok(ret == 1, "SHGetIniStringW should have given 1, instead: %ld\n", ret); ok(!lstrcmpW(out, L"1"), "Expected L"1", got: %s\n", wine_dbgstr_w(out));
ret = pSHGetIniStringW(TestAppW, AnotherKeyW, out, ARRAY_SIZE(out), pathW); - ok(ret == 4, "SHGetIniStringW should have given 4, instead: %d\n", ret); + ok(ret == 4, "SHGetIniStringW should have given 4, instead: %ld\n", ret); ok(!lstrcmpW(out, L"asdf"), "Expected L"asdf", got: %s\n", wine_dbgstr_w(out));
out[0] = 1; ret = pSHGetIniStringW(TestAppW, JunkKeyW, out, ARRAY_SIZE(out), pathW); - ok(ret == 0, "SHGetIniStringW should have given 0, instead: %d\n", ret); + ok(ret == 0, "SHGetIniStringW should have given 0, instead: %ld\n", ret); ok(*out == 0, "Expected L"", got: %s\n", wine_dbgstr_w(out));
DeleteFileW(pathW); @@ -2854,40 +2854,40 @@ static void test_SHGetShellKey(void)
size = sizeof(data); hres = pSKGetValueW(SHKEY_Root_HKLM, WineTestW, NULL, NULL, &data, &size); - ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "hres = %x\n", hres); + ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "hres = %lx\n", hres);
data = 1234; hres = pSKSetValueW(SHKEY_Root_HKLM, WineTestW, NULL, REG_DWORD, &data, sizeof(DWORD)); - ok(hres == S_OK, "hres = %x\n", hres); + ok(hres == S_OK, "hres = %lx\n", hres);
size = 1; hres = pSKGetValueW(SHKEY_Root_HKLM, WineTestW, NULL, NULL, NULL, &size); - ok(hres == S_OK, "hres = %x\n", hres); - ok(size == sizeof(DWORD), "size = %d\n", size); + ok(hres == S_OK, "hres = %lx\n", hres); + ok(size == sizeof(DWORD), "size = %ld\n", size);
data = 0xdeadbeef; hres = pSKGetValueW(SHKEY_Root_HKLM, WineTestW, NULL, NULL, &data, &size); - ok(hres == S_OK, "hres = %x\n", hres); - ok(size == sizeof(DWORD), "size = %d\n", size); - ok(data == 1234, "data = %d\n", data); + ok(hres == S_OK, "hres = %lx\n", hres); + ok(size == sizeof(DWORD), "size = %ld\n", size); + ok(data == 1234, "data = %ld\n", data);
hres = pSKAllocValueW(SHKEY_Root_HKLM, WineTestW, NULL, NULL, (void**)&alloc_data, &size); - ok(hres == S_OK, "hres= %x\n", hres); - ok(size == sizeof(DWORD), "size = %d\n", size); + ok(hres == S_OK, "hres= %lx\n", hres); + ok(size == sizeof(DWORD), "size = %ld\n", size); if (SUCCEEDED(hres)) { - ok(*alloc_data == 1234, "*alloc_data = %d\n", *alloc_data); + ok(*alloc_data == 1234, "*alloc_data = %ld\n", *alloc_data); LocalFree(alloc_data); }
hres = pSKDeleteValueW(SHKEY_Root_HKLM, WineTestW, NULL); - ok(hres == S_OK, "hres = %x\n", hres); + ok(hres == S_OK, "hres = %lx\n", hres);
hres = pSKDeleteValueW(SHKEY_Root_HKLM, WineTestW, NULL); - ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "hres = %x\n", hres); + ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "hres = %lx\n", hres);
hres = pSKGetValueW(SHKEY_Root_HKLM, WineTestW, NULL, NULL, &data, &size); - ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "hres = %x\n", hres); + ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "hres = %lx\n", hres);
hkey = pSHGetShellKey(SHKEY_Root_HKLM, NULL, FALSE); ok(hkey != NULL, "Can't create key\n"); @@ -2953,21 +2953,21 @@ static void test_SHSetParentHwnd(void) ret = GetParent(hwnd); ok(ret == NULL, "got %p\n", ret); style = GetWindowLongA(hwnd, GWL_STYLE); - ok((style & (WS_POPUP|WS_CHILD)) == 0, "got style 0x%08x\n", style); + ok((style & (WS_POPUP|WS_CHILD)) == 0, "got style 0x%08lx\n", style); ret = pSHSetParentHwnd(hwnd, NULL); ok(ret == NULL, "got %p\n", ret); style = GetWindowLongA(hwnd, GWL_STYLE); - ok((style & (WS_POPUP|WS_CHILD)) == 0, "got style 0x%08x\n", style); + ok((style & (WS_POPUP|WS_CHILD)) == 0, "got style 0x%08lx\n", style);
/* reset to null parent from not null */ ret = GetParent(hwnd2); ok(ret == hwnd, "got %p\n", ret); style = GetWindowLongA(hwnd2, GWL_STYLE); - ok((style & (WS_POPUP|WS_CHILD)) == WS_CHILD, "got style 0x%08x\n", style); + ok((style & (WS_POPUP|WS_CHILD)) == WS_CHILD, "got style 0x%08lx\n", style); ret = pSHSetParentHwnd(hwnd2, NULL); ok(ret == NULL, "got %p\n", ret); style = GetWindowLongA(hwnd2, GWL_STYLE); - ok((style & (WS_POPUP|WS_CHILD)) == WS_POPUP, "got style 0x%08x\n", style); + ok((style & (WS_POPUP|WS_CHILD)) == WS_POPUP, "got style 0x%08lx\n", style); ret = GetParent(hwnd2); ok(ret == NULL, "got %p\n", ret);
@@ -2975,13 +2975,13 @@ static void test_SHSetParentHwnd(void) style = GetWindowLongA(hwnd2, GWL_STYLE); SetWindowLongA(hwnd2, GWL_STYLE, style & ~(WS_CHILD|WS_POPUP)); style = GetWindowLongA(hwnd2, GWL_STYLE); - ok((style & (WS_CHILD|WS_POPUP)) == 0, "got 0x%08x\n", style); + ok((style & (WS_CHILD|WS_POPUP)) == 0, "got 0x%08lx\n", style);
ret = pSHSetParentHwnd(hwnd2, hwnd); todo_wine ok(ret == NULL, "got %p\n", ret);
style = GetWindowLongA(hwnd2, GWL_STYLE); - ok((style & (WS_POPUP|WS_CHILD)) == WS_CHILD, "got style 0x%08x\n", style); + ok((style & (WS_POPUP|WS_CHILD)) == WS_CHILD, "got style 0x%08lx\n", style); ret = GetParent(hwnd2); ok(ret == hwnd, "got %p\n", ret);
@@ -2992,7 +2992,7 @@ static void test_SHSetParentHwnd(void) ret = pSHSetParentHwnd(hwnd2, hwnd); todo_wine ok(ret == NULL, "got %p\n", ret); style = GetWindowLongA(hwnd2, GWL_STYLE); - ok((style & (WS_CHILD|WS_POPUP)) == WS_CHILD, "got 0x%08x\n", style); + ok((style & (WS_CHILD|WS_POPUP)) == WS_CHILD, "got 0x%08lx\n", style); ret = GetParent(hwnd2); ok(ret == hwnd, "got %p\n", ret);
@@ -3002,7 +3002,7 @@ static void test_SHSetParentHwnd(void) ret = pSHSetParentHwnd(hwnd2, hwnd); todo_wine ok(ret == hwnd, "got %p\n", ret); style = GetWindowLongA(hwnd2, GWL_STYLE); - ok((style & (WS_CHILD|WS_POPUP)) == WS_CHILD, "got 0x%08x\n", style); + ok((style & (WS_CHILD|WS_POPUP)) == WS_CHILD, "got 0x%08lx\n", style); ret = GetParent(hwnd2); ok(ret == hwnd, "got %p\n", ret);
@@ -3078,14 +3078,14 @@ static void test_IUnknown_GetClassID(void) memset(&clsid, 0xcc, sizeof(clsid)); memset(&clsid3, 0xcc, sizeof(clsid3)); hr = pIUnknown_GetClassID(NULL, &clsid); - ok(hr == E_FAIL, "got 0x%08x\n", hr); + ok(hr == E_FAIL, "got 0x%08lx\n", hr); ok(IsEqualCLSID(&clsid, &CLSID_NULL) || broken(IsEqualCLSID(&clsid, &clsid3)) /* win2k, winxp, win2k3 */, "got wrong clsid %s\n", wine_dbgstr_guid(&clsid));
memset(&clsid, 0xcc, sizeof(clsid)); memset(&clsid2, 0xab, sizeof(clsid2)); hr = pIUnknown_GetClassID((IUnknown*)&testpersist, &clsid); - ok(hr == 0x8fff2222, "got 0x%08x\n", hr); + ok(hr == 0x8fff2222, "got 0x%08lx\n", hr); ok(IsEqualCLSID(&clsid, &clsid2) || broken(IsEqualCLSID(&clsid, &clsid3)) /* win2k3 */, "got wrong clsid %s\n", wine_dbgstr_guid(&clsid));
@@ -3094,7 +3094,7 @@ static void test_IUnknown_GetClassID(void) memset(&clsid2, 0xab, sizeof(clsid2)); memset(&clsid3, 0xcc, sizeof(clsid3)); hr = pIUnknown_GetClassID((IUnknown*)&testpersist2, &clsid); - ok(hr == 0x8fff2222, "got 0x%08x\n", hr); + ok(hr == 0x8fff2222, "got 0x%08lx\n", hr); ok(IsEqualCLSID(&clsid, &clsid2) || broken(IsEqualCLSID(&clsid, &clsid3)) /* win2k3 */, "got wrong clsid %s\n", wine_dbgstr_guid(&clsid)); } @@ -3104,7 +3104,7 @@ static void test_DllGetVersion(void) HRESULT hr;
hr = pDllGetVersion(NULL); - ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); + ok(hr == E_INVALIDARG, "got 0x%08lx\n", hr); }
START_TEST(ordinal) @@ -3121,7 +3121,7 @@ START_TEST(ordinal) { DWORD procid; HANDLE hmem; - sscanf(argv[2], "%d", &procid); + sscanf(argv[2], "%ld", &procid); sscanf(argv[3], "%p", &hmem); test_alloc_shared_remote(procid, hmem); return; diff --git a/dlls/shlwapi/tests/path.c b/dlls/shlwapi/tests/path.c index dbe1f36fbfd..4614d3fea25 100644 --- a/dlls/shlwapi/tests/path.c +++ b/dlls/shlwapi/tests/path.c @@ -279,19 +279,19 @@ static void test_PathCreateFromUrl(void) /* Won't say how much is needed without a buffer */ len = 0xdeca; ret = pPathCreateFromUrlA("file://foo", NULL, &len, 0); - ok(ret == E_INVALIDARG, "got 0x%08x expected E_INVALIDARG\n", ret); - ok(len == 0xdeca, "got %x expected 0xdeca\n", len); + ok(ret == E_INVALIDARG, "got 0x%08lx expected E_INVALIDARG\n", ret); + ok(len == 0xdeca, "got %lx expected 0xdeca\n", len);
/* Test the decoding itself */ for (i = 0; i < ARRAY_SIZE(TEST_PATHFROMURL); i++) { len = INTERNET_MAX_URL_LENGTH; ret = pPathCreateFromUrlA(TEST_PATHFROMURL[i].url, ret_path, &len, 0); todo_wine_if (TEST_PATHFROMURL[i].todo & 0x1) - ok(ret == TEST_PATHFROMURL[i].ret, "ret %08x from url %s\n", ret, TEST_PATHFROMURL[i].url); + ok(ret == TEST_PATHFROMURL[i].ret, "ret %08lx from url %s\n", ret, TEST_PATHFROMURL[i].url); if(SUCCEEDED(ret) && TEST_PATHFROMURL[i].path) { if(!(TEST_PATHFROMURL[i].todo & 0x2)) { ok(!lstrcmpiA(ret_path, TEST_PATHFROMURL[i].path), "got %s expected %s from url %s\n", ret_path, TEST_PATHFROMURL[i].path, TEST_PATHFROMURL[i].url); - ok(len == strlen(ret_path), "ret len %d from url %s\n", len, TEST_PATHFROMURL[i].url); + ok(len == strlen(ret_path), "ret len %ld from url %s\n", len, TEST_PATHFROMURL[i].url); } else todo_wine /* Wrong string, don't bother checking the length */ ok(!lstrcmpiA(ret_path, TEST_PATHFROMURL[i].path), "got %s expected %s from url %s\n", ret_path, TEST_PATHFROMURL[i].path, TEST_PATHFROMURL[i].url); @@ -304,12 +304,12 @@ static void test_PathCreateFromUrl(void) ret = pPathCreateFromUrlW(urlW, ret_pathW, &len, 0); WideCharToMultiByte(CP_ACP, 0, ret_pathW, -1, ret_path, sizeof(ret_path),NULL,NULL); todo_wine_if (TEST_PATHFROMURL[i].todo & 0x1) - ok(ret == TEST_PATHFROMURL[i].ret, "ret %08x from url L"%s"\n", ret, TEST_PATHFROMURL[i].url); + ok(ret == TEST_PATHFROMURL[i].ret, "ret %08lx from url L"%s"\n", ret, TEST_PATHFROMURL[i].url); if(SUCCEEDED(ret) && TEST_PATHFROMURL[i].path) { if(!(TEST_PATHFROMURL[i].todo & 0x2)) { ok(!lstrcmpiW(ret_pathW, pathW), "got %s expected %s from url L"%s"\n", ret_path, TEST_PATHFROMURL[i].path, TEST_PATHFROMURL[i].url); - ok(len == lstrlenW(ret_pathW), "ret len %d from url L"%s"\n", len, TEST_PATHFROMURL[i].url); + ok(len == lstrlenW(ret_pathW), "ret len %ld from url L"%s"\n", len, TEST_PATHFROMURL[i].url); } else todo_wine /* Wrong string, don't bother checking the length */ ok(!lstrcmpiW(ret_pathW, pathW), "got %s expected %s from url L"%s"\n", @@ -321,9 +321,9 @@ static void test_PathCreateFromUrl(void) /* Check what happens if the buffer is too small */ len2 = 2; ret = pPathCreateFromUrlW(urlW, ret_pathW, &len2, 0); - ok(ret == E_POINTER, "ret %08x, expected E_POINTER from url %s\n", ret, TEST_PATHFROMURL[i].url); + ok(ret == E_POINTER, "ret %08lx, expected E_POINTER from url %s\n", ret, TEST_PATHFROMURL[i].url); todo_wine_if (TEST_PATHFROMURL[i].todo & 0x4) - ok(len2 == len + 1, "got len = %d expected %d from url %s\n", len2, len + 1, TEST_PATHFROMURL[i].url); + ok(len2 == len + 1, "got len = %ld expected %ld from url %s\n", len2, len + 1, TEST_PATHFROMURL[i].url); }
FreeWideString(urlW); @@ -338,7 +338,7 @@ static void test_PathCreateFromUrl(void)
pathW = NULL; ret = pPathCreateFromUrlAlloc(fileW, &pathW, 0); - ok(ret == S_OK, "got 0x%08x expected S_OK\n", ret); + ok(ret == S_OK, "got 0x%08lx expected S_OK\n", ret); ok(lstrcmpiW(pathW, fooW) == 0, "got %s expected %s\n", wine_dbgstr_w(pathW), wine_dbgstr_w(fooW)); HeapFree(GetProcessHeap(), 0, pathW); } @@ -566,19 +566,19 @@ static void test_PathCombineA(void) SetLastError(0xdeadbeef); str = PathCombineA(NULL, "C:\", "one\two\three"); ok(str == NULL, "Expected NULL, got %p\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try NULL dest and NULL directory */ SetLastError(0xdeadbeef); str = PathCombineA(NULL, NULL, "one\two\three"); ok(str == NULL, "Expected NULL, got %p\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try all NULL*/ SetLastError(0xdeadbeef); str = PathCombineA(NULL, NULL, NULL); ok(str == NULL, "Expected NULL, got %p\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try NULL file part */ SetLastError(0xdeadbeef); @@ -586,7 +586,7 @@ static void test_PathCombineA(void) str = PathCombineA(dest, "C:\", NULL); ok(str == dest, "Expected str == dest, got %p\n", str); ok(!lstrcmpA(str, "C:\"), "Expected C:\, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try empty file part */ SetLastError(0xdeadbeef); @@ -594,7 +594,7 @@ static void test_PathCombineA(void) str = PathCombineA(dest, "C:\", ""); ok(str == dest, "Expected str == dest, got %p\n", str); ok(!lstrcmpA(str, "C:\"), "Expected C:\, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try empty directory and file part */ SetLastError(0xdeadbeef); @@ -604,7 +604,7 @@ static void test_PathCombineA(void) ok(!lstrcmpA(str, "\") || broken(!lstrcmpA(str, "control")), /* Win95 and some W2K */ "Expected \, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try NULL directory */ SetLastError(0xdeadbeef); @@ -612,7 +612,7 @@ static void test_PathCombineA(void) str = PathCombineA(dest, NULL, "one\two\three"); ok(str == dest, "Expected str == dest, got %p\n", str); ok(!lstrcmpA(str, "one\two\three"), "Expected one\two\three, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try NULL directory and empty file part */ SetLastError(0xdeadbeef); @@ -624,7 +624,7 @@ static void test_PathCombineA(void) "Expected \, got %s\n", str); ok(GetLastError() == 0xdeadbeef || broken(GetLastError() == ERROR_INVALID_PARAMETER), /* Win95 */ - "Expected 0xdeadbeef, got %d\n", GetLastError()); + "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try NULL directory and file part */ SetLastError(0xdeadbeef); @@ -635,7 +635,7 @@ static void test_PathCombineA(void) "Expected str == NULL, got %p\n", str); ok(!dest[0] || broken(!lstrcmpA(dest, "control")), /* Win95 and some W2K */ "Expected 0 length, got %i\n", lstrlenA(dest)); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try directory without backslash */ SetLastError(0xdeadbeef); @@ -643,7 +643,7 @@ static void test_PathCombineA(void) str = PathCombineA(dest, "C:", "one\two\three"); ok(str == dest, "Expected str == dest, got %p\n", str); ok(!lstrcmpA(str, "C:\one\two\three"), "Expected C:\one\two\three, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try directory with backslash */ SetLastError(0xdeadbeef); @@ -651,7 +651,7 @@ static void test_PathCombineA(void) str = PathCombineA(dest, "C:\", "one\two\three"); ok(str == dest, "Expected str == dest, got %p\n", str); ok(!lstrcmpA(str, "C:\one\two\three"), "Expected C:\one\two\three, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try directory with backslash and file with prepended backslash */ SetLastError(0xdeadbeef); @@ -659,7 +659,7 @@ static void test_PathCombineA(void) str = PathCombineA(dest, "C:\", "\one\two\three"); ok(str == dest, "Expected str == dest, got %p\n", str); ok(!lstrcmpA(str, "C:\one\two\three"), "Expected C:\one\two\three, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try previous test, with backslash appended as well */ SetLastError(0xdeadbeef); @@ -667,13 +667,13 @@ static void test_PathCombineA(void) str = PathCombineA(dest, "C:\", "\one\two\three\"); ok(str == dest, "Expected str == dest, got %p\n", str); ok(!lstrcmpA(str, "C:\one\two\three\"), "Expected C:\one\two\three\, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try a relative directory */ SetLastError(0xdeadbeef); lstrcpyA(dest, "control"); str = PathCombineA(dest, "relative\dir", "\one\two\three\"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); /* Vista fails which probably makes sense as PathCombineA expects an absolute dir */ if (str) { @@ -687,7 +687,7 @@ static void test_PathCombineA(void) str = PathCombineA(dest, "C:\", "one/two/three\"); ok(str == dest, "Expected str == dest, got %p\n", str); ok(!lstrcmpA(str, "C:\one/two/three\"), "Expected one/two/three\, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try a really weird directory */ SetLastError(0xdeadbeef); @@ -695,7 +695,7 @@ static void test_PathCombineA(void) str = PathCombineA(dest, "C:\/\/", "\one\two\three\"); ok(str == dest, "Expected str == dest, got %p\n", str); ok(!lstrcmpA(str, "C:\one\two\three\"), "Expected C:\one\two\three\, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try periods */ SetLastError(0xdeadbeef); @@ -703,7 +703,7 @@ static void test_PathCombineA(void) str = PathCombineA(dest, "C:\", "one\..\two\.\three"); ok(str == dest, "Expected str == dest, got %p\n", str); ok(!lstrcmpA(str, "C:\two\three"), "Expected C:\two\three, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try .. as file */ /* try forward slashes */ @@ -712,7 +712,7 @@ static void test_PathCombineA(void) str = PathCombineA(dest, "C:\", ".."); ok(str == dest, "Expected str == dest, got %p\n", str); ok(!lstrcmpA(str, "C:\"), "Expected C:\, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try relative paths */ /* try forward slashes */ @@ -721,7 +721,7 @@ static void test_PathCombineA(void) str = PathCombineA(dest, "../../../one/two/", "*"); ok(str == dest, "Expected str == dest, got %p\n", str); ok(!lstrcmpA(str, "../../../one/two/\*"), "Expected ../../../one/two/\*, got %s\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
memset(too_long, 'a', LONG_LEN); too_long[LONG_LEN - 1] = '\0'; @@ -733,7 +733,7 @@ static void test_PathCombineA(void) ok(str == NULL, "Expected str == NULL, got %p\n", str); ok(!dest[0] || broken(!lstrcmpA(dest, "control")), /* Win95 and some W2K */ "Expected 0 length, got %i\n", lstrlenA(dest)); - todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try a directory longer than MAX_PATH */ SetLastError(0xdeadbeef); @@ -742,7 +742,7 @@ static void test_PathCombineA(void) ok(str == NULL, "Expected str == NULL, got %p\n", str); ok(!dest[0] || broken(!lstrcmpA(dest, "control")), /* Win95 and some W2K */ "Expected 0 length, got %i\n", lstrlenA(dest)); - todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
memset(one, 'b', HALF_LEN); memset(two, 'c', HALF_LEN); @@ -756,7 +756,7 @@ static void test_PathCombineA(void) ok(str == NULL, "Expected str == NULL, got %p\n", str); ok(!dest[0] || broken(!lstrcmpA(dest, "control")), /* Win95 and some W2K */ "Expected 0 length, got %i\n", lstrlenA(dest)); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); }
static void test_PathAddBackslash(void) @@ -769,7 +769,7 @@ static void test_PathAddBackslash(void) SetLastError(0xdeadbeef); str = PathAddBackslashA(NULL); ok(str == NULL, "Expected str == NULL, got %p\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try an empty path */ path[0] = '\0'; @@ -777,7 +777,7 @@ static void test_PathAddBackslash(void) str = PathAddBackslashA(path); ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str); ok(!path[0], "Expected empty string, got %i\n", lstrlenA(path)); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try a relative path */ lstrcpyA(path, "one\two"); @@ -785,7 +785,7 @@ static void test_PathAddBackslash(void) str = PathAddBackslashA(path); ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str); ok(!lstrcmpA(path, "one\two\"), "Expected one\two\, got %s\n", path); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try periods */ lstrcpyA(path, "one\..\two"); @@ -793,7 +793,7 @@ static void test_PathAddBackslash(void) str = PathAddBackslashA(path); ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str); ok(!lstrcmpA(path, "one\..\two\"), "Expected one\..\two\, got %s\n", path); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try just a space */ lstrcpyA(path, " "); @@ -801,7 +801,7 @@ static void test_PathAddBackslash(void) str = PathAddBackslashA(path); ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str); ok(!lstrcmpA(path, " \"), "Expected \, got %s\n", path); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* path already has backslash */ lstrcpyA(path, "C:\one\"); @@ -809,7 +809,7 @@ static void test_PathAddBackslash(void) str = PathAddBackslashA(path); ok(str == (path + lstrlenA(path)), "Expected str to point to end of path, got %p\n", str); ok(!lstrcmpA(path, "C:\one\"), "Expected C:\one\, got %s\n", path); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
memset(too_long, 'a', LONG_LEN); too_long[LONG_LEN - 1] = '\0'; @@ -818,7 +818,7 @@ static void test_PathAddBackslash(void) SetLastError(0xdeadbeef); str = PathAddBackslashA(too_long); ok(str == NULL, "Expected str == NULL, got %p\n", str); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); }
static void test_PathAppendA(void) @@ -834,28 +834,28 @@ static void test_PathAppendA(void) SetLastError(0xdeadbeef); res = PathAppendA(path, NULL); ok(!res, "Expected failure\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(path, "C:\one"), "Expected C:\one, got %s\n", path);
/* try empty pszMore */ SetLastError(0xdeadbeef); res = PathAppendA(path, ""); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(path, "C:\one"), "Expected C:\one, got %s\n", path);
/* try NULL pszPath */ SetLastError(0xdeadbeef); res = PathAppendA(NULL, "two\three"); ok(!res, "Expected failure\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try empty pszPath */ path[0] = '\0'; SetLastError(0xdeadbeef); res = PathAppendA(path, "two\three"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(path, "two\three"), "Expected \two\three, got %s\n", path);
/* try empty pszPath and empty pszMore */ @@ -863,7 +863,7 @@ static void test_PathAppendA(void) SetLastError(0xdeadbeef); res = PathAppendA(path, ""); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(path, "\"), "Expected \, got %s\n", path);
/* try legit params */ @@ -871,7 +871,7 @@ static void test_PathAppendA(void) SetLastError(0xdeadbeef); res = PathAppendA(path, "two\three"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(path, "C:\one\two\three"), "Expected C:\one\two\three, got %s\n", path);
/* try pszPath with backslash after it */ @@ -879,7 +879,7 @@ static void test_PathAppendA(void) SetLastError(0xdeadbeef); res = PathAppendA(path, "two\three"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(path, "C:\one\two\three"), "Expected C:\one\two\three, got %s\n", path);
/* try pszMore with backslash before it */ @@ -887,7 +887,7 @@ static void test_PathAppendA(void) SetLastError(0xdeadbeef); res = PathAppendA(path, "\two\three"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(path, "C:\one\two\three"), "Expected C:\one\two\three, got %s\n", path);
/* try pszMore with backslash after it */ @@ -895,7 +895,7 @@ static void test_PathAppendA(void) SetLastError(0xdeadbeef); res = PathAppendA(path, "two\three\"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(path, "C:\one\two\three\"), "Expected C:\one\two\three\, got %s\n", path);
/* try spaces in pszPath */ @@ -903,7 +903,7 @@ static void test_PathAppendA(void) SetLastError(0xdeadbeef); res = PathAppendA(path, "two\three"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(path, "C: \ one \two\three"), "Expected C: \ one \two\three, got %s\n", path);
/* try spaces in pszMore */ @@ -911,7 +911,7 @@ static void test_PathAppendA(void) SetLastError(0xdeadbeef); res = PathAppendA(path, " two \ three "); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(path, "C:\one\ two \ three "), "Expected 'C:\one\ two \ three ', got %s\n", path);
/* pszPath is too long */ @@ -920,7 +920,7 @@ static void test_PathAppendA(void) SetLastError(0xdeadbeef); res = PathAppendA(too_long, "two\three"); ok(!res, "Expected failure\n"); - todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!too_long[0] || broken(lstrlenA(too_long) == (LONG_LEN - 1)), /* Win95 and some W2K */ "Expected length of too_long to be zero, got %i\n", lstrlenA(too_long));
@@ -931,7 +931,7 @@ static void test_PathAppendA(void) SetLastError(0xdeadbeef); res = PathAppendA(path, too_long); ok(!res, "Expected failure\n"); - todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + todo_wine ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!path[0] || broken(!lstrcmpA(path, "C:\one")), /* Win95 and some W2K */ "Expected length of path to be zero, got %i\n", lstrlenA(path));
@@ -945,7 +945,7 @@ static void test_PathAppendA(void) ok(!res, "Expected failure\n"); ok(!path[0] || broken(lstrlenA(path) == (HALF_LEN - 1)), /* Win95 and some W2K */ "Expected length of path to be zero, got %i\n", lstrlenA(path)); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); }
static void test_PathCanonicalizeA(void) @@ -960,7 +960,7 @@ static void test_PathCanonicalizeA(void) res = PathCanonicalizeA(dest, NULL); ok(!res, "Expected failure\n"); ok(GetLastError() == ERROR_INVALID_PARAMETER, - "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError()); + "Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError()); ok(dest[0] == 0 || !lstrcmpA(dest, "test"), "Expected either an empty string (Vista) or test, got %s\n", dest);
@@ -969,7 +969,7 @@ static void test_PathCanonicalizeA(void) SetLastError(0xdeadbeef); res = PathCanonicalizeA(dest, ""); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(dest, "\") || broken(!lstrcmpA(dest, "test")), /* Win95 and some W2K */ "Expected \, got %s\n", dest); @@ -979,14 +979,14 @@ static void test_PathCanonicalizeA(void) res = PathCanonicalizeA(NULL, "C:\"); ok(!res, "Expected failure\n"); ok(GetLastError() == ERROR_INVALID_PARAMETER, - "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError()); + "Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
/* try empty dest */ dest[0] = '\0'; SetLastError(0xdeadbeef); res = PathCanonicalizeA(dest, "C:\"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(dest, "C:\"), "Expected C:\, got %s\n", dest);
/* try non-empty dest */ @@ -994,7 +994,7 @@ static void test_PathCanonicalizeA(void) SetLastError(0xdeadbeef); res = PathCanonicalizeA(dest, "C:\"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(dest, "C:\"), "Expected C:\, got %s\n", dest);
/* try a space for source */ @@ -1002,7 +1002,7 @@ static void test_PathCanonicalizeA(void) SetLastError(0xdeadbeef); res = PathCanonicalizeA(dest, " "); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(dest, " "), "Expected ' ', got %s\n", dest);
/* try a relative path */ @@ -1010,7 +1010,7 @@ static void test_PathCanonicalizeA(void) SetLastError(0xdeadbeef); res = PathCanonicalizeA(dest, "one\two"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(dest, "one\two"), "Expected one\two, got %s\n", dest);
/* try current dir and previous dir */ @@ -1018,7 +1018,7 @@ static void test_PathCanonicalizeA(void) SetLastError(0xdeadbeef); res = PathCanonicalizeA(dest, "C:\one\.\..\two\three\.."); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(dest, "C:\two"), "Expected C:\two, got %s\n", dest);
/* try simple forward slashes */ @@ -1026,7 +1026,7 @@ static void test_PathCanonicalizeA(void) SetLastError(0xdeadbeef); res = PathCanonicalizeA(dest, "C:\one/two/three\four/five\six"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(dest, "C:\one/two/three\four/five\six"), "Expected C:\one/two/three\four/five\six, got %s\n", dest);
@@ -1035,7 +1035,7 @@ static void test_PathCanonicalizeA(void) SetLastError(0xdeadbeef); res = PathCanonicalizeA(dest, "C:\one/.\two"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(dest, "C:\one/.\two"), "Expected C:\one/.\two, got %s\n", dest);
/* try simple forward slashes with change dir */ @@ -1043,7 +1043,7 @@ static void test_PathCanonicalizeA(void) SetLastError(0xdeadbeef); res = PathCanonicalizeA(dest, "C:\one/.\two\.."); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(dest, "C:\one/.") || !lstrcmpA(dest, "C:\one/"), /* Vista */ "Expected "C:\one/." or "C:\one/", got "%s"\n", dest); @@ -1053,7 +1053,7 @@ static void test_PathCanonicalizeA(void) SetLastError(0xdeadbeef); res = PathCanonicalizeA(dest, "../../one/two/"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(dest, "../../one/two/"), "Expected ../../one/two/, got %s\n", dest);
/* try relative forward slashes */ @@ -1061,7 +1061,7 @@ static void test_PathCanonicalizeA(void) SetLastError(0xdeadbeef); res = PathCanonicalizeA(dest, "../../one/two/\*"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(dest, "../../one/two/\*"), "Expected ../../one/two/\*, got %s\n", dest);
/* try forward slashes with change dirs @@ -1072,7 +1072,7 @@ static void test_PathCanonicalizeA(void) SetLastError(0xdeadbeef); res = PathCanonicalizeA(dest, "C:\one/.\..\two/three\..\four/.five"); ok(res, "Expected success\n"); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); ok(!lstrcmpA(dest, "C:\four/.five"), "Expected C:\four/.five, got %s\n", dest);
/* try src is too long */ @@ -1087,7 +1087,7 @@ static void test_PathCanonicalizeA(void) todo_wine { ok(GetLastError() == 0xdeadbeef || GetLastError() == ERROR_FILENAME_EXCED_RANGE /* Vista */, - "Expected 0xdeadbeef or ERROR_FILENAME_EXCED_RANGE, got %d\n", GetLastError()); + "Expected 0xdeadbeef or ERROR_FILENAME_EXCED_RANGE, got %ld\n", GetLastError()); } ok(lstrlenA(too_long) == LONG_LEN - 1, "Expected length LONG_LEN - 1, got %i\n", lstrlenA(too_long)); } @@ -1102,7 +1102,7 @@ static void test_PathFindExtensionA(void) SetLastError(0xdeadbeef); ext = PathFindExtensionA(NULL); ok(ext == NULL, "Expected NULL, got %p\n", ext); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try an empty path */ path[0] = '\0'; @@ -1110,7 +1110,7 @@ static void test_PathFindExtensionA(void) ext = PathFindExtensionA(path); ok(ext == path, "Expected ext == path, got %p\n", ext); ok(!ext[0], "Expected length 0, got %i\n", lstrlenA(ext)); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try a path without an extension */ lstrcpyA(path, "file"); @@ -1118,7 +1118,7 @@ static void test_PathFindExtensionA(void) ext = PathFindExtensionA(path); ok(ext == path + lstrlenA(path), "Expected ext == path, got %p\n", ext); ok(!ext[0], "Expected length 0, got %i\n", lstrlenA(ext)); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try a path with an extension */ lstrcpyA(path, "file.txt"); @@ -1127,7 +1127,7 @@ static void test_PathFindExtensionA(void) ok(ext == path + lstrlenA("file"), "Expected ext == path + lstrlenA("file"), got %p\n", ext); ok(!lstrcmpA(ext, ".txt"), "Expected .txt, got %s\n", ext); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try a path with two extensions */ lstrcpyA(path, "file.txt.doc"); @@ -1136,7 +1136,7 @@ static void test_PathFindExtensionA(void) ok(ext == path + lstrlenA("file.txt"), "Expected ext == path + lstrlenA("file.txt"), got %p\n", ext); ok(!lstrcmpA(ext, ".doc"), "Expected .txt, got %s\n", ext); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try a path longer than MAX_PATH without an extension*/ memset(too_long, 'a', LONG_LEN); @@ -1144,7 +1144,7 @@ static void test_PathFindExtensionA(void) SetLastError(0xdeadbeef); ext = PathFindExtensionA(too_long); ok(ext == too_long + LONG_LEN - 1, "Expected ext == too_long + LONG_LEN - 1, got %p\n", ext); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try a path longer than MAX_PATH with an extension*/ memset(too_long, 'a', LONG_LEN); @@ -1155,7 +1155,7 @@ static void test_PathFindExtensionA(void) ext = PathFindExtensionA(too_long); ok(ext == too_long + 300, "Expected ext == too_long + 300, got %p\n", ext); ok(lstrlenA(ext) == LONG_LEN - 301, "Expected LONG_LEN - 301, got %i\n", lstrlenA(ext)); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); }
static void test_PathBuildRootA(void) @@ -1178,7 +1178,7 @@ static void test_PathBuildRootA(void) root = PathBuildRootA(path, j); ok(root == path, "Expected root == path, got %p\n", root); ok(!lstrcmpA(root, root_expected[j]), "Expected %s, got %s\n", root_expected[j], root); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); }
/* test a negative drive number */ @@ -1188,7 +1188,7 @@ static void test_PathBuildRootA(void) ok(root == path, "Expected root == path, got %p\n", root); ok(!lstrcmpA(path, "aaaaaaaaa") || !path[0], /* Vista */ "Expected aaaaaaaaa or empty string, got %s\n", path); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* test a drive number greater than 25 */ SetLastError(0xdeadbeef); @@ -1197,7 +1197,7 @@ static void test_PathBuildRootA(void) ok(root == path, "Expected root == path, got %p\n", root); ok(!lstrcmpA(path, "aaaaaaaaa") || !path[0], /* Vista */ "Expected aaaaaaaaa or empty string, got %s\n", path); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* length of path is less than 4 */ SetLastError(0xdeadbeef); @@ -1205,13 +1205,13 @@ static void test_PathBuildRootA(void) root = PathBuildRootA(path, 0); ok(root == path, "Expected root == path, got %p\n", root); ok(!lstrcmpA(path, "A:\"), "Expected A:\, got %s\n", path); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* path is NULL */ SetLastError(0xdeadbeef); root = PathBuildRootA(NULL, 0); ok(root == NULL, "Expected root == NULL, got %p\n", root); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); }
static void test_PathCommonPrefixA(void) @@ -1231,7 +1231,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(out, "aaa"), "Expected aaa, got %s\n", out); } ok(!lstrcmpA(path2, "C:\"), "Expected C:\, got %s\n", path2); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* test NULL path2 */ SetLastError(0xdeadbeef); @@ -1244,7 +1244,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(out, "aaa"), "Expected aaa, got %s\n", out); } ok(!lstrcmpA(path1, "C:\"), "Expected C:\, got %s\n", path1); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* test empty path1 */ SetLastError(0xdeadbeef); @@ -1256,7 +1256,7 @@ static void test_PathCommonPrefixA(void) ok(!out[0], "Expected 0 length out, got %i\n", lstrlenA(out)); ok(!path1[0], "Expected 0 length path1, got %i\n", lstrlenA(path1)); ok(!lstrcmpA(path2, "C:\"), "Expected C:\, got %s\n", path2); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* test empty path1 */ SetLastError(0xdeadbeef); @@ -1268,7 +1268,7 @@ static void test_PathCommonPrefixA(void) ok(!out[0], "Expected 0 length out, got %i\n", lstrlenA(out)); ok(!path2[0], "Expected 0 length path2, got %i\n", lstrlenA(path2)); ok(!lstrcmpA(path1, "C:\"), "Expected C:\, got %s\n", path1); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* paths are legit, out is NULL */ SetLastError(0xdeadbeef); @@ -1278,7 +1278,7 @@ static void test_PathCommonPrefixA(void) ok(count == 3, "Expected 3, got %i\n", count); ok(!lstrcmpA(path1, "C:\"), "Expected C:\, got %s\n", path1); ok(!lstrcmpA(path2, "C:\"), "Expected C:\, got %s\n", path2); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* all parameters legit */ SetLastError(0xdeadbeef); @@ -1290,7 +1290,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(path1, "C:\"), "Expected C:\, got %s\n", path1); ok(!lstrcmpA(path2, "C:\"), "Expected C:\, got %s\n", path2); ok(!lstrcmpA(out, "C:\"), "Expected C:\, got %s\n", out); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* path1 and path2 not the same, but common prefix */ SetLastError(0xdeadbeef); @@ -1302,7 +1302,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(path1, "C:\one\two"), "Expected C:\one\two, got %s\n", path1); ok(!lstrcmpA(path2, "C:\one\three"), "Expected C:\one\three, got %s\n", path2); ok(!lstrcmpA(out, "C:\one"), "Expected C:\one, got %s\n", out); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try . prefix */ SetLastError(0xdeadbeef); @@ -1314,7 +1314,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(path1, "one\.two"), "Expected one\.two, got %s\n", path1); ok(!lstrcmpA(path2, "one\.three"), "Expected one\.three, got %s\n", path2); ok(!lstrcmpA(out, "one"), "Expected one, got %s\n", out); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try .. prefix */ SetLastError(0xdeadbeef); @@ -1326,7 +1326,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(path1, "one\..two"), "Expected one\..two, got %s\n", path1); ok(!lstrcmpA(path2, "one\..three"), "Expected one\..three, got %s\n", path2); ok(!lstrcmpA(out, "one"), "Expected one, got %s\n", out); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try ... prefix */ SetLastError(0xdeadbeef); @@ -1338,7 +1338,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(path1, "one\...two"), "Expected one\...two, got %s\n", path1); ok(!lstrcmpA(path2, "one\...three"), "Expected one\...three, got %s\n", path2); ok(!lstrcmpA(out, "one"), "Expected one, got %s\n", out); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try .\ prefix */ SetLastError(0xdeadbeef); @@ -1350,7 +1350,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(path1, "one\.\two"), "Expected one\.\two, got %s\n", path1); ok(!lstrcmpA(path2, "one\.\three"), "Expected one\.\three, got %s\n", path2); ok(!lstrcmpA(out, "one\."), "Expected one\., got %s\n", out); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try ..\ prefix */ SetLastError(0xdeadbeef); @@ -1362,7 +1362,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(path1, "one\..\two"), "Expected one\..\two, got %s\n", path1); ok(!lstrcmpA(path2, "one\..\three"), "Expected one\..\three, got %s\n", path2); ok(!lstrcmpA(out, "one\.."), "Expected one\.., got %s\n", out); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try ...\ prefix */ SetLastError(0xdeadbeef); @@ -1374,7 +1374,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(path1, "one\...\two"), "Expected one\...\two, got %s\n", path1); ok(!lstrcmpA(path2, "one\...\three"), "Expected one\...\three, got %s\n", path2); ok(!lstrcmpA(out, "one\..."), "Expected one\..., got %s\n", out); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try prefix that is not an msdn labeled prefix type */ SetLastError(0xdeadbeef); @@ -1386,7 +1386,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(path1, "same"), "Expected same, got %s\n", path1); ok(!lstrcmpA(path2, "same"), "Expected same, got %s\n", path2); ok(!lstrcmpA(out, "same"), "Expected same, got %s\n", out); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try . after directory */ SetLastError(0xdeadbeef); @@ -1398,7 +1398,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(path1, "one\mid.\two"), "Expected one\mid.\two, got %s\n", path1); ok(!lstrcmpA(path2, "one\mid.\three"), "Expected one\mid.\three, got %s\n", path2); ok(!lstrcmpA(out, "one\mid."), "Expected one\mid., got %s\n", out); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try . in the middle of a directory */ SetLastError(0xdeadbeef); @@ -1410,7 +1410,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(path1, "one\mid.end\two"), "Expected one\mid.end\two, got %s\n", path1); ok(!lstrcmpA(path2, "one\mid.end\three"), "Expected one\mid.end\three, got %s\n", path2); ok(!lstrcmpA(out, "one\mid.end"), "Expected one\mid.end, got %s\n", out); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError());
/* try comparing a .. with the expanded path */ SetLastError(0xdeadbeef); @@ -1422,7 +1422,7 @@ static void test_PathCommonPrefixA(void) ok(!lstrcmpA(path1, "one\..\two"), "Expected one\..\two, got %s\n", path1); ok(!lstrcmpA(path2, "two"), "Expected two, got %s\n", path2); ok(!out[0], "Expected 0 length out, got %i\n", lstrlenA(out)); - ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got %ld\n", GetLastError()); }
static void test_PathUnquoteSpaces(void) @@ -1464,7 +1464,7 @@ static void test_PathGetDriveNumber(void) SetLastError(0xdeadbeef); ret = PathGetDriveNumberA(NULL); ok(ret == -1, "got %d\n", ret); - ok(GetLastError() == 0xdeadbeef, "got %d\n", GetLastError()); + ok(GetLastError() == 0xdeadbeef, "got %ld\n", GetLastError());
ret = PathGetDriveNumberA(test1A); ok(ret == 0, "got %d\n", ret); @@ -1507,20 +1507,20 @@ static void test_PathUnExpandEnvStrings(void) ok(ret, "got %d\n", ret); SetLastError(0xdeadbeef); ret = pPathUnExpandEnvStringsA(envvarA, buff, sizeof(buff)); - ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError()); + ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %ld\n", ret, GetLastError());
ret = GetEnvironmentVariableW(computernameW, envvarW, ARRAY_SIZE(envvarW)); ok(ret, "got %d\n", ret); SetLastError(0xdeadbeef); ret = pPathUnExpandEnvStringsW(envvarW, buffW, ARRAY_SIZE(buffW)); - ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError()); + ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %ld\n", ret, GetLastError());
/* something that can't be represented with env var */ strcpy(path, "somepath_name"); strcpy(buff, "xx"); SetLastError(0xdeadbeef); ret = pPathUnExpandEnvStringsA(path, buff, sizeof(buff)); - ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError()); + ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %ld\n", ret, GetLastError()); ok(buff[0] == 'x', "wrong return string %s\n", buff);
len = GetSystemDirectoryA(path, MAX_PATH); @@ -1540,7 +1540,7 @@ static void test_PathUnExpandEnvStrings(void) strcpy(buff, "xx"); SetLastError(0xdeadbeef); ret = pPathUnExpandEnvStringsA(path, buff, sizeof(sysrootA)); - ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError()); + ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %ld\n", ret, GetLastError()); ok(buff[0] == 'x', "wrong return string %s\n", buff);
/* enough size */ @@ -1573,7 +1573,7 @@ static void test_PathUnExpandEnvStrings(void) strcat(path, sysdrvA); SetLastError(0xdeadbeef); ret = pPathUnExpandEnvStringsA(path, buff, sizeof(buff)); - ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError()); + ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %ld\n", ret, GetLastError());
ret = SetEnvironmentVariableA("SystemDrive", envvarA); ok(ret, "got %d\n", ret); @@ -1585,7 +1585,7 @@ static void test_PathUnExpandEnvStrings(void) buffW[0] = 'x'; buffW[1] = 0; SetLastError(0xdeadbeef); ret = pPathUnExpandEnvStringsW(pathW, buffW, ARRAY_SIZE(buffW)); - ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError()); + ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %ld\n", ret, GetLastError()); ok(buffW[0] == 'x', "wrong return string %s\n", wine_dbgstr_w(buffW));
len = GetSystemDirectoryW(pathW, MAX_PATH); @@ -1599,14 +1599,14 @@ static void test_PathUnExpandEnvStrings(void) buffW[0] = 'x'; buffW[1] = 0; SetLastError(0xdeadbeef); ret = pPathUnExpandEnvStringsW(pathW, buffW, 5); - ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError()); + ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %ld\n", ret, GetLastError()); ok(buffW[0] == 'x', "wrong return string %s\n", wine_dbgstr_w(buffW));
/* buffer size is enough to hold variable name only */ buffW[0] = 'x'; buffW[1] = 0; SetLastError(0xdeadbeef); ret = pPathUnExpandEnvStringsW(pathW, buffW, ARRAY_SIZE(sysrootW)); - ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %d\n", ret, GetLastError()); + ok(!ret && GetLastError() == 0xdeadbeef, "got %d, error %ld\n", ret, GetLastError()); ok(buffW[0] == 'x', "wrong return string %s\n", wine_dbgstr_w(buffW));
/* enough size */ diff --git a/dlls/shlwapi/tests/shreg.c b/dlls/shlwapi/tests/shreg.c index ca7fbad289e..3ce0551db39 100644 --- a/dlls/shlwapi/tests/shreg.c +++ b/dlls/shlwapi/tests/shreg.c @@ -83,7 +83,7 @@ static HKEY create_test_entries(void) SetEnvironmentVariableA("FOO", sEnvvar2);
ret = RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_KEY, &hKey); - ok( ERROR_SUCCESS == ret, "RegCreateKeyA failed, ret=%u\n", ret); + ok( ERROR_SUCCESS == ret, "RegCreateKeyA failed, ret=%lu\n", ret);
if (hKey) { @@ -98,13 +98,13 @@ static HKEY create_test_entries(void) nExpectedLen1 = strlen(sTestpath1) - strlen("%LONGSYSTEMVAR%") + strlen(sEnvvar1) + 1; nExpectedLen2 = strlen(sTestpath2) - strlen("%FOO%") + strlen(sEnvvar2) + 1; /* ExpandEnvironmentStringsA on NT4 returns 2x the correct result */ - trace("sExplen1 = (%d)\n", nExpLen1); + trace("sExplen1 = (%ld)\n", nExpLen1); if (nExpectedLen1 != nExpLen1) - trace( "Expanding %s failed (expected %d) - known bug in NT4\n", sTestpath1, nExpectedLen1 ); + trace( "Expanding %s failed (expected %ld) - known bug in NT4\n", sTestpath1, nExpectedLen1 );
- trace("sExplen2 = (%d)\n", nExpLen2); + trace("sExplen2 = (%ld)\n", nExpLen2); if (nExpectedLen2 != nExpLen2) - trace( "Expanding %s failed (expected %d) - known bug in NT4\n", sTestpath2, nExpectedLen2 ); + trace( "Expanding %s failed (expected %ld) - known bug in NT4\n", sTestpath2, nExpectedLen2 );
/* Make sure we carry on with correct values */ nExpLen1 = nExpectedLen1; @@ -123,21 +123,21 @@ static void test_SHGetValue(void) dwSize = MAX_PATH; dwType = -1; dwRet = SHGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test1", &dwType, buf, &dwSize); - ok( ERROR_SUCCESS == dwRet, "SHGetValueA failed, ret=%u\n", dwRet); + ok( ERROR_SUCCESS == dwRet, "SHGetValueA failed, ret=%lu\n", dwRet); ok( 0 == strcmp(sExpTestpath1, buf) || broken(0 == strcmp(sTestpath1, buf)), /* IE4.x */ "Comparing of (%s) with (%s) failed\n", buf, sExpTestpath1); ok( REG_SZ == dwType || broken(REG_EXPAND_SZ == dwType), /* IE4.x */ - "Expected REG_SZ, got (%u)\n", dwType); + "Expected REG_SZ, got (%lu)\n", dwType);
strcpy(buf, sEmptyBuffer); dwSize = MAX_PATH; dwType = -1; dwRet = SHGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test2", &dwType, buf, &dwSize); - ok( ERROR_SUCCESS == dwRet, "SHGetValueA failed, ret=%u\n", dwRet); + ok( ERROR_SUCCESS == dwRet, "SHGetValueA failed, ret=%lu\n", dwRet); ok( 0 == strcmp(sTestpath1, buf) , "Comparing of (%s) with (%s) failed\n", buf, sTestpath1); - ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType); + ok( REG_SZ == dwType , "Expected REG_SZ, got (%lu)\n", dwType); }
static void test_SHRegGetValue(void) @@ -151,31 +151,31 @@ static void test_SHRegGetValue(void)
size = MAX_PATH; ret = pSHRegGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test1", SRRF_RT_REG_EXPAND_SZ, &type, data, &size); - ok(ret == ERROR_INVALID_PARAMETER, "SHRegGetValue failed, ret=%u\n", ret); + ok(ret == ERROR_INVALID_PARAMETER, "SHRegGetValue failed, ret=%lu\n", ret);
size = MAX_PATH; ret = pSHRegGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test1", SRRF_RT_REG_SZ, &type, data, &size); - ok(ret == ERROR_SUCCESS, "SHRegGetValue failed, ret=%u\n", ret); + ok(ret == ERROR_SUCCESS, "SHRegGetValue failed, ret=%lu\n", ret); ok(!strcmp(data, sExpTestpath1), "data = %s, expected %s\n", data, sExpTestpath1); - ok(type == REG_SZ, "type = %d, expected REG_SZ\n", type); + ok(type == REG_SZ, "type = %ld, expected REG_SZ\n", type);
size = MAX_PATH; ret = pSHRegGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test1", SRRF_RT_REG_DWORD, &type, data, &size); - ok(ret == ERROR_UNSUPPORTED_TYPE, "SHRegGetValue failed, ret=%u\n", ret); + ok(ret == ERROR_UNSUPPORTED_TYPE, "SHRegGetValue failed, ret=%lu\n", ret);
size = MAX_PATH; ret = pSHRegGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test2", SRRF_RT_REG_EXPAND_SZ, &type, data, &size); - ok(ret == ERROR_INVALID_PARAMETER, "SHRegGetValue failed, ret=%u\n", ret); + ok(ret == ERROR_INVALID_PARAMETER, "SHRegGetValue failed, ret=%lu\n", ret);
size = MAX_PATH; ret = pSHRegGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test2", SRRF_RT_REG_SZ, &type, data, &size); - ok(ret == ERROR_SUCCESS, "SHRegGetValue failed, ret=%u\n", ret); + ok(ret == ERROR_SUCCESS, "SHRegGetValue failed, ret=%lu\n", ret); ok(!strcmp(data, sTestpath1), "data = %s, expected %s\n", data, sTestpath1); - ok(type == REG_SZ, "type = %d, expected REG_SZ\n", type); + ok(type == REG_SZ, "type = %ld, expected REG_SZ\n", type);
size = MAX_PATH; ret = pSHRegGetValueA(HKEY_CURRENT_USER, REG_TEST_KEY, "Test2", SRRF_RT_REG_QWORD, &type, data, &size); - ok(ret == ERROR_UNSUPPORTED_TYPE, "SHRegGetValue failed, ret=%u\n", ret); + ok(ret == ERROR_UNSUPPORTED_TYPE, "SHRegGetValue failed, ret=%lu\n", ret); }
static void test_SHGetRegPath(void) @@ -188,7 +188,7 @@ static void test_SHGetRegPath(void)
strcpy(buf, sEmptyBuffer); dwRet = (*pSHRegGetPathA)(HKEY_CURRENT_USER, REG_TEST_KEY, "Test1", buf, 0); - ok( ERROR_SUCCESS == dwRet, "SHRegGetPathA failed, ret=%u\n", dwRet); + ok( ERROR_SUCCESS == dwRet, "SHRegGetPathA failed, ret=%lu\n", dwRet); ok( 0 == strcmp(sExpTestpath1, buf) , "Comparing (%s) with (%s) failed\n", buf, sExpTestpath1); }
@@ -204,7 +204,7 @@ static void test_SHQueryValueEx(void)
sTestedFunction = "RegOpenKeyExA"; dwRet = RegOpenKeyExA(HKEY_CURRENT_USER, REG_TEST_KEY, 0, KEY_QUERY_VALUE, &hKey); - ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet); + ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%lu\n", sTestedFunction, dwRet);
/****** SHQueryValueExA ******/
@@ -215,15 +215,15 @@ static void test_SHQueryValueEx(void) * Case 1.1 All arguments are NULL */ dwRet = SHQueryValueExA( hKey, "Test1", NULL, NULL, NULL, NULL); - ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet); + ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%lu\n", sTestedFunction, dwRet);
/* * Case 1.2 dwType is set */ dwType = -1; dwRet = SHQueryValueExA( hKey, "Test1", NULL, &dwType, NULL, NULL); - ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet); - ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType); + ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%lu\n", sTestedFunction, dwRet); + ok( REG_SZ == dwType , "Expected REG_SZ, got (%lu)\n", dwType);
/* * dwSize is set @@ -231,18 +231,18 @@ static void test_SHQueryValueEx(void) */ dwSize = 6; dwRet = SHQueryValueExA( hKey, "Test1", NULL, NULL, NULL, &dwSize); - ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet); - ok( dwSize == nUsedBuffer1, "Buffer sizes (%u) and (%u) are not equal\n", dwSize, nUsedBuffer1); + ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%lu\n", sTestedFunction, dwRet); + ok( dwSize == nUsedBuffer1, "Buffer sizes (%lu) and (%lu) are not equal\n", dwSize, nUsedBuffer1);
/* * dwExpanded > dwUnExpanded */ dwSize = 6; dwRet = SHQueryValueExA( hKey, "Test3", NULL, NULL, NULL, &dwSize); - ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet); + ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%lu\n", sTestedFunction, dwRet); ok( dwSize >= nUsedBuffer2 || broken(dwSize == (strlen(sTestpath2) + 1)), /* < IE4.x */ - "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2); + "Buffer size (%lu) should be >= (%lu)\n", dwSize, nUsedBuffer2);
/* * Case 1 string shrinks during expanding @@ -251,12 +251,12 @@ static void test_SHQueryValueEx(void) dwSize = 6; dwType = -1; dwRet = SHQueryValueExA( hKey, "Test1", NULL, &dwType, buf, &dwSize); - ok( ERROR_MORE_DATA == dwRet, "Expected ERROR_MORE_DATA, got (%u)\n", dwRet); + ok( ERROR_MORE_DATA == dwRet, "Expected ERROR_MORE_DATA, got (%lu)\n", dwRet); ok( 0 == strcmp(sEmptyBuffer, buf) , "Comparing (%s) with (%s) failed\n", buf, sEmptyBuffer); - ok( dwSize == nUsedBuffer1, "Buffer sizes (%u) and (%u) are not equal\n", dwSize, nUsedBuffer1); + ok( dwSize == nUsedBuffer1, "Buffer sizes (%lu) and (%lu) are not equal\n", dwSize, nUsedBuffer1); ok( REG_SZ == dwType || broken(REG_EXPAND_SZ == dwType), /* < IE6 */ - "Expected REG_SZ, got (%u)\n", dwType); + "Expected REG_SZ, got (%lu)\n", dwType);
/* * string grows during expanding @@ -266,14 +266,14 @@ static void test_SHQueryValueEx(void) dwSize = 6; dwType = -1; dwRet = SHQueryValueExA( hKey, "Test3", NULL, &dwType, buf, &dwSize); - ok( ERROR_MORE_DATA == dwRet, "Expected ERROR_MORE_DATA, got (%u)\n", dwRet); + ok( ERROR_MORE_DATA == dwRet, "Expected ERROR_MORE_DATA, got (%lu)\n", dwRet); ok( 0 == strcmp(sEmptyBuffer, buf) , "Comparing (%s) with (%s) failed\n", buf, sEmptyBuffer); ok( dwSize >= nUsedBuffer2 || broken(dwSize == (strlen(sTestpath2) + 1)), /* < IE6 */ - "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2); + "Buffer size (%lu) should be >= (%lu)\n", dwSize, nUsedBuffer2); ok( REG_SZ == dwType || broken(REG_EXPAND_SZ == dwType), /* < IE6 */ - "Expected REG_SZ, got (%u)\n", dwType); + "Expected REG_SZ, got (%lu)\n", dwType);
/* * string grows during expanding @@ -288,7 +288,7 @@ static void test_SHQueryValueEx(void) ok( ERROR_MORE_DATA == dwRet || broken(ERROR_ENVVAR_NOT_FOUND == dwRet) || /* IE5.5 */ broken(ERROR_SUCCESS == dwRet), /* < IE5.5*/ - "Expected ERROR_MORE_DATA, got (%u)\n", dwRet); + "Expected ERROR_MORE_DATA, got (%lu)\n", dwRet);
todo_wine { @@ -298,8 +298,8 @@ static void test_SHQueryValueEx(void)
ok( dwSize >= nUsedBuffer2 || broken(dwSize == (strlen("") + 1)), /* < IE 5.5 */ - "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2); - ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType); + "Buffer size (%lu) should be >= (%lu)\n", dwSize, nUsedBuffer2); + ok( REG_SZ == dwType , "Expected REG_SZ, got (%lu)\n", dwType);
/* * string grows during expanding @@ -314,7 +314,7 @@ static void test_SHQueryValueEx(void) ok( ERROR_MORE_DATA == dwRet || broken(ERROR_ENVVAR_NOT_FOUND == dwRet) || /* IE5.5 */ broken(ERROR_SUCCESS == dwRet), /* < IE5.5 */ - "Expected ERROR_MORE_DATA, got (%u)\n", dwRet); + "Expected ERROR_MORE_DATA, got (%lu)\n", dwRet);
todo_wine { @@ -326,8 +326,8 @@ static void test_SHQueryValueEx(void) ok( dwSize >= nUsedBuffer2 || broken(dwSize == (strlen(sEnvvar2) + 1)) || /* IE4.01 SP1 (W98) and IE5 (W98SE) */ broken(dwSize == (strlen("") + 1)), /* IE4.01 (NT4) and IE5.x (W2K) */ - "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2); - ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType); + "Buffer size (%lu) should be >= (%lu)\n", dwSize, nUsedBuffer2); + ok( REG_SZ == dwType , "Expected REG_SZ, got (%lu)\n", dwType);
/* * The buffer is NULL but the size is set @@ -336,11 +336,11 @@ static void test_SHQueryValueEx(void) dwSize = 6; dwType = -1; dwRet = SHQueryValueExA( hKey, "Test3", NULL, &dwType, NULL, &dwSize); - ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%u\n", sTestedFunction, dwRet); + ok( ERROR_SUCCESS == dwRet, "%s failed, ret=%lu\n", sTestedFunction, dwRet); ok( dwSize >= nUsedBuffer2 || broken(dwSize == (strlen(sTestpath2) + 1)), /* IE4.01 SP1 (Win98) */ - "Buffer size (%u) should be >= (%u)\n", dwSize, nUsedBuffer2); - ok( REG_SZ == dwType , "Expected REG_SZ, got (%u)\n", dwType); + "Buffer size (%lu) should be >= (%lu)\n", dwSize, nUsedBuffer2); + ok( REG_SZ == dwType , "Expected REG_SZ, got (%lu)\n", dwType);
RegCloseKey(hKey); } @@ -368,7 +368,7 @@ static void test_SHCopyKey(void) dwRet = RegCreateKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\CopyDestination", &hKeyDst); if (dwRet || !hKeyDst) { - ok( 0, "Destination couldn't be created, RegCreateKeyA returned (%u)\n", dwRet); + ok( 0, "Destination couldn't be created, RegCreateKeyA returned (%lu)\n", dwRet); return; }
@@ -376,13 +376,13 @@ static void test_SHCopyKey(void) dwRet = RegOpenKeyA(HKEY_LOCAL_MACHINE, REG_CURRENT_VERSION, &hKeySrc); if (dwRet || !hKeySrc) { - ok( 0, "Source couldn't be opened, RegOpenKeyA returned (%u)\n", dwRet); + ok( 0, "Source couldn't be opened, RegOpenKeyA returned (%lu)\n", dwRet); RegCloseKey(hKeyDst); return; }
dwRet = (*pSHCopyKeyA)(hKeySrc, NULL, hKeyDst, 0); - ok ( ERROR_SUCCESS == dwRet, "Copy failed, ret=(%u)\n", dwRet); + ok ( ERROR_SUCCESS == dwRet, "Copy failed, ret=(%lu)\n", dwRet);
RegCloseKey(hKeySrc); RegCloseKey(hKeyDst); @@ -392,7 +392,7 @@ static void test_SHCopyKey(void) dwRet = RegOpenKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\CopyDestination\Shell Folders", &hKeyDst); if (dwRet || !hKeyDst) { - ok ( 0, "Copy couldn't be opened, RegOpenKeyA returned (%u)\n", dwRet); + ok ( 0, "Copy couldn't be opened, RegOpenKeyA returned (%lu)\n", dwRet); return; }
@@ -433,7 +433,7 @@ static void test_SHDeleteKey(void) {
dwRet = SHDeleteKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\ODBC"); - ok ( ERROR_SUCCESS == dwRet, "SHDeleteKey failed, ret=(%u)\n", dwRet); + ok ( ERROR_SUCCESS == dwRet, "SHDeleteKey failed, ret=(%lu)\n", dwRet);
dwRet = RegOpenKeyA(HKEY_CURRENT_USER, REG_TEST_KEY "\ODBC", &hKeyS); ok ( ERROR_FILE_NOT_FOUND == dwRet, "SHDeleteKey did not delete\n"); @@ -457,7 +457,7 @@ static void test_SHRegCreateUSKeyW(void) }
ret = pSHRegCreateUSKeyW(subkeyW, KEY_ALL_ACCESS, NULL, NULL, SHREGSET_FORCE_HKCU); - ok(ret == ERROR_INVALID_PARAMETER, "got %d\n", ret); + ok(ret == ERROR_INVALID_PARAMETER, "got %ld\n", ret); }
static void test_SHRegCloseUSKey(void) @@ -473,20 +473,20 @@ static void test_SHRegCloseUSKey(void) }
ret = pSHRegCloseUSKey(NULL); - ok(ret == ERROR_INVALID_PARAMETER, "got %d\n", ret); + ok(ret == ERROR_INVALID_PARAMETER, "got %ld\n", ret);
ret = pSHRegOpenUSKeyW(localW, KEY_ALL_ACCESS, NULL, &key, FALSE); - ok(ret == ERROR_SUCCESS, "got %d\n", ret); + ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
ret = pSHRegCloseUSKey(key); - ok(ret == ERROR_SUCCESS, "got %d\n", ret); + ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
/* Test with limited rights, specially without KEY_SET_VALUE */ ret = pSHRegOpenUSKeyW(localW, KEY_QUERY_VALUE, NULL, &key, FALSE); - ok(ret == ERROR_SUCCESS, "got %d\n", ret); + ok(ret == ERROR_SUCCESS, "got %ld\n", ret);
ret = pSHRegCloseUSKey(key); - ok(ret == ERROR_SUCCESS, "got %d\n", ret); + ok(ret == ERROR_SUCCESS, "got %ld\n", ret); }
START_TEST(shreg) diff --git a/dlls/shlwapi/tests/string.c b/dlls/shlwapi/tests/string.c index 77c108e38bf..d988e26acb4 100644 --- a/dlls/shlwapi/tests/string.c +++ b/dlls/shlwapi/tests/string.c @@ -772,7 +772,7 @@ static void test_StrFromTimeIntervalA(void) { StrFromTimeIntervalA(szBuff, 256, result->ms, result->digits);
- ok(!strcmp(result->time_interval, szBuff), "Formatted %d %d wrong: %s\n", + ok(!strcmp(result->time_interval, szBuff), "Formatted %ld %d wrong: %s\n", result->ms, result->digits, szBuff); result++; } @@ -867,14 +867,14 @@ static void test_StrRetToBSTR(void) bstr = 0; ret = pStrRetToBSTR(&strret, NULL, &bstr); ok(ret == S_OK && bstr && !wcscmp(bstr, szTestW), - "STRRET_WSTR: dup failed, ret=0x%08x, bstr %p\n", ret, bstr); + "STRRET_WSTR: dup failed, ret=0x%08lx, bstr %p\n", ret, bstr); SysFreeString(bstr);
strret.uType = STRRET_CSTR; lstrcpyA(U(strret).cStr, "Test"); ret = pStrRetToBSTR(&strret, NULL, &bstr); ok(ret == S_OK && bstr && !wcscmp(bstr, szTestW), - "STRRET_CSTR: dup failed, ret=0x%08x, bstr %p\n", ret, bstr); + "STRRET_CSTR: dup failed, ret=0x%08lx, bstr %p\n", ret, bstr); SysFreeString(bstr);
strret.uType = STRRET_OFFSET; @@ -882,7 +882,7 @@ static void test_StrRetToBSTR(void) strcpy((char*)&iidl, " Test"); ret = pStrRetToBSTR(&strret, iidl, &bstr); ok(ret == S_OK && bstr && !wcscmp(bstr, szTestW), - "STRRET_OFFSET: dup failed, ret=0x%08x, bstr %p\n", ret, bstr); + "STRRET_OFFSET: dup failed, ret=0x%08lx, bstr %p\n", ret, bstr); SysFreeString(bstr);
/* Native crashes if str is NULL */ @@ -987,7 +987,7 @@ static void test_SHAnsiToAnsi(void) memset(dest, '\n', sizeof(dest)); dwRet = pSHAnsiToAnsi("hello", dest, ARRAY_SIZE(dest)); ok(dwRet == 6 && !memcmp(dest, "hello\0\n\n", sizeof(dest)), - "SHAnsiToAnsi: expected 6, "hello\0\n\n", got %d, "%d,%d,%d,%d,%d,%d,%d,%d"\n", + "SHAnsiToAnsi: expected 6, "hello\0\n\n", got %ld, "%d,%d,%d,%d,%d,%d,%d,%d"\n", dwRet, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]); }
@@ -1014,7 +1014,7 @@ static void test_SHUnicodeToUnicode(void) memcpy(dest, lpInit, sizeof(lpInit)); dwRet = pSHUnicodeToUnicode(lpSrc, dest, ARRAY_SIZE(dest)); ok(dwRet == 6 && !memcmp(dest, lpRes, sizeof(dest)), - "SHUnicodeToUnicode: expected 6, "hello\0\n\n", got %d, "%d,%d,%d,%d,%d,%d,%d,%d"\n", + "SHUnicodeToUnicode: expected 6, "hello\0\n\n", got %ld, "%d,%d,%d,%d,%d,%d,%d,%d"\n", dwRet, dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]); }
@@ -1098,7 +1098,7 @@ if (0) U(strret).pOleStr = StrDupW(wstr1); hres = pStrRetToBufW(&strret, NULL, wbuf, 10); ok(hres == E_NOT_SUFFICIENT_BUFFER || broken(hres == S_OK) /* winxp */, - "StrRetToBufW returned %08x\n", hres); + "StrRetToBufW returned %08lx\n", hres); if (hres == E_NOT_SUFFICIENT_BUFFER) expect_eq(wbuf[0], 0, WCHAR, "%x"); expect_eq(wbuf[9], 0, WCHAR, "%x"); @@ -1108,14 +1108,14 @@ if (0) strret.uType = STRRET_CSTR; StrCpyNA(U(strret).cStr, str1, MAX_PATH); hres = pStrRetToBufW(&strret, NULL, wbuf, 10); - ok(hres == S_OK, "StrRetToBufW returned %08x\n", hres); + ok(hres == S_OK, "StrRetToBufW returned %08lx\n", hres); ok(!memcmp(wbuf, wstr1, 9*sizeof(WCHAR)) && !wbuf[9], "StrRetToBuf returned %s\n", wine_dbgstr_w(wbuf));
memset(wbuf, 0xbf, sizeof(wbuf)); strret.uType = STRRET_WSTR; U(strret).pOleStr = NULL; hres = pStrRetToBufW(&strret, NULL, wbuf, 10); - ok(hres == E_FAIL, "StrRetToBufW returned %08x\n", hres); + ok(hres == E_FAIL, "StrRetToBufW returned %08lx\n", hres); ok(!wbuf[0], "StrRetToBuf returned %s\n", wine_dbgstr_w(wbuf)); } else @@ -1126,7 +1126,7 @@ if (0) memset(buf, 0xbf, sizeof(buf)); strret.uType = STRRET_CSTR; StrCpyNA(U(strret).cStr, str1, MAX_PATH); - expect_eq2(pStrRetToBufA(&strret, NULL, buf, 10), S_OK, E_NOT_SUFFICIENT_BUFFER /* Vista */, HRESULT, "%x"); + expect_eq2(pStrRetToBufA(&strret, NULL, buf, 10), S_OK, E_NOT_SUFFICIENT_BUFFER /* Vista */, HRESULT, "%lx"); expect_eq(buf[9], 0, CHAR, "%x"); expect_eq(buf[10], (CHAR)0xbf, CHAR, "%x"); } @@ -1554,43 +1554,43 @@ static void test_StrCatChainW(void)
/* Test with NULL buffer */ ret = pStrCatChainW(NULL, 0, 0, beefW); - ok(ret == 0, "Expected StrCatChainW to return 0, got %u\n", ret); + ok(ret == 0, "Expected StrCatChainW to return 0, got %lu\n", ret);
/* Test with empty buffer */ memset(buf, 0x11, sizeof(buf)); ret = pStrCatChainW(buf, 0, 0, beefW); - ok(ret == 0, "Expected StrCatChainW to return 0, got %u\n", ret); + ok(ret == 0, "Expected StrCatChainW to return 0, got %lu\n", ret); ok(buf[0] == 0x1111, "Expected buf[0] = 0x1111, got %x\n", buf[0]);
memcpy(buf, deadbeefW, sizeof(deadbeefW)); ret = pStrCatChainW(buf, 0, -1, beefW); - ok(ret == 8, "Expected StrCatChainW to return 8, got %u\n", ret); + ok(ret == 8, "Expected StrCatChainW to return 8, got %lu\n", ret); ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n");
/* Append data to existing string with offset = -1 */ memset(buf, 0x11, sizeof(buf)); ret = pStrCatChainW(buf, 32, 0, deadW); - ok(ret == 4, "Expected StrCatChainW to return 4, got %u\n", ret); + ok(ret == 4, "Expected StrCatChainW to return 4, got %lu\n", ret); ok(!memcmp(buf, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
ret = pStrCatChainW(buf, 32, -1, beefW); - ok(ret == 8, "Expected StrCatChainW to return 8, got %u\n", ret); + ok(ret == 8, "Expected StrCatChainW to return 8, got %lu\n", ret); ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n");
/* Append data at a fixed offset */ memset(buf, 0x11, sizeof(buf)); ret = pStrCatChainW(buf, 32, 0, deadW); - ok(ret == 4, "Expected StrCatChainW to return 4, got %u\n", ret); + ok(ret == 4, "Expected StrCatChainW to return 4, got %lu\n", ret); ok(!memcmp(buf, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
ret = pStrCatChainW(buf, 32, 4, beefW); - ok(ret == 8, "Expected StrCatChainW to return 8, got %u\n", ret); + ok(ret == 8, "Expected StrCatChainW to return 8, got %lu\n", ret); ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n");
/* Buffer exactly sufficient for string + terminating null */ memset(buf, 0x11, sizeof(buf)); ret = pStrCatChainW(buf, 5, 0, deadW); - ok(ret == 4, "Expected StrCatChainW to return 4, got %u\n", ret); + ok(ret == 4, "Expected StrCatChainW to return 4, got %lu\n", ret); ok(!memcmp(buf, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
/* Buffer too small, string will be truncated */ @@ -1604,14 +1604,14 @@ static void test_StrCatChainW(void) win_skip("Windows2000/XP behaviour detected for StrCatChainW, skipping tests\n"); return; } - ok(ret == 3, "Expected StrCatChainW to return 3, got %u\n", ret); + ok(ret == 3, "Expected StrCatChainW to return 3, got %lu\n", ret); ok(!memcmp(buf, deadW, 3 * sizeof(WCHAR)), "Buffer contains wrong data\n"); ok(!buf[3], "String is not nullterminated\n"); ok(buf[4] == 0x1111, "Expected buf[4] = 0x1111, got %x\n", buf[4]);
/* Overwrite part of an existing string */ ret = pStrCatChainW(buf, 4, 1, beefW); - ok(ret == 3, "Expected StrCatChainW to return 3, got %u\n", ret); + ok(ret == 3, "Expected StrCatChainW to return 3, got %lu\n", ret); ok(buf[0] == 'D', "Expected buf[0] = 'D', got %x\n", buf[0]); ok(buf[1] == 'B', "Expected buf[1] = 'B', got %x\n", buf[1]); ok(buf[2] == 'e', "Expected buf[2] = 'e', got %x\n", buf[2]); @@ -1623,35 +1623,35 @@ static void test_StrCatChainW(void) memcpy(buf, deadbeefW, sizeof(deadbeefW)); memcpy(buf + 9, deadW, sizeof(deadW)); ret = pStrCatChainW(buf, 9, 8, beefW); - ok(ret == 8, "Expected StrCatChainW to return 8, got %u\n", ret); + ok(ret == 8, "Expected StrCatChainW to return 8, got %lu\n", ret); ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n"); ok(!memcmp(buf + 9, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
/* Offset points at the end of the buffer */ ret = pStrCatChainW(buf, 9, 9, beefW); - ok(ret == 8, "Expected StrCatChainW to return 8, got %u\n", ret); + ok(ret == 8, "Expected StrCatChainW to return 8, got %lu\n", ret); ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n"); ok(!memcmp(buf + 9, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
/* Offset points outside of the buffer */ ret = pStrCatChainW(buf, 9, 10, beefW); - ok(ret == 10, "Expected StrCatChainW to return 10, got %u\n", ret); + ok(ret == 10, "Expected StrCatChainW to return 10, got %lu\n", ret); ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n"); ok(!memcmp(buf + 9, deadW, sizeof(deadW)), "Buffer contains wrong data\n");
/* The same but without nullterminated string */ memcpy(buf, deadbeefW, sizeof(deadbeefW)); ret = pStrCatChainW(buf, 5, -1, deadW); - ok(ret == 8, "Expected StrCatChainW to return 8, got %u\n", ret); + ok(ret == 8, "Expected StrCatChainW to return 8, got %lu\n", ret); ok(!memcmp(buf, deadbeefW, sizeof(deadbeefW)), "Buffer contains wrong data\n");
ret = pStrCatChainW(buf, 5, 5, deadW); - ok(ret == 4, "Expected StrCatChainW to return 4, got %u\n", ret); + ok(ret == 4, "Expected StrCatChainW to return 4, got %lu\n", ret); ok(!memcmp(buf, deadW, sizeof(deadW)), "Buffer contains wrong data\n"); ok(buf[5] == 'e', "Expected buf[5] = 'e', got %x\n", buf[5]);
ret = pStrCatChainW(buf, 5, 6, deadW); - ok(ret == 6, "Expected StrCatChainW to return 6, got %u\n", ret); + ok(ret == 6, "Expected StrCatChainW to return 6, got %lu\n", ret); ok(!memcmp(buf, deadW, sizeof(deadW)), "Buffer contains wrong data\n"); ok(buf[5] == 'e', "Expected buf[5] = 'e', got %x\n", buf[5]); } diff --git a/dlls/shlwapi/tests/thread.c b/dlls/shlwapi/tests/thread.c index 34eb98ca607..65a13a3ef49 100644 --- a/dlls/shlwapi/tests/thread.c +++ b/dlls/shlwapi/tests/thread.c @@ -104,44 +104,44 @@ static void test_SHCreateThreadRef(void)
/* start with a clean state */ hr = pSHSetThreadRef(NULL); - ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr); + ok(hr == S_OK, "got 0x%lx (expected S_OK)\n", hr);
pobj = NULL; refcount = 0xdeadbeef; hr = pSHCreateThreadRef(&refcount, &pobj); ok((hr == S_OK) && pobj && (refcount == 1), - "got 0x%x and %p with %d (expected S_OK and '!= NULL' with 1)\n", + "got 0x%lx and %p with %ld (expected S_OK and '!= NULL' with 1)\n", hr, pobj, refcount);
/* the object is not automatic set as ThreadRef */ punk = NULL; hr = pSHGetThreadRef(&punk); ok( (hr == E_NOINTERFACE) && (punk == NULL), - "got 0x%x and %p (expected E_NOINTERFACE and NULL)\n", hr, punk); + "got 0x%lx and %p (expected E_NOINTERFACE and NULL)\n", hr, punk);
/* set the object */ hr = pSHSetThreadRef(pobj); - ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr); + ok(hr == S_OK, "got 0x%lx (expected S_OK)\n", hr);
/* read back */ punk = NULL; hr = pSHGetThreadRef(&punk); ok( (hr == S_OK) && (punk == pobj) && (refcount == 2), - "got 0x%x and %p with %d (expected S_OK and %p with 2)\n", + "got 0x%lx and %p with %ld (expected S_OK and %p with 2)\n", hr, punk, refcount, pobj);
/* free the ref from SHGetThreadRef */ if (SUCCEEDED(hr)) { hr = IUnknown_Release(pobj); ok((hr == 1) && (hr == refcount), - "got %d with %d (expected 1 with 1)\n", hr, refcount); + "got %ld with %ld (expected 1 with 1)\n", hr, refcount); }
/* free the object */ if (pobj) { hr = IUnknown_Release(pobj); ok((hr == 0) && (hr == refcount), - "got %d with %d (expected 0 with 0)\n", hr, refcount); + "got %ld with %ld (expected 0 with 0)\n", hr, refcount); }
if (0) { @@ -149,25 +149,25 @@ static void test_SHCreateThreadRef(void) but the object no longer exist after the *_Release */ punk = NULL; hr = pSHGetThreadRef(&punk); - trace("got 0x%x and %p with %d\n", hr, punk, refcount); + trace("got 0x%lx and %p with %ld\n", hr, punk, refcount); }
/* remove the dead object pointer */ hr = pSHSetThreadRef(NULL); - ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr); + ok(hr == S_OK, "got 0x%lx (expected S_OK)\n", hr);
/* parameter check */ if (0) { /* vista: E_INVALIDARG, XP: crash */ pobj = NULL; hr = pSHCreateThreadRef(NULL, &pobj); - ok(hr == E_INVALIDARG, "got 0x%x (expected E_INVALIDARG)\n", hr); + ok(hr == E_INVALIDARG, "got 0x%lx (expected E_INVALIDARG)\n", hr);
refcount = 0xdeadbeef; /* vista: E_INVALIDARG, XP: crash */ hr = pSHCreateThreadRef(&refcount, NULL); ok( (hr == E_INVALIDARG) && (refcount == 0xdeadbeef), - "got 0x%x with 0x%x (expected E_INVALIDARG and oxdeadbeef)\n", + "got 0x%lx with 0x%lx (expected E_INVALIDARG and oxdeadbeef)\n", hr, refcount); } } @@ -187,7 +187,7 @@ static void test_SHGetThreadRef(void) punk = NULL; hr = pSHGetThreadRef(&punk); ok( (hr == E_NOINTERFACE) && (punk == NULL), - "got 0x%x and %p (expected E_NOINTERFACE and NULL)\n", hr, punk); + "got 0x%lx and %p (expected E_NOINTERFACE and NULL)\n", hr, punk);
if (0) { /* this crash on Windows */ @@ -210,7 +210,7 @@ static void test_SHSetThreadRef(void)
/* start with a clean state */ hr = pSHSetThreadRef(NULL); - ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr); + ok(hr == S_OK, "got 0x%lx (expected S_OK)\n", hr);
/* build and set out object */ init_threadref(&ref, &refcount); @@ -218,7 +218,7 @@ static void test_SHSetThreadRef(void) refcount = 1; hr = pSHSetThreadRef(&ref.IUnknown_iface); ok( (hr == S_OK) && (refcount == 1) && (!AddRef_called), - "got 0x%x with %d, %d (expected S_OK with 1, 0)\n", + "got 0x%lx with %ld, %ld (expected S_OK with 1, 0)\n", hr, refcount, AddRef_called);
/* read back our object */ @@ -227,17 +227,17 @@ static void test_SHSetThreadRef(void) punk = NULL; hr = pSHGetThreadRef(&punk); ok( (hr == S_OK) && (punk == &ref.IUnknown_iface) && (refcount == 2) && (AddRef_called == 1), - "got 0x%x and %p with %d, %d (expected S_OK and %p with 2, 1)\n", + "got 0x%lx and %p with %ld, %ld (expected S_OK and %p with 2, 1)\n", hr, punk, refcount, AddRef_called, &ref);
/* clear the object pointer */ hr = pSHSetThreadRef(NULL); - ok(hr == S_OK, "got 0x%x (expected S_OK)\n", hr); + ok(hr == S_OK, "got 0x%lx (expected S_OK)\n", hr);
/* verify, that our object is no longer known as ThreadRef */ hr = pSHGetThreadRef(&punk); ok( (hr == E_NOINTERFACE) && (punk == NULL), - "got 0x%x and %p (expected E_NOINTERFACE and NULL)\n", hr, punk); + "got 0x%lx and %p (expected E_NOINTERFACE and NULL)\n", hr, punk);
}
diff --git a/dlls/shlwapi/tests/url.c b/dlls/shlwapi/tests/url.c index c6c7e26cec6..476358c6d45 100644 --- a/dlls/shlwapi/tests/url.c +++ b/dlls/shlwapi/tests/url.c @@ -489,17 +489,17 @@ static void test_UrlApplyScheme(void) strcpy(newurl, "untouched"); res = UrlApplySchemeA(TEST_APPLY[i].url, newurl, &len, TEST_APPLY[i].flags); ok( res == TEST_APPLY[i].res, - "#%dA: got HRESULT 0x%x (expected 0x%x)\n", i, res, TEST_APPLY[i].res); + "#%ldA: got HRESULT 0x%lx (expected 0x%lx)\n", i, res, TEST_APPLY[i].res); if (res == S_OK) { - ok(len == strlen(newurl), "Test %u: Expected length %u, got %u.\n", i, strlen(newurl), len); - ok(!strcmp(newurl, TEST_APPLY[i].newurl), "Test %u: Expected %s, got %s.\n", + ok(len == strlen(newurl), "Test %lu: Expected length %Iu, got %lu.\n", i, strlen(newurl), len); + ok(!strcmp(newurl, TEST_APPLY[i].newurl), "Test %lu: Expected %s, got %s.\n", i, debugstr_a(TEST_APPLY[i].newurl), debugstr_a(newurl)); } else { - ok(len == ARRAY_SIZE(newurl), "Test %u: Got length %u.\n", i, len); - ok(!strcmp(newurl, "untouched"), "Test %u: Got %s.\n", i, debugstr_a(newurl)); + ok(len == ARRAY_SIZE(newurl), "Test %lu: Got length %lu.\n", i, len); + ok(!strcmp(newurl, "untouched"), "Test %lu: Got %s.\n", i, debugstr_a(newurl)); }
/* returned length is in character */ @@ -510,17 +510,17 @@ static void test_UrlApplyScheme(void) wcscpy(newurlW, L"untouched"); res = UrlApplySchemeW(urlW, newurlW, &len, TEST_APPLY[i].flags); ok( res == TEST_APPLY[i].res, - "#%dW: got HRESULT 0x%x (expected 0x%x)\n", i, res, TEST_APPLY[i].res); + "#%ldW: got HRESULT 0x%lx (expected 0x%lx)\n", i, res, TEST_APPLY[i].res); if (res == S_OK) { - ok(len == wcslen(newurlW), "Test %u: Expected length %u, got %u.\n", i, wcslen(newurlW), len); - ok(!wcscmp(newurlW, expectW), "Test %u: Expected %s, got %s.\n", + ok(len == wcslen(newurlW), "Test %lu: Expected length %Iu, got %lu.\n", i, wcslen(newurlW), len); + ok(!wcscmp(newurlW, expectW), "Test %lu: Expected %s, got %s.\n", i, debugstr_w(expectW), debugstr_w(newurlW)); } else { - ok(len == ARRAY_SIZE(newurlW), "Test %u: Got length %u.\n", i, len); - ok(!wcscmp(newurlW, L"untouched"), "Test %u: Got %s.\n", i, debugstr_w(newurlW)); + ok(len == ARRAY_SIZE(newurlW), "Test %lu: Got length %lu.\n", i, len); + ok(!wcscmp(newurlW, L"untouched"), "Test %lu: Got %s.\n", i, debugstr_w(newurlW)); } }
@@ -528,28 +528,28 @@ static void test_UrlApplyScheme(void) lstrcpyA(newurl, untouchedA); len = lstrlenA(TEST_APPLY[0].newurl); res = UrlApplySchemeA(TEST_APPLY[0].url, newurl, &len, TEST_APPLY[0].flags); - ok(res == E_POINTER, "got HRESULT 0x%x (expected E_POINTER)\n", res); + ok(res == E_POINTER, "got HRESULT 0x%lx (expected E_POINTER)\n", res); /* The returned length include the space for the terminating 0 */ i = lstrlenA(TEST_APPLY[0].newurl)+1; - ok(len == i, "got len %d (expected %d)\n", len, i); + ok(len == i, "got len %ld (expected %ld)\n", len, i); ok(!lstrcmpA(newurl, untouchedA), "got '%s' (expected '%s')\n", newurl, untouchedA);
/* NULL as parameter. The length and the buffer are not modified */ lstrcpyA(newurl, untouchedA); len = ARRAY_SIZE(newurl); res = UrlApplySchemeA(NULL, newurl, &len, TEST_APPLY[0].flags); - ok(res == E_INVALIDARG, "got HRESULT 0x%x (expected E_INVALIDARG)\n", res); - ok(len == ARRAY_SIZE(newurl), "got len %d\n", len); + ok(res == E_INVALIDARG, "got HRESULT 0x%lx (expected E_INVALIDARG)\n", res); + ok(len == ARRAY_SIZE(newurl), "got len %ld\n", len); ok(!lstrcmpA(newurl, untouchedA), "got '%s' (expected '%s')\n", newurl, untouchedA);
len = ARRAY_SIZE(newurl); res = UrlApplySchemeA(TEST_APPLY[0].url, NULL, &len, TEST_APPLY[0].flags); - ok(res == E_INVALIDARG, "got HRESULT 0x%x (expected E_INVALIDARG)\n", res); - ok(len == ARRAY_SIZE(newurl), "got len %d\n", len); + ok(res == E_INVALIDARG, "got HRESULT 0x%lx (expected E_INVALIDARG)\n", res); + ok(len == ARRAY_SIZE(newurl), "got len %ld\n", len);
lstrcpyA(newurl, untouchedA); res = UrlApplySchemeA(TEST_APPLY[0].url, newurl, NULL, TEST_APPLY[0].flags); - ok(res == E_INVALIDARG, "got HRESULT 0x%x (expected E_INVALIDARG)\n", res); + ok(res == E_INVALIDARG, "got HRESULT 0x%lx (expected E_INVALIDARG)\n", res); ok(!lstrcmpA(newurl, untouchedA), "got '%s' (expected '%s')\n", newurl, untouchedA);
} @@ -565,12 +565,12 @@ static void hash_url(const char* szUrl) DWORD cbSize = sizeof(DWORD); DWORD dwHash1, dwHash2; res = UrlHashA(szTestUrl, (LPBYTE)&dwHash1, cbSize); - ok(res == S_OK, "UrlHashA returned 0x%x (expected S_OK) for %s\n", res, szUrl); + ok(res == S_OK, "UrlHashA returned 0x%lx (expected S_OK) for %s\n", res, szUrl);
res = UrlHashW(wszTestUrl, (LPBYTE)&dwHash2, cbSize); - ok(res == S_OK, "UrlHashW returned 0x%x (expected S_OK) for %s\n", res, szUrl); + ok(res == S_OK, "UrlHashW returned 0x%lx (expected S_OK) for %s\n", res, szUrl); ok(dwHash1 == dwHash2, - "Hashes didn't match (A: 0x%x, W: 0x%x) for %s\n", dwHash1, dwHash2, szUrl); + "Hashes didn't match (A: 0x%lx, W: 0x%lx) for %s\n", dwHash1, dwHash2, szUrl); FreeWideString(wszTestUrl); }
@@ -751,23 +751,23 @@ static void test_UrlGetPart(void) winetest_mute_threshold = 5;
hr = UrlGetPartA(NULL, NULL, NULL, URL_PART_SCHEME, 0); - ok(hr == E_INVALIDARG, "Got hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got hr %#lx.\n", hr);
hr = UrlGetPartA(NULL, buffer, &size, URL_PART_SCHEME, 0); - ok(hr == E_INVALIDARG, "Got hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got hr %#lx.\n", hr);
hr = UrlGetPartA("res://some.dll/find.dlg", NULL, &size, URL_PART_SCHEME, 0); - ok(hr == E_INVALIDARG, "Got hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got hr %#lx.\n", hr);
hr = UrlGetPartA("res://some.dll/find.dlg", buffer, NULL, URL_PART_SCHEME, 0); - ok(hr == E_INVALIDARG, "Got hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got hr %#lx.\n", hr);
size = 0; strcpy(buffer, "x"); hr = UrlGetPartA("hi", buffer, &size, URL_PART_SCHEME, 0); - ok(hr == E_INVALIDARG, "Got hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got hr %#lx.\n", hr); ok(!strcmp(buffer, "x"), "Got result %s.\n", debugstr_a(buffer)); - ok(!size, "Got size %u.\n", size); + ok(!size, "Got size %lu.\n", size);
for (i = 0; i < ARRAY_SIZE(tests); ++i) { @@ -777,7 +777,7 @@ static void test_UrlGetPart(void) DWORD flags = tests[i].flags; DWORD part = tests[i].part;
- winetest_push_context("URL %s, part %#x, flags %#x", debugstr_a(url), part, flags); + winetest_push_context("URL %s, part %#lx, flags %#lx", debugstr_a(url), part, flags);
size = 1; strcpy(buffer, "x"); @@ -785,14 +785,14 @@ static void test_UrlGetPart(void) todo_wine_if (tests[i].todo_hr) { if (tests[i].hr == S_OK) - ok(hr == E_POINTER, "Got hr %#x.\n", hr); + ok(hr == E_POINTER, "Got hr %#lx.\n", hr); else - ok(hr == tests[i].hr, "Got hr %#x.\n", hr); + ok(hr == tests[i].hr, "Got hr %#lx.\n", hr); }
if (hr == S_FALSE) { - ok(!size, "Got size %u.\n", size); + ok(!size, "Got size %lu.\n", size); ok(!buffer[0], "Got result %s.\n", debugstr_a(buffer)); } else @@ -802,12 +802,12 @@ static void test_UrlGetPart(void) if (expect) { todo_wine_if (tests[i].todo_hr || tests[i].todo_result) - ok(size == strlen(expect) + 1, "Got size %u.\n", size); + ok(size == strlen(expect) + 1, "Got size %lu.\n", size); } } else { - ok(size == 1, "Got size %u.\n", size); + ok(size == 1, "Got size %lu.\n", size); } ok(!strcmp(buffer, "x"), "Got result %s.\n", debugstr_a(buffer)); } @@ -816,10 +816,10 @@ static void test_UrlGetPart(void) strcpy(buffer, "x"); hr = UrlGetPartA(url, buffer, &size, part, flags); todo_wine_if (tests[i].todo_hr) - ok(hr == tests[i].hr, "Got hr %#x.\n", hr); + ok(hr == tests[i].hr, "Got hr %#lx.\n", hr); if (SUCCEEDED(hr)) { - ok(size == strlen(buffer), "Got size %u.\n", size); + ok(size == strlen(buffer), "Got size %lu.\n", size); if (expect) { todo_wine_if (tests[i].todo_hr || tests[i].todo_result) @@ -828,7 +828,7 @@ static void test_UrlGetPart(void) } else { - ok(size == sizeof(buffer), "Got size %u.\n", size); + ok(size == sizeof(buffer), "Got size %lu.\n", size); ok(!strcmp(buffer, "x"), "Got result %s.\n", debugstr_a(buffer)); }
@@ -840,14 +840,14 @@ static void test_UrlGetPart(void) todo_wine_if (tests[i].todo_hr || tests[i].hr == S_FALSE) { if (tests[i].hr == S_OK) - ok(hr == E_POINTER, "Got hr %#x.\n", hr); + ok(hr == E_POINTER, "Got hr %#lx.\n", hr); else - ok(hr == (tests[i].hr == S_FALSE ? S_OK : tests[i].hr), "Got hr %#x.\n", hr); + ok(hr == (tests[i].hr == S_FALSE ? S_OK : tests[i].hr), "Got hr %#lx.\n", hr); }
if (SUCCEEDED(hr)) { - ok(!size, "Got size %u.\n", size); + ok(!size, "Got size %lu.\n", size); ok(!buffer[0], "Got result %s.\n", debugstr_a(buffer)); } else @@ -857,12 +857,12 @@ static void test_UrlGetPart(void) if (expect) { todo_wine_if (tests[i].todo_hr || tests[i].todo_result) - ok(size == strlen(expect) + 1, "Got size %u.\n", size); + ok(size == strlen(expect) + 1, "Got size %lu.\n", size); } } else { - ok(size == 1, "Got size %u.\n", size); + ok(size == 1, "Got size %lu.\n", size); } ok(!wcscmp(bufferW, L"x"), "Got result %s.\n", debugstr_w(bufferW)); } @@ -871,16 +871,16 @@ static void test_UrlGetPart(void) wcscpy(bufferW, L"x"); hr = UrlGetPartW(urlW, bufferW, &size, part, flags); todo_wine_if ((tests[i].hr == S_FALSE || tests[i].todo_hr) && strcmp(url, "a:") && strcmp(url, "0:")) - ok(hr == (tests[i].hr == S_FALSE ? S_OK : tests[i].hr), "Got hr %#x.\n", hr); + ok(hr == (tests[i].hr == S_FALSE ? S_OK : tests[i].hr), "Got hr %#lx.\n", hr); if (SUCCEEDED(hr)) { - ok(size == wcslen(bufferW), "Got size %u.\n", size); + ok(size == wcslen(bufferW), "Got size %lu.\n", size); MultiByteToWideChar(CP_ACP, 0, buffer, -1, expectW, ARRAY_SIZE(expectW)); ok(!wcscmp(bufferW, expectW), "Got result %s.\n", debugstr_w(bufferW)); } else { - ok(size == ARRAY_SIZE(bufferW), "Got size %u.\n", size); + ok(size == ARRAY_SIZE(bufferW), "Got size %lu.\n", size); ok(!wcscmp(bufferW, L"x"), "Got result %s.\n", debugstr_w(bufferW)); }
@@ -904,18 +904,18 @@ static void check_url_canonicalize(int index, const char *szUrl, DWORD dwFlags,
dwSize = INTERNET_MAX_URL_LENGTH; ret = UrlCanonicalizeA(szUrl, NULL, &dwSize, dwFlags); - ok(ret == E_INVALIDARG, "Got unexpected hr %#x for index %d.\n", ret, index); + ok(ret == E_INVALIDARG, "Got unexpected hr %#lx for index %d.\n", ret, index); ret = UrlCanonicalizeA(szUrl, szReturnUrl, &dwSize, dwFlags); ok(ret == S_OK || (!szUrl[0] && ret == S_FALSE) /* Vista+ */, - "Got unexpected hr %#x for index %d.\n", ret, index); + "Got unexpected hr %#lx for index %d.\n", ret, index); todo_wine_if (todo) - ok(strcmp(szReturnUrl,szExpectUrl)==0, "UrlCanonicalizeA dwFlags 0x%08x url '%s' Expected "%s", but got "%s", index %d\n", dwFlags, szUrl, szExpectUrl, szReturnUrl, index); + ok(strcmp(szReturnUrl,szExpectUrl)==0, "UrlCanonicalizeA dwFlags 0x%08lx url '%s' Expected "%s", but got "%s", index %d\n", dwFlags, szUrl, szExpectUrl, szReturnUrl, index);
dwSize = INTERNET_MAX_URL_LENGTH; ret = UrlCanonicalizeW(wszUrl, NULL, &dwSize, dwFlags); - ok(ret == E_INVALIDARG, "Got unexpected hr %#x for index %d.\n", ret, index); + ok(ret == E_INVALIDARG, "Got unexpected hr %#lx for index %d.\n", ret, index); ret = UrlCanonicalizeW(wszUrl, wszReturnUrl, &dwSize, dwFlags); - ok(ret == S_OK, "Got unexpected hr %#x for index %d.\n", ret, index); + ok(ret == S_OK, "Got unexpected hr %#lx for index %d.\n", ret, index);
wszConvertedUrl = GetWideString(szReturnUrl); ok(lstrcmpW(wszReturnUrl, wszConvertedUrl)==0, @@ -935,36 +935,36 @@ static void test_UrlEscapeA(void) char empty_string[] = "";
ret = UrlEscapeA("/woningplan/woonkamer basis.swf", NULL, &size, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_INVALIDARG, "got %x, expected %x\n", ret, E_INVALIDARG); - ok(size == 0, "got %d, expected %d\n", size, 0); + ok(ret == E_INVALIDARG, "got %lx, expected %lx\n", ret, E_INVALIDARG); + ok(size == 0, "got %ld, expected %d\n", size, 0);
size = 0; ret = UrlEscapeA("/woningplan/woonkamer basis.swf", empty_string, &size, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_INVALIDARG, "got %x, expected %x\n", ret, E_INVALIDARG); - ok(size == 0, "got %d, expected %d\n", size, 0); + ok(ret == E_INVALIDARG, "got %lx, expected %lx\n", ret, E_INVALIDARG); + ok(size == 0, "got %ld, expected %d\n", size, 0);
size = 1; ret = UrlEscapeA("/woningplan/woonkamer basis.swf", NULL, &size, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_INVALIDARG, "got %x, expected %x\n", ret, E_INVALIDARG); - ok(size == 1, "got %d, expected %d\n", size, 1); + ok(ret == E_INVALIDARG, "got %lx, expected %lx\n", ret, E_INVALIDARG); + ok(size == 1, "got %ld, expected %d\n", size, 1);
size = 1; ret = UrlEscapeA("/woningplan/woonkamer basis.swf", empty_string, NULL, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_INVALIDARG, "got %x, expected %x\n", ret, E_INVALIDARG); - ok(size == 1, "got %d, expected %d\n", size, 1); + ok(ret == E_INVALIDARG, "got %lx, expected %lx\n", ret, E_INVALIDARG); + ok(size == 1, "got %ld, expected %d\n", size, 1);
size = 1; empty_string[0] = 127; ret = UrlEscapeA("/woningplan/woonkamer basis.swf", empty_string, &size, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_POINTER, "got %x, expected %x\n", ret, E_POINTER); - ok(size == 34, "got %d, expected %d\n", size, 34); + ok(ret == E_POINTER, "got %lx, expected %lx\n", ret, E_POINTER); + ok(size == 34, "got %ld, expected %d\n", size, 34); ok(empty_string[0] == 127, "String has changed, empty_string[0] = %d\n", empty_string[0]);
size = 1; empty_string[0] = 127; ret = UrlEscapeA("/woningplan/woonkamer basis.swf", empty_string, &size, URL_ESCAPE_AS_UTF8); - ok(ret == E_NOTIMPL, "Got unexpected hr %#x.\n", ret); - ok(size == 1, "Got unexpected size %u.\n", size); + ok(ret == E_NOTIMPL, "Got unexpected hr %#lx.\n", ret); + ok(size == 1, "Got unexpected size %lu.\n", size); ok(empty_string[0] == 127, "String has changed, empty_string[0] = %d\n", empty_string[0]);
for (i = 0; i < ARRAY_SIZE(TEST_ESCAPE); i++) { @@ -972,7 +972,7 @@ static void test_UrlEscapeA(void)
size = INTERNET_MAX_URL_LENGTH; ret = UrlEscapeA(TEST_ESCAPE[i].url, ret_url, &size, TEST_ESCAPE[i].flags); - ok(ret == S_OK, "Got unexpected hr %#x for %s.\n", ret, debugstr_a(TEST_ESCAPE[i].url)); + ok(ret == S_OK, "Got unexpected hr %#lx for %s.\n", ret, debugstr_a(TEST_ESCAPE[i].url)); ok(!strcmp(ret_url, TEST_ESCAPE[i].expecturl), "Expected "%s", but got "%s" for "%s"\n", TEST_ESCAPE[i].expecturl, ret_url, TEST_ESCAPE[i].url); } @@ -991,56 +991,56 @@ static void test_UrlEscapeW(void) /* Check error paths */
ret = UrlEscapeW(L"/test", NULL, NULL, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_INVALIDARG, "got %x, expected %x\n", ret, E_INVALIDARG); + ok(ret == E_INVALIDARG, "got %lx, expected %lx\n", ret, E_INVALIDARG);
size = 0; ret = UrlEscapeW(L"/test", NULL, &size, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_INVALIDARG, "got %x, expected %x\n", ret, E_INVALIDARG); - ok(size == 0, "got %d, expected %d\n", size, 0); + ok(ret == E_INVALIDARG, "got %lx, expected %lx\n", ret, E_INVALIDARG); + ok(size == 0, "got %ld, expected %d\n", size, 0);
ret = UrlEscapeW(L"/test", empty_string, NULL, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_INVALIDARG, "got %x, expected %x\n", ret, E_INVALIDARG); + ok(ret == E_INVALIDARG, "got %lx, expected %lx\n", ret, E_INVALIDARG);
size = 0; ret = UrlEscapeW(L"/test", empty_string, &size, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_INVALIDARG, "got %x, expected %x\n", ret, E_INVALIDARG); - ok(size == 0, "got %d, expected %d\n", size, 0); + ok(ret == E_INVALIDARG, "got %lx, expected %lx\n", ret, E_INVALIDARG); + ok(size == 0, "got %ld, expected %d\n", size, 0);
ret = UrlEscapeW(L"/test", NULL, NULL, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_INVALIDARG, "got %x, expected %x\n", ret, E_INVALIDARG); + ok(ret == E_INVALIDARG, "got %lx, expected %lx\n", ret, E_INVALIDARG);
size = 1; ret = UrlEscapeW(L"/test", NULL, &size, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_INVALIDARG, "got %x, expected %x\n", ret, E_INVALIDARG); - ok(size == 1, "got %d, expected %d\n", size, 1); + ok(ret == E_INVALIDARG, "got %lx, expected %lx\n", ret, E_INVALIDARG); + ok(size == 1, "got %ld, expected %d\n", size, 1);
ret = UrlEscapeW(L"/test", empty_string, NULL, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_INVALIDARG, "got %x, expected %x\n", ret, E_INVALIDARG); + ok(ret == E_INVALIDARG, "got %lx, expected %lx\n", ret, E_INVALIDARG);
size = 1; ret = UrlEscapeW(L"/test", empty_string, &size, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_POINTER, "got %x, expected %x\n", ret, E_POINTER); - ok(size == 6, "got %d, expected %d\n", size, 6); + ok(ret == E_POINTER, "got %lx, expected %lx\n", ret, E_POINTER); + ok(size == 6, "got %ld, expected %d\n", size, 6);
/* Check actual escaping */
size = ARRAY_SIZE(overwrite); ret = UrlEscapeW(overwrite, overwrite, &size, URL_ESCAPE_SPACES_ONLY); - ok(ret == S_OK, "got %x, expected S_OK\n", ret); - ok(size == 9, "got %d, expected 9\n", size); + ok(ret == S_OK, "got %lx, expected S_OK\n", ret); + ok(size == 9, "got %ld, expected 9\n", size); ok(!wcscmp(overwrite, L"foo%20bar"), "Got unexpected string %s.\n", debugstr_w(overwrite));
size = 1; wc = 127; ret = UrlEscapeW(overwrite, &wc, &size, URL_ESCAPE_SPACES_ONLY); - ok(ret == E_POINTER, "got %x, expected %x\n", ret, E_POINTER); - ok(size == 10, "got %d, expected 10\n", size); + ok(ret == E_POINTER, "got %lx, expected %lx\n", ret, E_POINTER); + ok(size == 10, "got %ld, expected 10\n", size); ok(wc == 127, "String has changed, wc = %d\n", wc);
/* non-ASCII range */ size = ARRAY_SIZE(ret_urlW); ret = UrlEscapeW(L"ftp\x1f\xff\xfa\x2122q/", ret_urlW, &size, 0); - ok(ret == S_OK, "got %x, expected S_OK\n", ret); + ok(ret == S_OK, "got %lx, expected S_OK\n", ret); ok(!wcscmp(ret_urlW, L"ftp%1F%FF%FA\x2122q/"), "Got unexpected string %s.\n", debugstr_w(ret_urlW));
for (i = 0; i < ARRAY_SIZE(TEST_ESCAPE); i++) { @@ -1051,8 +1051,8 @@ static void test_UrlEscapeW(void) urlW = GetWideString(TEST_ESCAPE[i].url); expected_urlW = GetWideString(TEST_ESCAPE[i].expecturl); ret = UrlEscapeW(urlW, ret_urlW, &size, TEST_ESCAPE[i].flags); - ok(ret == S_OK, "Got unexpected hr %#x for %s.\n", ret, debugstr_w(urlW)); - ok(!lstrcmpW(ret_urlW, expected_urlW), "Expected %s, but got %s for %s flags %08x\n", + ok(ret == S_OK, "Got unexpected hr %#lx for %s.\n", ret, debugstr_w(urlW)); + ok(!lstrcmpW(ret_urlW, expected_urlW), "Expected %s, but got %s for %s flags %08lx\n", wine_dbgstr_w(expected_urlW), wine_dbgstr_w(ret_urlW), wine_dbgstr_w(urlW), TEST_ESCAPE[i].flags); FreeWideString(urlW); FreeWideString(expected_urlW); @@ -1063,7 +1063,7 @@ static void test_UrlEscapeW(void)
size = INTERNET_MAX_URL_LENGTH; ret = UrlEscapeW(TEST_ESCAPEW[i].url, ret_url, &size, TEST_ESCAPEW[i].flags); - ok(ret == S_OK, "Got unexpected hr %#x for %s.\n", ret, debugstr_w(TEST_ESCAPEW[i].url)); + ok(ret == S_OK, "Got unexpected hr %#lx for %s.\n", ret, debugstr_w(TEST_ESCAPEW[i].url)); ok(!wcscmp(ret_url, TEST_ESCAPEW[i].expecturl) || broken(!wcscmp(ret_url, TEST_ESCAPEW[i].win7url)), "Expected %s, but got %s for %s.\n", debugstr_w(TEST_ESCAPEW[i].expecturl), @@ -1087,18 +1087,18 @@ static void test_UrlCanonicalizeA(void) /* Parameter checks */ dwSize = ARRAY_SIZE(szReturnUrl); hr = UrlCanonicalizeA(NULL, szReturnUrl, &dwSize, URL_UNESCAPE); - ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
dwSize = ARRAY_SIZE(szReturnUrl); hr = UrlCanonicalizeA(winehqA, NULL, &dwSize, URL_UNESCAPE); - ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
hr = UrlCanonicalizeA(winehqA, szReturnUrl, NULL, URL_UNESCAPE); - ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
dwSize = 0; hr = UrlCanonicalizeA(winehqA, szReturnUrl, &dwSize, URL_UNESCAPE); - ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
/* buffer has no space for the result */ dwSize=urllen-1; @@ -1107,7 +1107,7 @@ static void test_UrlCanonicalizeA(void) SetLastError(0xdeadbeef); hr = UrlCanonicalizeA(winehqA, szReturnUrl, &dwSize, URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE); ok( (hr == E_POINTER) && (dwSize == (urllen + 1)), - "got 0x%x with %u and size %u for '%s' and %u (expected 'E_POINTER' and size %u)\n", + "got 0x%lx with %lu and size %lu for '%s' and %u (expected 'E_POINTER' and size %lu)\n", hr, GetLastError(), dwSize, szReturnUrl, lstrlenA(szReturnUrl), urllen+1);
/* buffer has no space for the terminating '\0' */ @@ -1117,7 +1117,7 @@ static void test_UrlCanonicalizeA(void) SetLastError(0xdeadbeef); hr = UrlCanonicalizeA(winehqA, szReturnUrl, &dwSize, URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE); ok( (hr == E_POINTER) && (dwSize == (urllen + 1)), - "got 0x%x with %u and size %u for '%s' and %u (expected 'E_POINTER' and size %u)\n", + "got 0x%lx with %lu and size %lu for '%s' and %u (expected 'E_POINTER' and size %lu)\n", hr, GetLastError(), dwSize, szReturnUrl, lstrlenA(szReturnUrl), urllen+1);
/* buffer has the required size */ @@ -1127,7 +1127,7 @@ static void test_UrlCanonicalizeA(void) SetLastError(0xdeadbeef); hr = UrlCanonicalizeA(winehqA, szReturnUrl, &dwSize, URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE); ok( (hr == S_OK) && (dwSize == urllen), - "got 0x%x with %u and size %u for '%s' and %u (expected 'S_OK' and size %u)\n", + "got 0x%lx with %lu and size %lu for '%s' and %u (expected 'S_OK' and size %lu)\n", hr, GetLastError(), dwSize, szReturnUrl, lstrlenA(szReturnUrl), urllen);
/* buffer is larger as the required size */ @@ -1137,7 +1137,7 @@ static void test_UrlCanonicalizeA(void) SetLastError(0xdeadbeef); hr = UrlCanonicalizeA(winehqA, szReturnUrl, &dwSize, URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE); ok( (hr == S_OK) && (dwSize == urllen), - "got 0x%x with %u and size %u for '%s' and %u (expected 'S_OK' and size %u)\n", + "got 0x%lx with %lu and size %lu for '%s' and %u (expected 'S_OK' and size %lu)\n", hr, GetLastError(), dwSize, szReturnUrl, lstrlenA(szReturnUrl), urllen);
/* length is set to 0 */ @@ -1147,7 +1147,7 @@ static void test_UrlCanonicalizeA(void) SetLastError(0xdeadbeef); hr = UrlCanonicalizeA(winehqA, szReturnUrl, &dwSize, URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE); ok( (hr == E_INVALIDARG) && (dwSize == 0), - "got 0x%x with %u and size %u for '%s' and %u (expected 'E_INVALIDARG' and size %u)\n", + "got 0x%lx with %lu and size %lu for '%s' and %u (expected 'E_INVALIDARG' and size %u)\n", hr, GetLastError(), dwSize, szReturnUrl, lstrlenA(szReturnUrl), 0);
/* url length > INTERNET_MAX_URL_SIZE */ @@ -1156,7 +1156,7 @@ static void test_UrlCanonicalizeA(void) memcpy(longurl, winehqA, sizeof(winehqA)-1); longurl[sizeof(longurl)-1] = '\0'; hr = UrlCanonicalizeA(longurl, szReturnUrl, &dwSize, URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE); - ok(hr == S_OK, "hr = %x\n", hr); + ok(hr == S_OK, "hr = %lx\n", hr);
/* test url-modification */ for (i = 0; i < ARRAY_SIZE(TEST_CANONICALIZE); i++) { @@ -1180,18 +1180,18 @@ static void test_UrlCanonicalizeW(void) /* Parameter checks */ dwSize = ARRAY_SIZE(szReturnUrl); hr = UrlCanonicalizeW(NULL, szReturnUrl, &dwSize, URL_UNESCAPE); - ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
dwSize = ARRAY_SIZE(szReturnUrl); hr = UrlCanonicalizeW(winehqW, NULL, &dwSize, URL_UNESCAPE); - ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
hr = UrlCanonicalizeW(winehqW, szReturnUrl, NULL, URL_UNESCAPE); - ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
dwSize = 0; hr = UrlCanonicalizeW(winehqW, szReturnUrl, &dwSize, URL_UNESCAPE); - ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
/* buffer has no space for the result */ dwSize = (urllen-1); @@ -1200,7 +1200,7 @@ static void test_UrlCanonicalizeW(void) SetLastError(0xdeadbeef); hr = UrlCanonicalizeW(winehqW, szReturnUrl, &dwSize, URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE); ok( (hr == E_POINTER) && (dwSize == (urllen + 1)), - "got 0x%x with %u and size %u for %u (expected 'E_POINTER' and size %u)\n", + "got 0x%lx with %lu and size %lu for %u (expected 'E_POINTER' and size %lu)\n", hr, GetLastError(), dwSize, lstrlenW(szReturnUrl), urllen+1);
@@ -1211,7 +1211,7 @@ static void test_UrlCanonicalizeW(void) SetLastError(0xdeadbeef); hr = UrlCanonicalizeW(winehqW, szReturnUrl, &dwSize, URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE); ok( (hr == E_POINTER) && (dwSize == (urllen + 1)), - "got 0x%x with %u and size %u for %u (expected 'E_POINTER' and size %u)\n", + "got 0x%lx with %lu and size %lu for %u (expected 'E_POINTER' and size %lu)\n", hr, GetLastError(), dwSize, lstrlenW(szReturnUrl), urllen+1);
/* buffer has the required size */ @@ -1221,7 +1221,7 @@ static void test_UrlCanonicalizeW(void) SetLastError(0xdeadbeef); hr = UrlCanonicalizeW(winehqW, szReturnUrl, &dwSize, URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE); ok( (hr == S_OK) && (dwSize == urllen), - "got 0x%x with %u and size %u for %u (expected 'S_OK' and size %u)\n", + "got 0x%lx with %lu and size %lu for %u (expected 'S_OK' and size %lu)\n", hr, GetLastError(), dwSize, lstrlenW(szReturnUrl), urllen);
/* buffer is larger as the required size */ @@ -1231,7 +1231,7 @@ static void test_UrlCanonicalizeW(void) SetLastError(0xdeadbeef); hr = UrlCanonicalizeW(winehqW, szReturnUrl, &dwSize, URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE); ok( (hr == S_OK) && (dwSize == urllen), - "got 0x%x with %u and size %u for %u (expected 'S_OK' and size %u)\n", + "got 0x%lx with %lu and size %lu for %u (expected 'S_OK' and size %lu)\n", hr, GetLastError(), dwSize, lstrlenW(szReturnUrl), urllen);
/* check that the characters 1..32 are chopped from the end of the string */ @@ -1268,36 +1268,36 @@ static void check_url_combine(const char *szUrl1, const char *szUrl2, DWORD dwFl wszExpectUrl = GetWideString(szExpectUrl);
hr = UrlCombineA(szUrl1, szUrl2, NULL, NULL, dwFlags); - ok(hr == E_INVALIDARG, "UrlCombineA returned 0x%08x, expected 0x%08x\n", hr, E_INVALIDARG); + ok(hr == E_INVALIDARG, "UrlCombineA returned 0x%08lx, expected 0x%08lx\n", hr, E_INVALIDARG);
dwSize = 0; hr = UrlCombineA(szUrl1, szUrl2, NULL, &dwSize, dwFlags); - ok(hr == E_POINTER, "Checking length of string, return was 0x%08x, expected 0x%08x\n", hr, E_POINTER); - ok(dwSize == dwExpectLen+1, "Got length %d, expected %d\n", dwSize, dwExpectLen+1); + ok(hr == E_POINTER, "Checking length of string, return was 0x%08lx, expected 0x%08lx\n", hr, E_POINTER); + ok(dwSize == dwExpectLen+1, "Got length %ld, expected %ld\n", dwSize, dwExpectLen+1);
dwSize--; hr = UrlCombineA(szUrl1, szUrl2, szReturnUrl, &dwSize, dwFlags); - ok(hr == E_POINTER, "UrlCombineA returned 0x%08x, expected 0x%08x\n", hr, E_POINTER); - ok(dwSize == dwExpectLen+1, "Got length %d, expected %d\n", dwSize, dwExpectLen+1); + ok(hr == E_POINTER, "UrlCombineA returned 0x%08lx, expected 0x%08lx\n", hr, E_POINTER); + ok(dwSize == dwExpectLen+1, "Got length %ld, expected %ld\n", dwSize, dwExpectLen+1);
hr = UrlCombineA(szUrl1, szUrl2, szReturnUrl, &dwSize, dwFlags); - ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); - ok(dwSize == dwExpectLen, "Got length %d, expected %d\n", dwSize, dwExpectLen); + ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); + ok(dwSize == dwExpectLen, "Got length %ld, expected %ld\n", dwSize, dwExpectLen); ok(!strcmp(szReturnUrl, szExpectUrl), "Expected %s, got %s.\n", szExpectUrl, szReturnUrl);
dwSize = 0; hr = UrlCombineW(wszUrl1, wszUrl2, NULL, &dwSize, dwFlags); - ok(hr == E_POINTER, "Checking length of string, return was 0x%08x, expected 0x%08x\n", hr, E_POINTER); - ok(dwSize == dwExpectLen+1, "Got length %d, expected %d\n", dwSize, dwExpectLen+1); + ok(hr == E_POINTER, "Checking length of string, return was 0x%08lx, expected 0x%08lx\n", hr, E_POINTER); + ok(dwSize == dwExpectLen+1, "Got length %ld, expected %ld\n", dwSize, dwExpectLen+1);
dwSize--; hr = UrlCombineW(wszUrl1, wszUrl2, wszReturnUrl, &dwSize, dwFlags); - ok(hr == E_POINTER, "UrlCombineW returned 0x%08x, expected 0x%08x\n", hr, E_POINTER); - ok(dwSize == dwExpectLen+1, "Got length %d, expected %d\n", dwSize, dwExpectLen+1); + ok(hr == E_POINTER, "UrlCombineW returned 0x%08lx, expected 0x%08lx\n", hr, E_POINTER); + ok(dwSize == dwExpectLen+1, "Got length %ld, expected %ld\n", dwSize, dwExpectLen+1);
hr = UrlCombineW(wszUrl1, wszUrl2, wszReturnUrl, &dwSize, dwFlags); - ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); - ok(dwSize == dwExpectLen, "Got length %d, expected %d\n", dwSize, dwExpectLen); + ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); + ok(dwSize == dwExpectLen, "Got length %ld, expected %ld\n", dwSize, dwExpectLen); wszConvertedUrl = GetWideString(szReturnUrl); ok(!wcscmp(wszReturnUrl, wszConvertedUrl), "Expected %s, got %s.\n", debugstr_w(wszConvertedUrl), debugstr_w(wszReturnUrl)); @@ -1331,20 +1331,20 @@ static void test_UrlCreateFromPath(void) for (i = 0; i < ARRAY_SIZE(TEST_URLFROMPATH); i++) { len = INTERNET_MAX_URL_LENGTH; ret = UrlCreateFromPathA(TEST_URLFROMPATH[i].path, ret_url, &len, 0); - ok(ret == TEST_URLFROMPATH[i].ret, "ret %08x from path %s\n", ret, TEST_URLFROMPATH[i].path); + ok(ret == TEST_URLFROMPATH[i].ret, "ret %08lx from path %s\n", ret, TEST_URLFROMPATH[i].path); ok(!lstrcmpiA(ret_url, TEST_URLFROMPATH[i].url), "url %s from path %s\n", ret_url, TEST_URLFROMPATH[i].path); - ok(len == strlen(ret_url), "ret len %d from path %s\n", len, TEST_URLFROMPATH[i].path); + ok(len == strlen(ret_url), "ret len %ld from path %s\n", len, TEST_URLFROMPATH[i].path);
len = INTERNET_MAX_URL_LENGTH; pathW = GetWideString(TEST_URLFROMPATH[i].path); urlW = GetWideString(TEST_URLFROMPATH[i].url); ret = UrlCreateFromPathW(pathW, ret_urlW, &len, 0); WideCharToMultiByte(CP_ACP, 0, ret_urlW, -1, ret_url, sizeof(ret_url),0,0); - ok(ret == TEST_URLFROMPATH[i].ret, "ret %08x from path L"%s", expected %08x\n", + ok(ret == TEST_URLFROMPATH[i].ret, "ret %08lx from path L"%s", expected %08lx\n", ret, TEST_URLFROMPATH[i].path, TEST_URLFROMPATH[i].ret); ok(!lstrcmpiW(ret_urlW, urlW), "got %s expected %s from path L"%s"\n", ret_url, TEST_URLFROMPATH[i].url, TEST_URLFROMPATH[i].path); - ok(len == lstrlenW(ret_urlW), "ret len %d from path L"%s"\n", len, TEST_URLFROMPATH[i].path); + ok(len == lstrlenW(ret_urlW), "ret len %ld from path L"%s"\n", len, TEST_URLFROMPATH[i].path); FreeWideString(urlW); FreeWideString(pathW); } @@ -1356,9 +1356,9 @@ static void test_UrlIs_null(DWORD flag) { BOOL ret; ret = UrlIsA(NULL, flag); - ok(ret == FALSE, "pUrlIsA(NULL, %d) failed\n", flag); + ok(ret == FALSE, "pUrlIsA(NULL, %ld) failed\n", flag); ret = UrlIsW(NULL, flag); - ok(ret == FALSE, "pUrlIsW(NULL, %d) failed\n", flag); + ok(ret == FALSE, "pUrlIsW(NULL, %ld) failed\n", flag); }
static void test_UrlIs(void) @@ -1431,7 +1431,7 @@ static void test_UrlUnescape(void) dwEscaped=INTERNET_MAX_URL_LENGTH; res = UrlUnescapeA(TEST_URL_UNESCAPE[i].url, szReturnUrl, &dwEscaped, 0); ok(res == S_OK, - "UrlUnescapeA returned 0x%x (expected S_OK) for "%s"\n", + "UrlUnescapeA returned 0x%lx (expected S_OK) for "%s"\n", res, TEST_URL_UNESCAPE[i].url); ok(strcmp(szReturnUrl,TEST_URL_UNESCAPE[i].expect)==0, "Expected "%s", but got "%s" from "%s"\n", TEST_URL_UNESCAPE[i].expect, szReturnUrl, TEST_URL_UNESCAPE[i].url);
@@ -1439,7 +1439,7 @@ static void test_UrlUnescape(void) /* if we set the buffer pointer to NULL here, UrlUnescape fails and the string is not converted */ res = UrlUnescapeA(TEST_URL_UNESCAPE[i].url, szReturnUrl, NULL, 0); ok(res == E_INVALIDARG, - "UrlUnescapeA returned 0x%x (expected E_INVALIDARG) for "%s"\n", + "UrlUnescapeA returned 0x%lx (expected E_INVALIDARG) for "%s"\n", res, TEST_URL_UNESCAPE[i].url); ok(strcmp(szReturnUrl,"")==0, "Expected empty string\n");
@@ -1448,7 +1448,7 @@ static void test_UrlUnescape(void) expected_urlW = GetWideString(TEST_URL_UNESCAPE[i].expect); res = UrlUnescapeW(urlW, ret_urlW, &dwEscaped, 0); ok(res == S_OK, - "UrlUnescapeW returned 0x%x (expected S_OK) for "%s"\n", + "UrlUnescapeW returned 0x%lx (expected S_OK) for "%s"\n", res, TEST_URL_UNESCAPE[i].url);
WideCharToMultiByte(CP_ACP,0,ret_urlW,-1,szReturnUrl,INTERNET_MAX_URL_LENGTH,0,0); @@ -1461,23 +1461,23 @@ static void test_UrlUnescape(void)
dwEscaped = sizeof(inplace); res = UrlUnescapeA(inplace, NULL, &dwEscaped, URL_UNESCAPE_INPLACE); - ok(res == S_OK, "UrlUnescapeA returned 0x%x (expected S_OK)\n", res); + ok(res == S_OK, "UrlUnescapeA returned 0x%lx (expected S_OK)\n", res); ok(!strcmp(inplace, expected), "got %s expected %s\n", inplace, expected); - ok(dwEscaped == 27, "got %d expected 27\n", dwEscaped); + ok(dwEscaped == 27, "got %ld expected 27\n", dwEscaped);
/* if we set the buffer pointer to NULL, the string apparently still gets converted (Google Lively does this) */ res = UrlUnescapeA(another_inplace, NULL, NULL, URL_UNESCAPE_INPLACE); - ok(res == S_OK, "UrlUnescapeA returned 0x%x (expected S_OK)\n", res); + ok(res == S_OK, "UrlUnescapeA returned 0x%lx (expected S_OK)\n", res); ok(!strcmp(another_inplace, expected), "got %s expected %s\n", another_inplace, expected);
dwEscaped = sizeof(inplaceW); res = UrlUnescapeW(inplaceW, NULL, &dwEscaped, URL_UNESCAPE_INPLACE); - ok(res == S_OK, "UrlUnescapeW returned 0x%x (expected S_OK)\n", res); - ok(dwEscaped == 50, "got %d expected 50\n", dwEscaped); + ok(res == S_OK, "UrlUnescapeW returned 0x%lx (expected S_OK)\n", res); + ok(dwEscaped == 50, "got %ld expected 50\n", dwEscaped);
/* if we set the buffer pointer to NULL, the string apparently still gets converted (Google Lively does this) */ res = UrlUnescapeW(another_inplaceW, NULL, NULL, URL_UNESCAPE_INPLACE); - ok(res == S_OK, "UrlUnescapeW returned 0x%x (expected S_OK)\n", res); + ok(res == S_OK, "UrlUnescapeW returned 0x%lx (expected S_OK)\n", res);
ok(lstrlenW(another_inplaceW) == 24, "got %d expected 24\n", lstrlenW(another_inplaceW)); } @@ -1518,7 +1518,7 @@ static void test_ParseURL(void) memset(&parseda, 0xd0, sizeof(parseda)); parseda.cbSize = sizeof(parseda); hres = ParseURLA(test->url, &parseda); - ok(hres == test->hres, "ParseURL failed: %08x, expected %08x\n", hres, test->hres); + ok(hres == test->hres, "ParseURL failed: %08lx, expected %08lx\n", hres, test->hres); if(hres == S_OK) { ok(parseda.pszProtocol == test->url, "parseda.pszProtocol = %s, expected %s\n", parseda.pszProtocol, test->url); @@ -1541,7 +1541,7 @@ static void test_ParseURL(void) memset(&parsedw, 0xd0, sizeof(parsedw)); parsedw.cbSize = sizeof(parsedw); hres = ParseURLW(url, &parsedw); - ok(hres == test->hres, "ParseURL failed: %08x, expected %08x\n", hres, test->hres); + ok(hres == test->hres, "ParseURL failed: %08lx, expected %08lx\n", hres, test->hres); if(hres == S_OK) { ok(parsedw.pszProtocol == url, "parsedw.pszProtocol = %s, expected %s\n", wine_dbgstr_w(parsedw.pszProtocol), wine_dbgstr_w(url)); @@ -1582,28 +1582,28 @@ static void test_HashData(void)
/* Test hashing with identically sized input/output buffers. */ res = HashData(input, 16, output, 16); - ok(res == S_OK, "Expected HashData to return S_OK, got 0x%08x\n", res); + ok(res == S_OK, "Expected HashData to return S_OK, got 0x%08lx\n", res); ok(!memcmp(output, expected, sizeof(expected)), "data didn't match\n");
/* Test hashing with larger output buffer. */ res = HashData(input, 16, output, 32); - ok(res == S_OK, "Expected HashData to return S_OK, got 0x%08x\n", res); + ok(res == S_OK, "Expected HashData to return S_OK, got 0x%08lx\n", res); ok(!memcmp(output, expected2, sizeof(expected2)), "data didn't match\n");
/* Test hashing with smaller input buffer. */ res = HashData(input, 8, output, 16); - ok(res == S_OK, "Expected HashData to return S_OK, got 0x%08x\n", res); + ok(res == S_OK, "Expected HashData to return S_OK, got 0x%08lx\n", res); ok(!memcmp(output, expected3, sizeof(expected3)), "data didn't match\n");
/* Test passing NULL pointers for input/output parameters. */ res = HashData(NULL, 0, NULL, 0); - ok(res == E_INVALIDARG, "Got unexpected hr %#x.\n", res); + ok(res == E_INVALIDARG, "Got unexpected hr %#lx.\n", res);
res = HashData(input, 0, NULL, 0); - ok(res == E_INVALIDARG, "Got unexpected hr %#x.\n", res); + ok(res == E_INVALIDARG, "Got unexpected hr %#lx.\n", res);
res = HashData(NULL, 0, output, 0); - ok(res == E_INVALIDARG, "Got unexpected hr %#x.\n", res); + ok(res == E_INVALIDARG, "Got unexpected hr %#lx.\n", res);
/* Test passing valid pointers with sizes of zero. */ for (i = 0; i < ARRAY_SIZE(input); i++) @@ -1613,7 +1613,7 @@ static void test_HashData(void) output[i] = 0xFF;
res = HashData(input, 0, output, 0); - ok(res == S_OK, "Expected HashData to return S_OK, got 0x%08x\n", res); + ok(res == S_OK, "Expected HashData to return S_OK, got 0x%08lx\n", res);
/* The buffers should be unchanged. */ for (i = 0; i < ARRAY_SIZE(input); i++) @@ -1624,12 +1624,12 @@ static void test_HashData(void)
/* Input/output parameters are not validated. */ res = HashData((BYTE *)0xdeadbeef, 0, (BYTE *)0xdeadbeef, 0); - ok(res == S_OK, "Expected HashData to return S_OK, got 0x%08x\n", res); + ok(res == S_OK, "Expected HashData to return S_OK, got 0x%08lx\n", res);
if (0) { res = HashData((BYTE *)0xdeadbeef, 1, (BYTE *)0xdeadbeef, 1); - trace("HashData returned 0x%08x\n", res); + trace("HashData returned 0x%08lx\n", res); } }