[PATCH 3/3] webservices/tests: Build without -DWINE_NO_LONG_TYPES.
Hans Leidekker
hans at codeweavers.com
Tue Feb 15 03:32:50 CST 2022
Signed-off-by: Hans Leidekker <hans at codeweavers.com>
---
dlls/webservices/tests/Makefile.in | 1 -
dlls/webservices/tests/channel.c | 378 ++--
dlls/webservices/tests/msg.c | 502 +++---
dlls/webservices/tests/proxy.c | 118 +-
dlls/webservices/tests/reader.c | 2576 ++++++++++++++--------------
dlls/webservices/tests/url.c | 42 +-
dlls/webservices/tests/writer.c | 1604 ++++++++---------
7 files changed, 2610 insertions(+), 2611 deletions(-)
diff --git a/dlls/webservices/tests/Makefile.in b/dlls/webservices/tests/Makefile.in
index b8a3137c2a5..63e24e66db0 100644
--- a/dlls/webservices/tests/Makefile.in
+++ b/dlls/webservices/tests/Makefile.in
@@ -1,4 +1,3 @@
-EXTRADEFS = -DWINE_NO_LONG_TYPES
TESTDLL = webservices.dll
IMPORTS = webservices oleaut32 ole32 user32 rpcrt4 ws2_32 advapi32
diff --git a/dlls/webservices/tests/channel.c b/dlls/webservices/tests/channel.c
index ed6e9e829bf..64d134bfaab 100644
--- a/dlls/webservices/tests/channel.c
+++ b/dlls/webservices/tests/channel.c
@@ -36,48 +36,48 @@ static void test_WsCreateChannel(void)
ULONG size;
hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, 0, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
channel = NULL;
hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, 0, NULL, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( channel != NULL, "channel not set\n" );
size = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE, &size, sizeof(size), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( size == 65536, "got %u\n", size );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( size == 65536, "got %lu\n", size );
encoding = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_ENCODING, &encoding, sizeof(encoding), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( encoding == WS_ENCODING_XML_UTF8, "got %u\n", encoding );
env_version = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_ENVELOPE_VERSION, &env_version, sizeof(env_version),
NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_2, "got %u\n", env_version );
addr_version = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_ADDRESSING_VERSION, &addr_version, sizeof(addr_version),
NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( addr_version == WS_ADDRESSING_VERSION_1_0, "got %u\n", addr_version );
/* read-only property */
state = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_CHANNEL_STATE_CREATED, "got %u\n", state );
state = WS_CHANNEL_STATE_CREATED;
hr = WsSetChannelProperty( channel, WS_CHANNEL_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
encoding = WS_ENCODING_XML_UTF8;
hr = WsSetChannelProperty( channel, WS_CHANNEL_PROPERTY_ENCODING, &encoding, sizeof(encoding), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeChannel( channel );
encoding = WS_ENCODING_XML_UTF16LE;
@@ -85,30 +85,30 @@ static void test_WsCreateChannel(void)
prop.value = &encoding;
prop.valueSize = sizeof(encoding);
hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, &prop, 1, NULL, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
encoding = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_ENCODING, &encoding, sizeof(encoding), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( encoding == WS_ENCODING_XML_UTF16LE, "got %u\n", encoding );
WsFreeChannel( channel );
hr = WsCreateChannel( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, NULL, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
encoding = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_ENCODING, &encoding, sizeof(encoding), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( encoding == WS_ENCODING_XML_BINARY_SESSION_1, "got %u\n", encoding );
env_version = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_ENVELOPE_VERSION, &env_version, sizeof(env_version),
NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_2, "got %u\n", env_version );
addr_version = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_ADDRESSING_VERSION, &addr_version, sizeof(addr_version),
NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( addr_version == WS_ADDRESSING_VERSION_1_0, "got %u\n", addr_version );
WsFreeChannel( channel );
}
@@ -121,48 +121,48 @@ static void test_WsOpenChannel(void)
WS_ENDPOINT_ADDRESS addr;
hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, 0, NULL, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCloseChannel( channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeChannel( channel );
hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, 0, NULL, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsOpenChannel( channel, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
memset( &addr, 0, sizeof(addr) );
addr.url.length = ARRAY_SIZE( L"http://localhost" ) - 1;
addr.url.chars = (WCHAR *)L"http://localhost";
hr = WsOpenChannel( NULL, &addr, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsOpenChannel( channel, &addr, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_CHANNEL_STATE_OPEN, "got %u\n", state );
hr = WsOpenChannel( channel, &addr, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCloseChannel( channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_CHANNEL_STATE_CLOSED, "got %u\n", state );
hr = WsCloseChannel( channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCloseChannel( NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeChannel( channel );
}
@@ -177,48 +177,48 @@ static void test_WsResetChannel(void)
ULONG size, timeout;
hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, 0, NULL, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsResetChannel( channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
timeout = 5000;
size = sizeof(timeout);
hr = WsSetChannelProperty( channel, WS_CHANNEL_PROPERTY_RESOLVE_TIMEOUT, &timeout, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &addr, 0, sizeof(addr) );
addr.url.length = ARRAY_SIZE( L"http://localhost" ) - 1;
addr.url.chars = (WCHAR *)L"http://localhost";
hr = WsOpenChannel( channel, &addr, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsResetChannel( channel, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCloseChannel( channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsResetChannel( channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
size = sizeof(state);
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_STATE, &state, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_CHANNEL_STATE_CREATED, "got %u\n", state );
type = 0xdeadbeef;
size = sizeof(type);
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_CHANNEL_TYPE, &type, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( type == WS_CHANNEL_TYPE_REQUEST, "got %u\n", type );
timeout = 0xdeadbeef;
size = sizeof(timeout);
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_RESOLVE_TIMEOUT, &timeout, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( timeout == 5000, "got %u\n", timeout );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( timeout == 5000, "got %lu\n", timeout );
WsFreeChannel( channel );
}
@@ -234,49 +234,49 @@ static void test_WsCreateListener(void)
ULONG size, backlog;
hr = WsCreateListener( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
listener = NULL;
hr = WsCreateListener( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, NULL, &listener, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( listener != NULL, "listener not set\n" );
backlog = 1000;
size = sizeof(backlog);
hr = WsSetListenerProperty( listener, WS_LISTENER_PROPERTY_LISTEN_BACKLOG, &backlog, size, NULL );
- todo_wine ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ todo_wine ok( hr == E_INVALIDARG, "got %#lx\n", hr );
version = WS_IP_VERSION_4;
size = sizeof(version);
hr = WsSetListenerProperty( listener, WS_LISTENER_PROPERTY_IP_VERSION, &version, size, NULL );
- todo_wine ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ todo_wine ok( hr == E_INVALIDARG, "got %#lx\n", hr );
type = 0xdeadbeef;
hr = WsGetListenerProperty( listener, WS_LISTENER_PROPERTY_CHANNEL_TYPE, &type, sizeof(type), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( type == WS_CHANNEL_TYPE_DUPLEX_SESSION, "got %u\n", type );
binding = 0xdeadbeef;
hr = WsGetListenerProperty( listener, WS_LISTENER_PROPERTY_CHANNEL_BINDING, &binding, sizeof(binding), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( binding == WS_TCP_CHANNEL_BINDING, "got %u\n", binding );
version = 0;
size = sizeof(version);
hr = WsGetListenerProperty( listener, WS_LISTENER_PROPERTY_IP_VERSION, &version, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
todo_wine ok( version == WS_IP_VERSION_AUTO, "got %u\n", version );
state = 0xdeadbeef;
size = sizeof(state);
hr = WsGetListenerProperty( listener, WS_LISTENER_PROPERTY_STATE, &state, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_LISTENER_STATE_CREATED, "got %u\n", state );
state = WS_LISTENER_STATE_CREATED;
size = sizeof(state);
hr = WsSetListenerProperty( listener, WS_LISTENER_PROPERTY_STATE, &state, size, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeListener( listener );
}
@@ -288,63 +288,63 @@ static void test_WsOpenListener(void)
HRESULT hr;
hr = WsOpenListener( NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateListener( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, NULL, &listener, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCloseListener( listener, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeListener( listener );
hr = WsCreateListener( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, NULL, &listener, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsOpenListener( listener, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
url.length = ARRAY_SIZE( L"net.tcp://+:2017/path" ) - 1;
url.chars = (WCHAR *)L"net.tcp://+:2017/path";
hr = WsOpenListener( NULL, &url, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsOpenListener( listener, &url, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsOpenListener( listener, &url, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCloseListener( listener, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeListener( listener );
hr = WsCreateListener( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, NULL, &listener, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
url.length = ARRAY_SIZE( L"net.tcp://localhost:2017" ) - 1;
url.chars = (WCHAR *)L"net.tcp://localhost:2017";
hr = WsOpenListener( listener, &url, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCloseListener( listener, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeListener( listener );
hr = WsCreateListener( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, NULL, &listener, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
url.length = ARRAY_SIZE( L"net.tcp://127.0.0.1:2017" ) - 1;
url.chars = (WCHAR *)L"net.tcp://127.0.0.1:2017";
hr = WsOpenListener( listener, &url, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCloseListener( listener, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCloseListener( NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeListener( listener );
}
@@ -358,27 +358,27 @@ static void test_WsCreateChannelForListener(void)
HRESULT hr;
hr = WsCreateChannelForListener( NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateChannelForListener( NULL, NULL, 0, &channel, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateListener( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, NULL, &listener, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
channel = NULL;
hr = WsCreateChannelForListener( listener, NULL, 0, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( channel != NULL, "channel not set\n" );
type = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_CHANNEL_TYPE, &type, sizeof(type), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( type == WS_CHANNEL_TYPE_DUPLEX_SESSION, "got %u\n", type );
state = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_CHANNEL_STATE_CREATED, "got %u\n", state );
WsFreeChannel( channel );
@@ -395,40 +395,40 @@ static void test_WsResetListener(void)
HRESULT hr;
hr = WsResetListener( NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
prop.id = WS_LISTENER_PROPERTY_CONNECT_TIMEOUT;
prop.value = &timeout;
prop.valueSize = sizeof(timeout);
hr = WsCreateListener( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, &prop, 1, NULL, &listener, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsResetListener( listener, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsOpenListener( listener, &url, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsResetListener( listener, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCloseListener( listener, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsResetListener( listener, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
size = sizeof(state);
hr = WsGetListenerProperty( listener, WS_LISTENER_PROPERTY_STATE, &state, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_LISTENER_STATE_CREATED, "got %u\n", state );
timeout = 0xdeadbeef;
size = sizeof(timeout);
hr = WsGetListenerProperty( listener, WS_LISTENER_PROPERTY_CONNECT_TIMEOUT, &timeout, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( timeout == 1000, "got %u\n", timeout );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( timeout == 1000, "got %lu\n", timeout );
WsFreeListener( listener );
}
@@ -449,31 +449,31 @@ static void server_message_read_write( WS_CHANNEL *channel )
HRESULT hr;
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadMessageStart( NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadMessageStart( channel, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadMessageStart( NULL, msg, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadMessageStart( channel, msg, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadMessageEnd( NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadMessageEnd( channel, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadMessageEnd( NULL, msg, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadMessageEnd( channel, msg, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeMessage( msg );
}
@@ -487,55 +487,55 @@ static void client_message_read_write( const struct listener_info *info )
DWORD err;
err = WaitForSingleObject( info->ready, 3000 );
- ok( err == WAIT_OBJECT_0, "wait failed %u\n", err );
+ ok( err == WAIT_OBJECT_0, "wait failed %lu\n", err );
hr = WsCreateChannel( info->type, info->binding, NULL, 0, NULL, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &addr, 0, sizeof(addr) );
addr.url.length = wsprintfW( buf, L"soap.udp://localhost:%u", info->port );
addr.url.chars = buf;
hr = WsOpenChannel( channel, &addr, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsShutdownSessionChannel( channel, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteMessageStart( NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteMessageStart( channel, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteMessageStart( NULL, msg, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteMessageStart( channel, msg, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteMessageEnd( NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteMessageEnd( channel, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteMessageEnd( NULL, msg, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteMessageEnd( channel, msg, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
err = WaitForSingleObject( info->done, 3000 );
- ok( err == WAIT_OBJECT_0, "wait failed %u\n", err );
+ ok( err == WAIT_OBJECT_0, "wait failed %lu\n", err );
hr = WsCloseChannel( channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeMessage( msg );
WsFreeChannel( channel );
@@ -551,7 +551,7 @@ static void CALLBACK async_callback( HRESULT hr, WS_CALLBACK_MODEL model, void *
{
struct async_test *test = state;
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( model == WS_LONG_CALLBACK, "got %u\n", model );
test->call_count++;
SetEvent( test->wait );
@@ -570,7 +570,7 @@ static void server_duplex_session( WS_CHANNEL *channel )
HRESULT hr;
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
desc_body.elementLocalName = &localname;
desc_body.elementNs = &ns;
@@ -587,27 +587,27 @@ static void server_duplex_session( WS_CHANNEL *channel )
hr = WsReceiveMessage( channel, msg, desc, 1, WS_RECEIVE_OPTIONAL_MESSAGE, WS_READ_REQUIRED_VALUE,
NULL, &val, sizeof(val), NULL, &ctx, NULL );
- ok( hr == WS_S_ASYNC || hr == S_OK, "got %08x\n", hr );
+ ok( hr == WS_S_ASYNC || hr == S_OK, "got %#lx\n", hr );
if (hr == WS_S_ASYNC)
{
WaitForSingleObject( test.wait, INFINITE );
- ok( test.call_count == 1, "got %u\n", test.call_count );
+ ok( test.call_count == 1, "got %lu\n", test.call_count );
}
- else ok( !test.call_count, "got %u\n", test.call_count );
+ else ok( !test.call_count, "got %lu\n", test.call_count );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
test.call_count = 0;
hr = WsReceiveMessage( channel, msg2, desc, 1, WS_RECEIVE_OPTIONAL_MESSAGE, WS_READ_REQUIRED_VALUE,
NULL, &val, sizeof(val), NULL, &ctx, NULL );
- ok( hr == WS_S_ASYNC || hr == S_OK, "got %08x\n", hr );
+ ok( hr == WS_S_ASYNC || hr == S_OK, "got %#lx\n", hr );
if (hr == WS_S_ASYNC)
{
WaitForSingleObject( test.wait, INFINITE );
- ok( test.call_count == 1, "got %u\n", test.call_count );
+ ok( test.call_count == 1, "got %lu\n", test.call_count );
}
- else ok( !test.call_count, "got %u\n", test.call_count );
+ else ok( !test.call_count, "got %lu\n", test.call_count );
CloseHandle( test.wait );
WsFreeMessage( msg );
@@ -628,22 +628,22 @@ static void client_duplex_session( const struct listener_info *info )
DWORD err;
err = WaitForSingleObject( info->ready, 3000 );
- ok( err == WAIT_OBJECT_0, "wait failed %u\n", err );
+ ok( err == WAIT_OBJECT_0, "wait failed %lu\n", err );
hr = WsCreateChannel( info->type, info->binding, NULL, 0, NULL, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsShutdownSessionChannel( channel, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
memset( &addr, 0, sizeof(addr) );
addr.url.length = wsprintfW( buf, L"net.tcp://localhost:%u", info->port );
addr.url.chars = buf;
hr = WsOpenChannel( channel, &addr, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
desc_body.elementLocalName = &localname;
desc_body.elementNs = &ns;
@@ -653,25 +653,25 @@ static void client_duplex_session( const struct listener_info *info )
desc.bodyElementDescription = &desc_body;
hr = WsSendMessage( channel, msg, &desc, WS_WRITE_REQUIRED_VALUE, &val, sizeof(val), NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSendMessage( channel, msg2, &desc, WS_WRITE_REQUIRED_VALUE, &val, sizeof(val), NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
err = WaitForSingleObject( info->done, 3000 );
- ok( err == WAIT_OBJECT_0, "wait failed %u\n", err );
+ ok( err == WAIT_OBJECT_0, "wait failed %lu\n", err );
hr = WsShutdownSessionChannel( channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsShutdownSessionChannel( channel, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCloseChannel( channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeMessage( msg );
WsFreeMessage( msg2 );
@@ -694,13 +694,13 @@ static void client_duplex_session_async( const struct listener_info *info )
DWORD err;
err = WaitForSingleObject( info->ready, 3000 );
- ok( err == WAIT_OBJECT_0, "wait failed %u\n", err );
+ ok( err == WAIT_OBJECT_0, "wait failed %lu\n", err );
hr = WsCreateChannel( info->type, info->binding, NULL, 0, NULL, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsShutdownSessionChannel( channel, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
test.call_count = 0;
test.wait = CreateEventW( NULL, FALSE, FALSE, NULL );
@@ -711,16 +711,16 @@ static void client_duplex_session_async( const struct listener_info *info )
addr.url.length = wsprintfW( buf, L"net.tcp://localhost:%u", info->port );
addr.url.chars = buf;
hr = WsOpenChannel( channel, &addr, &ctx, NULL );
- ok( hr == WS_S_ASYNC || hr == S_OK, "got %08x\n", hr );
+ ok( hr == WS_S_ASYNC || hr == S_OK, "got %#lx\n", hr );
if (hr == WS_S_ASYNC)
{
WaitForSingleObject( test.wait, INFINITE );
- ok( test.call_count == 1, "got %u\n", test.call_count );
+ ok( test.call_count == 1, "got %lu\n", test.call_count );
}
- else ok( !test.call_count, "got %u\n", test.call_count );
+ else ok( !test.call_count, "got %lu\n", test.call_count );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
desc_body.elementLocalName = &localname;
desc_body.elementNs = &ns;
@@ -732,46 +732,46 @@ static void client_duplex_session_async( const struct listener_info *info )
/* asynchronous call */
test.call_count = 0;
hr = WsSendMessage( channel, msg, &desc, WS_WRITE_REQUIRED_VALUE, &val, sizeof(val), &ctx, NULL );
- ok( hr == WS_S_ASYNC || hr == S_OK, "got %08x\n", hr );
+ ok( hr == WS_S_ASYNC || hr == S_OK, "got %#lx\n", hr );
if (hr == WS_S_ASYNC)
{
WaitForSingleObject( test.wait, INFINITE );
- ok( test.call_count == 1, "got %u\n", test.call_count );
+ ok( test.call_count == 1, "got %lu\n", test.call_count );
}
- else ok( !test.call_count, "got %u\n", test.call_count );
+ else ok( !test.call_count, "got %lu\n", test.call_count );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* synchronous call */
hr = WsSendMessage( channel, msg2, &desc, WS_WRITE_REQUIRED_VALUE, &val, sizeof(val), NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
test.call_count = 0;
hr = WsShutdownSessionChannel( channel, &ctx, NULL );
- ok( hr == WS_S_ASYNC || hr == S_OK, "got %08x\n", hr );
+ ok( hr == WS_S_ASYNC || hr == S_OK, "got %#lx\n", hr );
if (hr == WS_S_ASYNC)
{
WaitForSingleObject( test.wait, INFINITE );
- ok( test.call_count == 1, "got %u\n", test.call_count );
+ ok( test.call_count == 1, "got %lu\n", test.call_count );
}
- else ok( !test.call_count, "got %u\n", test.call_count );
+ else ok( !test.call_count, "got %lu\n", test.call_count );
hr = WsShutdownSessionChannel( channel, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
test.call_count = 0;
hr = WsCloseChannel( channel, &ctx, NULL );
- ok( hr == WS_S_ASYNC || hr == S_OK, "got %08x\n", hr );
+ ok( hr == WS_S_ASYNC || hr == S_OK, "got %#lx\n", hr );
if (hr == WS_S_ASYNC)
{
WaitForSingleObject( test.wait, INFINITE );
- ok( test.call_count == 1, "got %u\n", test.call_count );
+ ok( test.call_count == 1, "got %lu\n", test.call_count );
}
- else ok( !test.call_count, "got %u\n", test.call_count );
+ else ok( !test.call_count, "got %lu\n", test.call_count );
err = WaitForSingleObject( info->done, 3000 );
- ok( err == WAIT_OBJECT_0, "wait failed %u\n", err );
+ ok( err == WAIT_OBJECT_0, "wait failed %lu\n", err );
CloseHandle( test.wait );
WsFreeMessage( msg );
@@ -790,7 +790,7 @@ static void server_accept_channel( WS_CHANNEL *channel )
HRESULT hr;
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
body.elementLocalName = &localname;
body.elementNs = &ns;
@@ -803,7 +803,7 @@ static void server_accept_channel( WS_CHANNEL *channel )
hr = WsReceiveMessage( channel, msg, desc, 1, WS_RECEIVE_REQUIRED_MESSAGE, WS_READ_REQUIRED_VALUE,
NULL, &val, sizeof(val), NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val == -1, "got %d\n", val );
WsFreeMessage( msg );
}
@@ -824,36 +824,36 @@ static void client_accept_channel( const struct listener_info *info )
DWORD err;
err = WaitForSingleObject( info->ready, 3000 );
- ok( err == WAIT_OBJECT_0, "wait failed %u\n", err );
+ ok( err == WAIT_OBJECT_0, "wait failed %lu\n", err );
hr = WsAcceptChannel( NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateListener( info->type, info->binding, NULL, 0, NULL, &listener, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsAcceptChannel( listener, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateChannelForListener( listener, NULL, 0, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsAcceptChannel( listener, channel, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
WsFreeChannel( channel );
WsFreeListener( listener );
hr = WsCreateChannel( info->type, info->binding, NULL, 0, NULL, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &addr, 0, sizeof(addr) );
addr.url.length = wsprintfW( buf, fmt, info->port );
addr.url.chars = buf;
hr = WsOpenChannel( channel, &addr, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
body.elementLocalName = &localname;
body.elementNs = &ns;
@@ -864,13 +864,13 @@ static void client_accept_channel( const struct listener_info *info )
desc.bodyElementDescription = &body;
hr = WsSendMessage( channel, msg, &desc, WS_WRITE_REQUIRED_VALUE, &val, sizeof(val), NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
err = WaitForSingleObject( info->done, 3000 );
- ok( err == WAIT_OBJECT_0, "wait failed %u\n", err );
+ ok( err == WAIT_OBJECT_0, "wait failed %lu\n", err );
hr = WsCloseChannel( channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeMessage( msg );
WsFreeChannel( channel );
@@ -888,7 +888,7 @@ static void server_request_reply( WS_CHANNEL *channel )
HRESULT hr;
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
body.elementLocalName = &localname;
body.elementNs = &ns;
@@ -901,18 +901,18 @@ static void server_request_reply( WS_CHANNEL *channel )
hr = WsReceiveMessage( channel, msg, desc, 1, WS_RECEIVE_REQUIRED_MESSAGE, WS_READ_REQUIRED_VALUE,
NULL, &val, sizeof(val), NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val == -1, "got %d\n", val );
WsFreeMessage( msg );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
out_desc.action = &reply_action;
out_desc.bodyElementDescription = &body;
hr = WsSendMessage( channel, msg, &out_desc, WS_WRITE_REQUIRED_VALUE, &val, sizeof(val), NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeMessage( msg );
}
@@ -931,25 +931,25 @@ static void client_request_reply( const struct listener_info *info )
DWORD err;
err = WaitForSingleObject( info->ready, 3000 );
- ok( err == WAIT_OBJECT_0, "wait failed %u\n", err );
+ ok( err == WAIT_OBJECT_0, "wait failed %lu\n", err );
hr = WsCreateChannel( info->type, info->binding, NULL, 0, NULL, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &addr, 0, sizeof(addr) );
addr.url.length = wsprintfW( buf, L"net.tcp://localhost:%u", info->port );
addr.url.chars = buf;
hr = WsOpenChannel( channel, &addr, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( channel, NULL, 0, &req, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( channel, NULL, 0, &reply, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( req, WS_BLANK_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
body.elementLocalName = &localname;
body.elementNs = &ns;
@@ -967,10 +967,10 @@ static void client_request_reply( const struct listener_info *info )
ok( val_out == -1, "got %d\n", val_out );
err = WaitForSingleObject( info->done, 3000 );
- ok( err == WAIT_OBJECT_0, "wait failed %u\n", err );
+ ok( err == WAIT_OBJECT_0, "wait failed %lu\n", err );
hr = WsCloseChannel( channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeMessage( req );
WsFreeMessage( reply );
@@ -989,24 +989,24 @@ static DWORD CALLBACK listener_proc( void *arg )
HRESULT hr;
hr = WsCreateListener( info->type, info->binding, NULL, 0, NULL, &listener, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
url.length = wsprintfW( buf, fmt, info->port );
url.chars = buf;
hr = WsOpenListener( listener, &url, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateChannelForListener( listener, NULL, 0, &channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
SetEvent( info->ready );
hr = WsAcceptChannel( listener, channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetChannelProperty( channel, WS_CHANNEL_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_CHANNEL_STATE_OPEN, "got %u\n", state );
info->server_func( channel );
@@ -1014,11 +1014,11 @@ static DWORD CALLBACK listener_proc( void *arg )
SetEvent( info->done );
hr = WsCloseChannel( channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeChannel( channel );
hr = WsCloseListener( listener, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeListener( listener );
return 0;
@@ -1027,7 +1027,7 @@ static DWORD CALLBACK listener_proc( void *arg )
static HANDLE start_listener( struct listener_info *info )
{
HANDLE thread = CreateThread( NULL, 0, listener_proc, info, 0, NULL );
- ok( thread != NULL, "failed to create listener thread %u\n", GetLastError() );
+ ok( thread != NULL, "failed to create listener thread %lu\n", GetLastError() );
return thread;
}
@@ -1065,18 +1065,18 @@ static BOOL is_firewall_enabled(void)
hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr,
(void **)&mgr );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (hr != S_OK) goto done;
hr = INetFwMgr_get_LocalPolicy( mgr, &policy );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (hr != S_OK) goto done;
hr = INetFwPolicy_get_CurrentProfile( policy, &profile );
if (hr != S_OK) goto done;
hr = INetFwProfile_get_FirewallEnabled( profile, &enabled );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
done:
if (policy) INetFwPolicy_Release( policy );
@@ -1105,23 +1105,23 @@ static HRESULT set_firewall( enum firewall_op op )
hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr,
(void **)&mgr );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (hr != S_OK) goto done;
hr = INetFwMgr_get_LocalPolicy( mgr, &policy );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (hr != S_OK) goto done;
hr = INetFwPolicy_get_CurrentProfile( policy, &profile );
if (hr != S_OK) goto done;
hr = INetFwProfile_get_AuthorizedApplications( profile, &apps );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (hr != S_OK) goto done;
hr = CoCreateInstance( &CLSID_NetFwAuthorizedApplication, NULL, CLSCTX_INPROC_SERVER,
&IID_INetFwAuthorizedApplication, (void **)&app );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (hr != S_OK) goto done;
hr = INetFwAuthorizedApplication_put_ProcessImageFileName( app, image );
@@ -1130,7 +1130,7 @@ static HRESULT set_firewall( enum firewall_op op )
name = SysAllocString( L"webservices_test" );
hr = INetFwAuthorizedApplication_put_Name( app, name );
SysFreeString( name );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (hr != S_OK) goto done;
if (op == APP_ADD)
@@ -1184,7 +1184,7 @@ START_TEST(channel)
}
if ((hr = set_firewall( APP_ADD )) != S_OK)
{
- skip( "can't authorize app in firewall %08x\n", hr );
+ skip( "can't authorize app in firewall %#lx\n", hr );
return;
}
}
diff --git a/dlls/webservices/tests/msg.c b/dlls/webservices/tests/msg.c
index 5a5af55e5d8..3c741c48ce3 100644
--- a/dlls/webservices/tests/msg.c
+++ b/dlls/webservices/tests/msg.c
@@ -31,16 +31,16 @@ static void test_WsCreateMessage(void)
WS_MESSAGE_PROPERTY prop;
hr = WsCreateMessage( 0, 0, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( 0, 0, NULL, 0, &msg, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, 0, NULL, 0, &msg, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( 0, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
env_version = WS_ENVELOPE_VERSION_SOAP_1_1;
prop.id = WS_MESSAGE_PROPERTY_ENVELOPE_VERSION;
@@ -48,42 +48,42 @@ static void test_WsCreateMessage(void)
prop.valueSize = sizeof(env_version);
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, &prop,
1, &msg, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL,
0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_EMPTY, "got %u\n", state );
env_version = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
sizeof(env_version), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_1, "got %u\n", env_version );
addr_version = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
sizeof(addr_version), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( addr_version == WS_ADDRESSING_VERSION_0_9, "got %u\n", addr_version );
state = WS_MESSAGE_STATE_EMPTY;
hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
env_version = WS_ENVELOPE_VERSION_SOAP_1_1;
hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
sizeof(env_version), NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
addr_version = WS_ADDRESSING_VERSION_0_9;
hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
sizeof(addr_version), NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
WsFreeMessage( msg );
}
@@ -99,39 +99,39 @@ static void test_WsCreateMessageForChannel(void)
BOOL addressed;
hr = WsCreateMessageForChannel( NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( NULL, NULL, 0, &msg, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
/* HTTP */
hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, 0, NULL,
&channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_EMPTY, "got %u\n", state );
env_version = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
sizeof(env_version), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_2, "got %u\n", env_version );
addr_version = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
sizeof(addr_version), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( addr_version == WS_ADDRESSING_VERSION_1_0, "got %u\n", addr_version );
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
WsFreeChannel( channel );
WsFreeMessage( msg );
@@ -142,15 +142,15 @@ static void test_WsCreateMessageForChannel(void)
prop.valueSize = sizeof(env_version);
hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, &prop, 1, NULL,
&channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
env_version = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
sizeof(env_version), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_1, "got %u\n", env_version );
WsFreeChannel( channel );
@@ -159,26 +159,26 @@ static void test_WsCreateMessageForChannel(void)
/* TCP */
hr = WsCreateChannel( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, NULL,
&channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_EMPTY, "got %u\n", state );
env_version = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
sizeof(env_version), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_2, "got %u\n", env_version );
addr_version = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
sizeof(addr_version), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( addr_version == WS_ADDRESSING_VERSION_1_0, "got %u\n", addr_version );
WsFreeChannel( channel );
@@ -187,21 +187,21 @@ static void test_WsCreateMessageForChannel(void)
/* UDP */
hr = WsCreateChannel( WS_CHANNEL_TYPE_DUPLEX, WS_UDP_CHANNEL_BINDING, NULL, 0, NULL,
&channel, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
env_version = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
sizeof(env_version), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_2, "got %u\n", env_version );
addr_version = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
sizeof(addr_version), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( addr_version == WS_ADDRESSING_VERSION_1_0, "got %u\n", addr_version );
WsFreeChannel( channel );
@@ -218,45 +218,45 @@ static void test_WsInitializeMessage(void)
BOOL addressed;
hr = WsInitializeMessage( NULL, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL,
0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, 0xdeadbeef, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_INITIALIZED, "got %u\n", state );
addressed = -1;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( !addressed, "unexpected value %d\n", addressed );
state = WS_MESSAGE_STATE_EMPTY;
hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
env_version = WS_ENVELOPE_VERSION_SOAP_1_1;
hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
sizeof(env_version), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
addr_version = WS_ADDRESSING_VERSION_0_9;
hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
sizeof(addr_version), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeMessage( msg );
}
@@ -268,55 +268,55 @@ static void test_WsAddressMessage(void)
BOOL addressed;
hr = WsAddressMessage( NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL,
0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsAddressMessage( msg, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
addressed = -1;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( !addressed, "unexpected value %d\n", addressed );
hr = WsAddressMessage( msg, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
addressed = -1;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( addressed == TRUE, "unexpected value %d\n", addressed );
WsFreeMessage( msg );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL,
0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &endpoint, 0, sizeof(endpoint) );
endpoint.url.chars = (WCHAR *)L"http://localhost/";
endpoint.url.length = ARRAY_SIZE( L"http://localhost/" ) - 1;
hr = WsAddressMessage( msg, &endpoint, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
addressed = -1;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( addressed == TRUE, "unexpected value %d\n", addressed );
WsFreeMessage( msg );
}
@@ -337,8 +337,8 @@ static void check_output( WS_XML_WRITER *writer, const char *expected, int len,
if (len == -1) len = strlen( expected );
memset( &bytes, 0, sizeof(bytes) );
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, sizeof(bytes), NULL );
- ok( hr == S_OK, "%u: got %08x\n", line, hr );
- ok( bytes.length == len, "%u: got %u expected %u\n", line, bytes.length, len );
+ ok( hr == S_OK, "%u: got %#lx\n", line, hr );
+ ok( bytes.length == len, "%u: got %lu expected %d\n", line, bytes.length, len );
if (bytes.length != len) return;
if (skip_start)
{
@@ -360,16 +360,16 @@ static void check_output_header( WS_MESSAGE *msg, const char *expected, int len,
HRESULT hr;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_HEADER_BUFFER, &buf, sizeof(buf), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteXmlBuffer( writer, buf, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, expected, len, skip_start, skip_len, line );
WsFreeWriter( writer );
@@ -414,111 +414,111 @@ static void test_WsWriteEnvelopeStart(void)
WS_MESSAGE_STATE state;
hr = WsWriteEnvelopeStart( NULL, NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeStart( NULL, writer, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_WRITING, "got %u\n", state );
WsFreeMessage( msg );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected3, -1, 0, 0, __LINE__ );
WsFreeMessage( msg );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_NONE, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected4, -1, 0, 0, __LINE__ );
WsFreeMessage( msg );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected5, -1, strstr(expected5, "urn:uuid:") - expected5, 46, __LINE__ );
WsFreeMessage( msg );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected6, -1, 0, 0, __LINE__ );
WsFreeMessage( msg );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected7, -1, strstr(expected7, "urn:uuid:") - expected7, 46, __LINE__ );
WsFreeMessage( msg );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_BLANK_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected8, -1, 0, 0, __LINE__ );
WsFreeMessage( msg );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeMessage( msg );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_NONE, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_NONE, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeWriter( writer );
}
@@ -535,38 +535,38 @@ static void test_WsWriteEnvelopeEnd(void)
WS_MESSAGE_STATE state;
hr = WsWriteEnvelopeEnd( NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg,
NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeEnd( msg, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeEnd( msg, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeEnd( msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_DONE, "got %u\n", state );
WsFreeMessage( msg );
@@ -601,25 +601,25 @@ static void test_WsWriteBody(void)
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg,
NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteBody( NULL, NULL, 0, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteBody( msg, NULL, 0, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_ELEMENT_FIELD_MAPPING;
@@ -644,22 +644,22 @@ static void test_WsWriteBody(void)
ptr = &test;
test.val = 1;
hr = WsWriteBody( msg, &desc, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, expected, 240, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_WRITING, "got %u\n", state );
hr = WsWriteEnvelopeEnd( msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
hr = WsWriteBody( msg, &desc, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
WsFreeMessage( msg );
WsFreeWriter( writer );
@@ -686,45 +686,45 @@ static void test_WsSetHeader(void)
const WCHAR *ptr = L"action";
hr = WsSetHeader( NULL, 0, 0, 0, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg,
NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetHeader( msg, 0, 0, 0, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr,
sizeof(ptr), NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetHeader( msg, 0, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr,
sizeof(ptr), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, expected, 250, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
/* called after WsWriteEnvelopeStart */
hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &action2,
sizeof(action2), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, expected, 250, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
@@ -750,44 +750,44 @@ static void test_WsRemoveHeader(void)
WS_MESSAGE *msg;
hr = WsSetHeader( NULL, 0, 0, 0, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg,
NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsRemoveHeader( NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsRemoveHeader( msg, 0, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsRemoveHeader( msg, WS_ACTION_HEADER, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
hr = WsRemoveHeader( msg, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsRemoveHeader( msg, WS_ACTION_HEADER, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &action,
sizeof(action), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
hr = WsRemoveHeader( msg, WS_ACTION_HEADER, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
/* again */
hr = WsRemoveHeader( msg, WS_ACTION_HEADER, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
WsFreeMessage( msg );
@@ -800,29 +800,29 @@ static void test_WsAddMappedHeader(void)
HRESULT hr;
hr = WsAddMappedHeader( NULL, NULL, 0, 0, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsAddMappedHeader( msg, NULL, 0, 0, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsAddMappedHeader( msg, &header, 0, 0, NULL, 0, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* again */
hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeMessage( msg );
}
@@ -834,29 +834,29 @@ static void test_WsRemoveMappedHeader(void)
HRESULT hr;
hr = WsRemoveMappedHeader( NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsRemoveMappedHeader( msg, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsRemoveMappedHeader( msg, &header, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsRemoveMappedHeader( msg, &header, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* again */
hr = WsRemoveMappedHeader( msg, &header, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeMessage( msg );
}
@@ -898,13 +898,13 @@ static void test_WsAddCustomHeader(void)
} test;
hr = WsAddCustomHeader( NULL, NULL, 0, NULL, 0, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsAddCustomHeader( msg, NULL, 0, NULL, 0, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_TEXT_FIELD_MAPPING;
@@ -922,29 +922,29 @@ static void test_WsAddCustomHeader(void)
desc.type = WS_STRUCT_TYPE;
desc.typeDescription = &s;
hr = WsAddCustomHeader( msg, &desc, 0, NULL, 0, 0, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
test.value = L"value";
hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
test.value = L"value2";
hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected3, -1, strstr(expected3, "urn:uuid:") - expected3, 46, __LINE__ );
desc.elementLocalName = &header2;
hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected4, -1, strstr(expected4, "urn:uuid:") - expected4, 46, __LINE__ );
hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, NULL, 0, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeMessage( msg );
}
@@ -975,16 +975,16 @@ static void test_WsRemoveCustomHeader(void)
WS_ELEMENT_DESCRIPTION desc;
hr = WsRemoveCustomHeader( NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsRemoveCustomHeader( msg, &localname, &ns, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
desc.elementLocalName = &localname;
@@ -992,26 +992,26 @@ static void test_WsRemoveCustomHeader(void)
desc.type = WS_XML_STRING_TYPE;
desc.typeDescription = NULL;
hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &value2, sizeof(value2), 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected3, -1, strstr(expected3, "urn:uuid:") - expected3, 46, __LINE__ );
hr = WsRemoveCustomHeader( msg, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsRemoveCustomHeader( msg, &localname, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsRemoveCustomHeader( msg, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
/* again */
hr = WsRemoveCustomHeader( msg, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeMessage( msg );
}
@@ -1038,53 +1038,53 @@ static void test_WsReadEnvelopeStart(void)
HRESULT hr;
hr = WsReadEnvelopeStart( NULL, NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadEnvelopeStart( msg, NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadEnvelopeStart( msg, reader, NULL, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, xml, strlen(xml) );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadEnvelopeStart( msg2, reader, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg2, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_READING, "got %u\n", state );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadEndElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadEndElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
WsFreeMessage( msg );
@@ -1102,35 +1102,35 @@ static void test_WsReadEnvelopeEnd(void)
HRESULT hr;
hr = WsReadEnvelopeEnd( NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, xml, strlen(xml) );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadEnvelopeEnd( msg2, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsReadEnvelopeStart( msg2, reader, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadEnvelopeEnd( msg2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg2, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_DONE, "got %u\n", state );
WsFreeMessage( msg );
@@ -1159,34 +1159,34 @@ static void test_WsReadBody(void)
HRESULT hr;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadBody( NULL, NULL, 0, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadBody( msg2, NULL, 0, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_input( reader, xml, strlen(xml) );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadEnvelopeStart( msg2, reader, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadBody( msg2, NULL, WS_READ_REQUIRED_VALUE, heap, &test, sizeof(test), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_ELEMENT_FIELD_MAPPING;
@@ -1210,16 +1210,16 @@ static void test_WsReadBody(void)
memset( &test, 0, sizeof(test) );
hr = WsReadBody( msg2, &desc, WS_READ_REQUIRED_VALUE, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test.val == 1, "got %u\n", test.val );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg2, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_READING, "got %u\n", state );
hr = WsReadEnvelopeEnd( msg2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeMessage( msg );
WsFreeMessage( msg2 );
@@ -1236,39 +1236,39 @@ static void test_WsResetMessage(void)
HRESULT hr;
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_EMPTY, "got %u\n", state );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_INITIALIZED, "got %u\n", state );
hr = WsResetMessage( msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_MESSAGE_STATE_EMPTY, "got %u\n", state );
env_version = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
sizeof(env_version), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_1, "got %u\n", env_version );
addr_version = 0xdeadbeef;
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
sizeof(addr_version), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( addr_version == WS_ADDRESSING_VERSION_0_9, "got %u\n", addr_version );
WsFreeMessage( msg );
@@ -1295,83 +1295,83 @@ static void test_WsGetHeader(void)
HRESULT hr;
hr = WsGetHeader( NULL, 0, 0, 0, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetHeader( msg, 0, 0, 0, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetHeader( msg, 0, 0, 0, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetHeader( msg, WS_ACTION_HEADER, 0, 0, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, 0, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_NILLABLE_POINTER, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_REQUIRED_POINTER, NULL, NULL, 0, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
ptr = L"action";
hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_REQUIRED_POINTER, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
ptr = NULL;
hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_REQUIRED_POINTER, NULL, &ptr, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
ptr = NULL;
hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_REQUIRED_POINTER, NULL, &ptr, sizeof(ptr), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( ptr != NULL, "ptr not set\n" );
ok( !memcmp( ptr, L"action", sizeof(L"action") ), "wrong data\n" );
WsFreeMessage( msg );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_NONE, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ptr = L"action";
hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (hr == S_OK) check_output_header( msg, expected2, -1, 0, 0, __LINE__ );
ptr = NULL;
hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_REQUIRED_POINTER, NULL, &ptr, sizeof(ptr), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( ptr != NULL, "ptr not set\n" );
ok( !memcmp( ptr, L"action", sizeof(L"action") ), "wrong data\n" );
WsFreeMessage( msg );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ptr = L"action";
hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (hr == S_OK) check_output_header( msg, expected3, -1, 0, 0, __LINE__ );
ptr = NULL;
hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_REQUIRED_POINTER, NULL, &ptr, sizeof(ptr), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( ptr != NULL, "ptr not set\n" );
ok( !memcmp( ptr, L"action", sizeof(L"action") ), "wrong data\n" );
WsFreeMessage( msg );
@@ -1393,16 +1393,16 @@ static void test_WsGetCustomHeader(void)
} test;
hr = WsGetCustomHeader( NULL, NULL, 0, 0, 0, NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateMessage( WS_ENVELOPE_VERSION_NONE, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetCustomHeader( msg, NULL, 0, 0, 0, NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_TEXT_FIELD_MAPPING;
@@ -1422,22 +1422,22 @@ static void test_WsGetCustomHeader(void)
test.value = L"value";
hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_header( msg, expected, -1, 0, 0, __LINE__ );
hr = WsGetCustomHeader( msg, &desc, 0, 0, 0, NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetCustomHeader( msg, &desc, WS_SINGLETON_HEADER, 1, 0, NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetCustomHeader( msg, &desc, WS_SINGLETON_HEADER, 0, WS_READ_REQUIRED_VALUE, NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
memset( &test, 0, sizeof(test) );
hr = WsGetCustomHeader( msg, &desc, WS_SINGLETON_HEADER, 0, WS_READ_REQUIRED_VALUE, NULL, &test, sizeof(test),
NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test.value != NULL, "value not set\n" );
ok( !memcmp( test.value, L"value", sizeof(L"value") ), "wrong value\n" );
WsFreeMessage( msg );
diff --git a/dlls/webservices/tests/proxy.c b/dlls/webservices/tests/proxy.c
index e2c6c87b830..9d6292be4c9 100644
--- a/dlls/webservices/tests/proxy.c
+++ b/dlls/webservices/tests/proxy.c
@@ -99,22 +99,22 @@ static void test_WsCreateServiceProxy(void)
hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, NULL,
0, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
proxy = NULL;
hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, NULL,
0, NULL, 0, &proxy, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( proxy != NULL, "proxy not set\n" );
/* write-only property */
value = 0xdeadbeef;
hr = WsGetServiceProxyProperty( proxy, WS_PROXY_PROPERTY_CALL_TIMEOUT, &value, sizeof(value), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetServiceProxyProperty( proxy, WS_PROXY_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_SERVICE_PROXY_STATE_CREATED, "got %u\n", state );
WsFreeServiceProxy( proxy );
@@ -128,17 +128,17 @@ static void test_WsCreateServiceProxyFromTemplate(void)
hr = WsCreateServiceProxyFromTemplate( WS_CHANNEL_TYPE_REQUEST, NULL, 0, WS_HTTP_BINDING_TEMPLATE_TYPE,
NULL, 0, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateServiceProxyFromTemplate( WS_CHANNEL_TYPE_REQUEST, NULL, 0, WS_HTTP_BINDING_TEMPLATE_TYPE,
NULL, 0, NULL, 0, &proxy, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
memset( &policy, 0, sizeof(policy) );
proxy = NULL;
hr = WsCreateServiceProxyFromTemplate( WS_CHANNEL_TYPE_REQUEST, NULL, 0, WS_HTTP_BINDING_TEMPLATE_TYPE,
NULL, 0, &policy, sizeof(policy), &proxy, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( proxy != NULL, "proxy not set\n" );
WsFreeServiceProxy( proxy );
@@ -155,30 +155,30 @@ static void test_WsOpenServiceProxy(void)
memset( &policy, 0, sizeof(policy) );
hr = WsCreateServiceProxyFromTemplate( WS_CHANNEL_TYPE_REQUEST, NULL, 0, WS_HTTP_BINDING_TEMPLATE_TYPE,
NULL, 0, &policy, sizeof(policy), &proxy, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetServiceProxyProperty( proxy, WS_PROXY_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_SERVICE_PROXY_STATE_CREATED, "got %u\n", state );
memset( &addr, 0, sizeof(addr) );
addr.url.length = ARRAY_SIZE( L"http://localhost/" ) - 1;
addr.url.chars = (WCHAR *)L"http://localhost/";
hr = WsOpenServiceProxy( proxy, &addr, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetServiceProxyProperty( proxy, WS_PROXY_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_SERVICE_PROXY_STATE_OPEN, "got %u\n", state );
hr = WsCloseServiceProxy( proxy , NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetServiceProxyProperty( proxy, WS_PROXY_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_SERVICE_PROXY_STATE_CLOSED, "got %u\n", state );
WsFreeServiceProxy( proxy );
@@ -193,34 +193,34 @@ static void test_WsResetServiceProxy(void)
hr = WsCreateServiceProxy( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, NULL,
0, NULL, 0, &proxy, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsResetServiceProxy( proxy, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetServiceProxyProperty( proxy, WS_PROXY_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_SERVICE_PROXY_STATE_CREATED, "got %u\n", state );
memset( &addr, 0, sizeof(addr) );
addr.url.length = ARRAY_SIZE( L"http://localhost/" ) - 1;
addr.url.chars = (WCHAR *)L"http://localhost/";
hr = WsOpenServiceProxy( proxy, &addr, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsResetServiceProxy( proxy, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCloseServiceProxy( proxy , NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsResetServiceProxy( proxy, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
state = 0xdeadbeef;
hr = WsGetServiceProxyProperty( proxy, WS_PROXY_PROPERTY_STATE, &state, sizeof(state), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( state == WS_SERVICE_PROXY_STATE_CREATED, "got %u\n", state );
WsFreeServiceProxy( proxy );
@@ -278,27 +278,27 @@ static void test_WsSendMessage( int port, WS_XML_STRING *action )
HRESULT hr;
hr = create_channel( port, &channel );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
set_elem_desc( &body, &req, &ns, WS_INT32_TYPE, NULL );
set_msg_desc( &desc, action, &body );
hr = WsSendMessage( NULL, msg, &desc, WS_WRITE_REQUIRED_VALUE, &val, sizeof(val), NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsSendMessage( channel, NULL, &desc, WS_WRITE_REQUIRED_VALUE, &val, sizeof(val), NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsSendMessage( channel, msg, NULL, WS_WRITE_REQUIRED_VALUE, &val, sizeof(val), NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsSendMessage( channel, msg, &desc, WS_WRITE_REQUIRED_VALUE, &val, sizeof(val), NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCloseChannel( channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeChannel( channel );
WsFreeMessage( msg );
@@ -316,42 +316,42 @@ static void test_WsReceiveMessage( int port )
HRESULT hr;
hr = create_channel( port, &channel );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
set_elem_desc( &body, &req, &ns, WS_INT32_TYPE, NULL );
set_msg_desc( &desc_req, &req, &body );
hr = WsSendMessage( channel, msg, &desc_req, WS_WRITE_REQUIRED_VALUE, &val, sizeof(val), NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeMessage( msg );
hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
set_elem_desc( &body, &resp, &ns, WS_INT32_TYPE, NULL );
set_msg_desc( &desc_resp, &resp, &body );
desc[0] = &desc_resp;
hr = WsReceiveMessage( NULL, msg, desc, 1, WS_RECEIVE_REQUIRED_MESSAGE, WS_READ_REQUIRED_VALUE,
NULL, &val, sizeof(val), NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReceiveMessage( channel, NULL, desc, 1, WS_RECEIVE_REQUIRED_MESSAGE, WS_READ_REQUIRED_VALUE,
NULL, &val, sizeof(val), NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReceiveMessage( channel, msg, NULL, 1, WS_RECEIVE_REQUIRED_MESSAGE, WS_READ_REQUIRED_VALUE,
NULL, &val, sizeof(val), NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReceiveMessage( channel, msg, desc, 1, WS_RECEIVE_REQUIRED_MESSAGE, WS_READ_REQUIRED_VALUE,
NULL, &val, sizeof(val), NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val == -2, "got %d\n", val );
hr = WsCloseChannel( channel, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeChannel( channel );
WsFreeMessage( msg );
@@ -438,20 +438,20 @@ static void check_output_headers( WS_MESSAGE *msg )
HRESULT hr;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_HEADER_BUFFER, &buf, sizeof(buf), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteXmlBuffer( writer, buf, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &bytes, 0, sizeof(bytes) );
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, sizeof(bytes), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeWriter( writer );
}
@@ -471,7 +471,7 @@ static HRESULT CALLBACK send_callback( WS_MESSAGE *msg, WS_HEAP *heap, void *sta
HRESULT hr;
hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_headers( msg );
return S_OK;
}
@@ -485,7 +485,7 @@ static HRESULT CALLBACK recv_callback( WS_MESSAGE *msg, WS_HEAP *heap, void *sta
check_output_headers( msg );
hr = WsGetMappedHeader( msg, &header, WS_SINGLETON_HEADER, 0, WS_WSZ_TYPE, WS_READ_OPTIONAL_POINTER, heap,
&str, sizeof(str), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( !wcscmp(str, L"value"), "wrong value %s\n", wine_dbgstr_w(str) );
return S_OK;
}
@@ -532,16 +532,16 @@ static void test_WsCall( int port )
} out;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCall( NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = create_proxy( port, &proxy );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCall( proxy, NULL, NULL, NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
set_field_desc( &f, WS_ELEMENT_FIELD_MAPPING, &val, &ns, WS_INT32_TYPE, NULL, 0, 0, 0, NULL, NULL );
set_field_desc( &f4, WS_REPEATING_ELEMENT_FIELD_MAPPING, NULL, NULL, WS_WSZ_TYPE, NULL,
@@ -573,7 +573,7 @@ static void test_WsCall( int port )
set_op_desc( &op, &input_msg, &output_msg, 6, param );
hr = WsCall( proxy, &op, NULL, NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
in.val = 1;
str_array[0] = L"test";
@@ -611,14 +611,14 @@ static void test_WsCall( int port )
prop[1].valueSize = sizeof(ctx_recv);
hr = WsCall( proxy, &op, args, heap, prop, ARRAY_SIZE(prop), NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( !wcscmp( out.str, L"test" ), "wrong data\n" );
- ok( out.count == 2, "got %u\n", out.count );
+ ok( out.count == 2, "got %lu\n", out.count );
ok( out.val[0] == 1, "got %u\n", out.val[0] );
ok( out.val[1] == 2, "got %u\n", out.val[1] );
hr = WsCloseServiceProxy( proxy, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeServiceProxy( proxy );
WsFreeHeap( heap );
@@ -659,10 +659,10 @@ static void test_empty_response( int port )
} in;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = create_proxy( port, &proxy );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
set_field_desc( &f, WS_ELEMENT_FIELD_MAPPING, &val, &ns, WS_INT32_TYPE, NULL, 0, 0, 0, NULL, NULL );
fields[0] = &f;
@@ -681,14 +681,14 @@ static void test_empty_response( int port )
in.val = 1;
args[0] = &in.val;
hr = WsCall( proxy, &op, args, heap, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
set_elem_desc( &output_elem, &resp_elem, &ns, WS_STRUCT_TYPE, &output_struct );
hr = WsCall( proxy, &op, args, heap, NULL, 0, NULL, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = WsCloseServiceProxy( proxy, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeServiceProxy( proxy );
WsFreeHeap( heap );
@@ -829,10 +829,10 @@ START_TEST(proxy)
info.port = 7533;
info.event = CreateEventW( NULL, 0, 0, NULL );
thread = CreateThread( NULL, 0, server_proc, &info, 0, NULL );
- ok( thread != NULL, "failed to create server thread %u\n", GetLastError() );
+ ok( thread != NULL, "failed to create server thread %lu\n", GetLastError() );
ret = WaitForSingleObject( info.event, 3000 );
- ok(ret == WAIT_OBJECT_0, "failed to start test server %u\n", GetLastError());
+ ok(ret == WAIT_OBJECT_0, "failed to start test server %lu\n", GetLastError());
if (ret != WAIT_OBJECT_0)
{
CloseHandle(thread);
diff --git a/dlls/webservices/tests/reader.c b/dlls/webservices/tests/reader.c
index 7ecb77fe6cd..eacde56928d 100644
--- a/dlls/webservices/tests/reader.c
+++ b/dlls/webservices/tests/reader.c
@@ -76,50 +76,50 @@ static void test_WsCreateError(void)
LANGID langid;
hr = WsCreateError( NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
error = NULL;
hr = WsCreateError( NULL, 0, &error );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( error != NULL, "error not set\n" );
count = 0xdeadbeef;
size = sizeof(count);
hr = WsGetErrorProperty( error, WS_ERROR_PROPERTY_STRING_COUNT, &count, size );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
hr = WsSetErrorProperty( error, WS_ERROR_PROPERTY_STRING_COUNT, &count, size );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
code = 0xdeadbeef;
size = sizeof(code);
hr = WsGetErrorProperty( error, WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE, &code, size );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !code, "got %u\n", code );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !code, "got %lu\n", code );
code = 0xdeadbeef;
hr = WsSetErrorProperty( error, WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE, &code, size );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetErrorProperty( error, WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE, &code, size );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( code == 0xdeadbeef, "got %u\n", code );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( code == 0xdeadbeef, "got %lu\n", code );
langid = 0xdead;
size = sizeof(langid);
hr = WsGetErrorProperty( error, WS_ERROR_PROPERTY_LANGID, &langid, size );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( langid == GetUserDefaultUILanguage(), "got %u\n", langid );
langid = MAKELANGID( LANG_DUTCH, SUBLANG_DEFAULT );
hr = WsSetErrorProperty( error, WS_ERROR_PROPERTY_LANGID, &langid, size );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
count = 0xdeadbeef;
size = sizeof(count);
hr = WsGetErrorProperty( error, WS_ERROR_PROPERTY_LANGID + 1, &count, size );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
- ok( count == 0xdeadbeef, "got %u\n", count );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
+ ok( count == 0xdeadbeef, "got %lu\n", count );
WsFreeError( error );
count = 1;
@@ -127,26 +127,26 @@ static void test_WsCreateError(void)
prop.value = &count;
prop.valueSize = sizeof(count);
hr = WsCreateError( &prop, 1, &error );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
code = 0xdeadbeef;
prop.id = WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE;
prop.value = &code;
prop.valueSize = sizeof(code);
hr = WsCreateError( &prop, 1, &error );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
langid = MAKELANGID( LANG_DUTCH, SUBLANG_DEFAULT );
prop.id = WS_ERROR_PROPERTY_LANGID;
prop.value = &langid;
prop.valueSize = sizeof(langid);
hr = WsCreateError( &prop, 1, &error );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
langid = 0xdead;
size = sizeof(langid);
hr = WsGetErrorProperty( error, WS_ERROR_PROPERTY_LANGID, &langid, size );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( langid == MAKELANGID( LANG_DUTCH, SUBLANG_DEFAULT ), "got %u\n", langid );
WsFreeError( error );
@@ -155,7 +155,7 @@ static void test_WsCreateError(void)
prop.value = &count;
prop.valueSize = sizeof(count);
hr = WsCreateError( &prop, 1, &error );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
}
static void test_WsCreateHeap(void)
@@ -167,55 +167,55 @@ static void test_WsCreateHeap(void)
ULONG size;
hr = WsCreateHeap( 0, 0, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
heap = NULL;
hr = WsCreateHeap( 0, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( heap != NULL, "heap not set\n" );
WsFreeHeap( heap );
hr = WsCreateHeap( 1 << 16, 1 << 6, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
heap = NULL;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( heap != NULL, "heap not set\n" );
WsFreeHeap( heap );
hr = WsCreateHeap( 1 << 16, 1 << 6, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
max = 0xdeadbeef;
size = sizeof(max);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_MAX_SIZE, &max, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max == 1 << 16, "got %u\n", (ULONG)max );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max == 1 << 16, "got %Iu\n", max );
trim = 0xdeadbeef;
size = sizeof(trim);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_TRIM_SIZE, &trim, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( trim == 1 << 6, "got %u\n", (ULONG)trim );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( trim == 1 << 6, "got %Iu\n", trim );
requested = 0xdeadbeef;
size = sizeof(requested);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_REQUESTED_SIZE, &requested, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !requested, "got %u\n", (ULONG)requested );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !requested, "got %Iu\n", requested );
actual = 0xdeadbeef;
size = sizeof(actual);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_ACTUAL_SIZE, &actual, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !actual, "got %u\n", (ULONG)actual );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !actual, "got %Iu\n", actual );
actual = 0xdeadbeef;
size = sizeof(actual);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_ACTUAL_SIZE + 1, &actual, size, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
- ok( actual == 0xdeadbeef, "got %u\n", (ULONG)actual );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
+ ok( actual == 0xdeadbeef, "got %Iu\n", actual );
WsFreeHeap( heap );
max = 1 << 16;
@@ -223,10 +223,10 @@ static void test_WsCreateHeap(void)
prop.value = &max;
prop.valueSize = sizeof(max);
hr = WsCreateHeap( 1 << 16, 1 << 6, &prop, 1, &heap, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 16, 1 << 6, NULL, 1, &heap, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
}
static HRESULT set_input( WS_XML_READER *reader, const char *data, ULONG size )
@@ -251,81 +251,81 @@ static void test_WsCreateReader(void)
WS_CHARSET charset;
hr = WsCreateReader( NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
reader = NULL;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( reader != NULL, "reader not set\n" );
/* can't retrieve properties before input is set */
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
ok( max_depth == 0xdeadbeef, "max_depth set\n" );
hr = set_input( reader, data1, sizeof(data1) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* check some defaults */
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_depth == 32, "got %u\n", max_depth );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_depth == 32, "got %lu\n", max_depth );
allow_fragment = TRUE;
size = sizeof(allow_fragment);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_ALLOW_FRAGMENT, &allow_fragment, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( !allow_fragment, "got %d\n", allow_fragment );
max_attrs = 0xdeadbeef;
size = sizeof(max_attrs);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_MAX_ATTRIBUTES, &max_attrs, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_attrs == 128, "got %u\n", max_attrs );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_attrs == 128, "got %lu\n", max_attrs );
read_decl = FALSE;
size = sizeof(read_decl);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_READ_DECLARATION, &read_decl, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( read_decl, "got %u\n", read_decl );
charset = 0xdeadbeef;
size = sizeof(charset);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_CHARSET, &charset, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( charset == WS_CHARSET_UTF8, "got %u\n", charset );
size = sizeof(trim_size);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE, &trim_size, size, NULL );
- todo_wine ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ todo_wine ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeReader( reader );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, data1, sizeof(data1) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
size = sizeof(buffer_size);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE, &buffer_size, size, NULL );
- todo_wine ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ todo_wine ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeReader( reader );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, data1, sizeof(data1) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
max_ns = 0xdeadbeef;
size = sizeof(max_ns);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_MAX_NAMESPACES, &max_ns, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_ns == 32, "got %u\n", max_ns );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_ns == 32, "got %lu\n", max_ns );
WsFreeReader( reader );
/* change a property */
@@ -334,16 +334,16 @@ static void test_WsCreateReader(void)
prop.value = &max_depth;
prop.valueSize = sizeof(max_depth);
hr = WsCreateReader( &prop, 1, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, data1, sizeof(data1) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_depth == 16, "got %u\n", max_depth );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_depth == 16, "got %lu\n", max_depth );
WsFreeReader( reader );
/* show that some properties are read-only */
@@ -352,21 +352,21 @@ static void test_WsCreateReader(void)
prop.value = &row;
prop.valueSize = sizeof(row);
hr = WsCreateReader( &prop, 1, &reader, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
column = 1;
prop.id = WS_XML_READER_PROPERTY_COLUMN;
prop.value = &column;
prop.valueSize = sizeof(column);
hr = WsCreateReader( &prop, 1, &reader, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
in_attr = TRUE;
prop.id = WS_XML_READER_PROPERTY_IN_ATTRIBUTE;
prop.value = &in_attr;
prop.valueSize = sizeof(in_attr);
hr = WsCreateReader( &prop, 1, &reader, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
}
static void test_WsSetInput(void)
@@ -444,14 +444,14 @@ static void test_WsSetInput(void)
};
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetInput( NULL, NULL, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
node = NULL;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node != NULL, "node not set\n" );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
@@ -463,17 +463,17 @@ static void test_WsSetInput(void)
input.encodedDataSize = sizeof(data1) - 1;
hr = WsSetInput( reader, &enc.encoding, &input.input, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node = NULL;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node != NULL, "node not set\n" );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
/* multiple calls are allowed */
hr = WsSetInput( reader, &enc.encoding, &input.input, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* charset is detected by WsSetInput */
enc.encoding.encodingType = WS_XML_READER_ENCODING_TYPE_TEXT;
@@ -484,16 +484,16 @@ static void test_WsSetInput(void)
input.encodedData = tests[i].data;
input.encodedDataSize = tests[i].size;
hr = WsSetInput( reader, &enc.encoding, &input.input, NULL, 0, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
charset = 0xdeadbeef;
size = sizeof(charset);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_CHARSET, &charset, size, NULL );
todo_wine_if (tests[i].todo)
{
- ok( hr == tests[i].hr, "%u: got %08x expected %08x\n", i, hr, tests[i].hr );
+ ok( hr == tests[i].hr, "%lu: got %#lx expected %#lx\n", i, hr, tests[i].hr );
if (hr == S_OK)
- ok( charset == tests[i].charset, "%u: got %u expected %u\n", i, charset, tests[i].charset );
+ ok( charset == tests[i].charset, "%lu: got %u expected %u\n", i, charset, tests[i].charset );
}
}
@@ -506,13 +506,13 @@ static void test_WsSetInput(void)
prop.value = &max_depth;
prop.valueSize = sizeof(max_depth);
hr = WsSetInput( reader, &enc.encoding, &input.input, &prop, 1, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_depth == 16, "got %u\n", max_depth );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_depth == 16, "got %lu\n", max_depth );
/* show that the reader converts text to UTF-8 */
enc.encoding.encodingType = WS_XML_READER_ENCODING_TYPE_TEXT;
@@ -520,26 +520,26 @@ static void test_WsSetInput(void)
input.encodedData = (void *)test24;
input.encodedDataSize = sizeof(test24);
hr = WsSetInput( reader, &enc.encoding, &input.input, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (hr == S_OK)
{
ok( found == TRUE, "got %d\n", found );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text = (WS_XML_TEXT_NODE *)node;
ok( text->node.nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", text->node.nodeType );
ok( text->text != NULL, "text not set\n" );
utf8 = (WS_XML_UTF8_TEXT *)text->text;
ok( text->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text->text->textType );
- ok( utf8->value.length == 1, "got %u\n", utf8->value.length );
+ ok( utf8->value.length == 1, "got %lu\n", utf8->value.length );
ok( utf8->value.bytes[0] == 'b', "wrong data\n" );
}
WsFreeReader( reader );
@@ -556,38 +556,38 @@ static void test_WsSetInputToBuffer(void)
ULONG size, max_depth;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetInputToBuffer( NULL, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsSetInputToBuffer( reader, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
node = NULL;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node != NULL, "node not set\n" );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
hr = WsSetInputToBuffer( reader, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node = NULL;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node != NULL, "node not set\n" );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
/* multiple calls are allowed */
hr = WsSetInputToBuffer( reader, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* reader properties can be set with WsSetInputToBuffer */
max_depth = 16;
@@ -595,13 +595,13 @@ static void test_WsSetInputToBuffer(void)
prop.value = &max_depth;
prop.valueSize = sizeof(max_depth);
hr = WsSetInputToBuffer( reader, buffer, &prop, 1, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_depth == 16, "got %u\n", max_depth );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_depth == 16, "got %lu\n", max_depth );
WsFreeReader( reader );
WsFreeHeap( heap );
@@ -615,66 +615,66 @@ static void test_WsFillReader(void)
/* what happens of we don't call WsFillReader? */
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node = NULL;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
hr = set_input( reader, data1, sizeof(data1) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node = NULL;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node = NULL;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
WsFreeReader( reader );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, data1, sizeof(data1) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data1) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, data1, sizeof(data1) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node = NULL;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node != NULL, "node not set\n" );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
hr = WsFillReader( NULL, sizeof(data1) - 1, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data1) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node = NULL;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node != NULL, "node not set\n" );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
hr = WsFillReader( reader, sizeof(data1) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* min_size larger than input size */
hr = WsFillReader( reader, sizeof(data1), NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeReader( reader );
}
@@ -686,50 +686,50 @@ static void test_WsReadToStartElement(void)
int found;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, data1, sizeof(data1) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data1) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
hr = WsFillReader( reader, sizeof(data1) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( NULL, NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == FALSE, "got %d\n", found );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
hr = set_input( reader, data2, sizeof(data2) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data2) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == TRUE, "got %d\n", found );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_ELEMENT_NODE *elem = (WS_XML_ELEMENT_NODE *)node;
@@ -738,47 +738,47 @@ static void test_WsReadToStartElement(void)
ok( elem->prefix != NULL, "prefix not set\n" );
if (elem->prefix)
{
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
}
ok( elem->localName != NULL, "localName not set\n" );
if (elem->localName)
{
- ok( elem->localName->length == 4, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 4, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "text", 4 ), "wrong data\n" );
}
ok( elem->ns != NULL, "ns not set\n" );
if (elem->ns)
{
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
}
- ok( !elem->attributeCount, "got %u\n", elem->attributeCount );
+ ok( !elem->attributeCount, "got %lu\n", elem->attributeCount );
ok( elem->attributes == NULL, "attributes set\n" );
ok( !elem->isEmpty, "isEmpty not zero\n" );
}
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == TRUE, "got %d\n", found );
node2 = NULL;
hr = WsGetReaderNode( reader, &node2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node2 == node, "different node\n" );
hr = set_input( reader, data3, sizeof(data3) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data3) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == TRUE, "got %d\n", found );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_ELEMENT_NODE *elem = (WS_XML_ELEMENT_NODE *)node;
@@ -787,20 +787,20 @@ static void test_WsReadToStartElement(void)
ok( elem->localName != NULL, "localName not set\n" );
if (elem->localName)
{
- ok( elem->localName->length == 4, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 4, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "text", 4 ), "wrong data\n" );
}
}
hr = set_input( reader, data4, sizeof(data4) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data4) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == TRUE, "got %d\n", found );
WsFreeReader( reader );
}
@@ -813,31 +813,31 @@ static void test_WsReadStartElement(void)
int found;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, data2, sizeof(data2) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data2) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == TRUE, "got %d\n", found );
hr = WsReadStartElement( NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_TEXT_NODE *text = (WS_XML_TEXT_NODE *)node;
@@ -847,36 +847,36 @@ static void test_WsReadStartElement(void)
{
WS_XML_UTF8_TEXT *utf8 = (WS_XML_UTF8_TEXT *)text->text;
ok( text->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text->text->textType );
- ok( utf8->value.length == 4, "got %u\n", utf8->value.length );
+ ok( utf8->value.length == 4, "got %lu\n", utf8->value.length );
ok( !memcmp( utf8->value.bytes, "test", 4 ), "wrong data\n" );
}
}
hr = WsReadStartElement( reader, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
node2 = NULL;
hr = WsGetReaderNode( reader, &node2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node2 == node, "different node\n" );
hr = set_input( reader, data8, sizeof(data8) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data8) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == TRUE, "got %d\n", found );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_ELEMENT_NODE *elem = (WS_XML_ELEMENT_NODE *)node;
@@ -885,10 +885,10 @@ static void test_WsReadStartElement(void)
}
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_ELEMENT_NODE *elem = (WS_XML_ELEMENT_NODE *)node;
@@ -897,46 +897,46 @@ static void test_WsReadStartElement(void)
}
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", node->nodeType );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadEndElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* WsReadEndElement advances reader to EOF */
hr = WsReadEndElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
hr = WsReadEndElement( reader, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_input( reader, data3, sizeof(data3) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node = NULL;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_TEXT_NODE *text = (WS_XML_TEXT_NODE *)node;
@@ -946,20 +946,20 @@ static void test_WsReadStartElement(void)
{
WS_XML_UTF8_TEXT *utf8 = (WS_XML_UTF8_TEXT *)text->text;
ok( text->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text->text->textType );
- ok( utf8->value.length == 4, "got %u\n", utf8->value.length );
+ ok( utf8->value.length == 4, "got %lu\n", utf8->value.length );
ok( !memcmp( utf8->value.bytes, "test", 4 ), "wrong data\n" );
}
}
hr = set_input( reader, " <text>test</text>", sizeof(" <text>test</text>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node = NULL;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_TEXT_NODE *text = (WS_XML_TEXT_NODE *)node;
@@ -969,7 +969,7 @@ static void test_WsReadStartElement(void)
{
WS_XML_UTF8_TEXT *utf8 = (WS_XML_UTF8_TEXT *)text->text;
ok( text->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text->text->textType );
- ok( utf8->value.length == 4, "got %u\n", utf8->value.length );
+ ok( utf8->value.length == 4, "got %lu\n", utf8->value.length );
ok( !memcmp( utf8->value.bytes, "test", 4 ), "wrong data\n" );
}
}
@@ -985,181 +985,181 @@ static void test_WsReadEndElement(void)
int found;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, data2, sizeof(data2) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data2) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadEndElement( reader, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_input( reader, data2, sizeof(data2) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data2) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", node->nodeType );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
hr = set_input( reader, data2, sizeof(data2) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data2) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", node->nodeType );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* WsReadEndElement advances reader to EOF */
hr = WsReadEndElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
hr = WsReadEndElement( reader, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_input( reader, data5, sizeof(data5) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data5) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadEndElement( reader, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_input( reader, data10, sizeof(data10) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data10) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadEndElement( reader, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_input( reader, "<a></A>", sizeof("<a></A>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof("<a></a>") - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == TRUE, "got %d\n", found );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadEndElement( reader, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_input( reader, "<a></a>", sizeof("<a></a>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof("<a></a>") - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == TRUE, "got %d\n", found );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadEndElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
hr = set_input( reader, "<a/>", sizeof("<a/>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof("<a/>") - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == TRUE, "got %d\n", found );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadEndElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeReader( reader );
}
@@ -1218,24 +1218,24 @@ static void test_WsReadNode(void)
};
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
hr = set_input( reader, tests[i].text, strlen(tests[i].text) );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, strlen(tests[i].text), NULL, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%u: got %#lx\n", i, hr );
hr = WsReadNode( reader, NULL );
todo_wine_if (tests[i].todo)
- ok( hr == tests[i].hr, "%u: got %08x\n", i, hr );
+ ok( hr == tests[i].hr, "%u: got %#lx\n", i, hr );
if (hr == S_OK)
{
node = NULL;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%u: got %#lx\n", i, hr );
ok( node != NULL, "%u: node not set\n", i );
if (node)
{
@@ -1246,18 +1246,18 @@ static void test_WsReadNode(void)
}
hr = set_input( reader, data6, sizeof(data6) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data6) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == TRUE, "got %d\n", found );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_ELEMENT_NODE *elem = (WS_XML_ELEMENT_NODE *)node;
@@ -1266,15 +1266,15 @@ static void test_WsReadNode(void)
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
ok( elem->prefix != NULL, "prefix not set\n" );
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
ok( elem->prefix->bytes == NULL, "bytes set\n" );
ok( elem->localName != NULL, "localName not set\n" );
- ok( elem->localName->length == 4, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 4, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "text", 4 ), "wrong data\n" );
ok( elem->ns != NULL, "ns not set\n" );
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "bytes not set\n" );
- ok( elem->attributeCount == 2, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 2, "got %lu\n", elem->attributeCount );
ok( elem->attributes != NULL, "attributes not set\n" );
ok( !elem->isEmpty, "isEmpty not zero\n" );
@@ -1282,74 +1282,74 @@ static void test_WsReadNode(void)
ok( !attr->singleQuote, "got %u\n", attr->singleQuote );
ok( !attr->isXmlNs, "got %u\n", attr->isXmlNs );
ok( attr->prefix != NULL, "prefix not set\n" );
- ok( !attr->prefix->length, "got %u\n", attr->prefix->length );
+ ok( !attr->prefix->length, "got %lu\n", attr->prefix->length );
ok( attr->prefix->bytes == NULL, "bytes set\n" );
ok( attr->localName != NULL, "localName not set\n" );
- ok( attr->localName->length == 4, "got %u\n", attr->localName->length );
+ ok( attr->localName->length == 4, "got %lu\n", attr->localName->length );
ok( !memcmp( attr->localName->bytes, "attr", 4 ), "wrong data\n" );
ok( attr->ns != NULL, "ns not set\n" );
- ok( !attr->ns->length, "got %u\n", attr->ns->length );
+ ok( !attr->ns->length, "got %lu\n", attr->ns->length );
ok( attr->ns->bytes == NULL, "bytes set\n" );
ok( attr->value != NULL, "value not set\n" );
text = (WS_XML_UTF8_TEXT *)attr->value;
ok( attr->value->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", attr->value->textType );
- ok( text->value.length == 5, "got %u\n", text->value.length );
+ ok( text->value.length == 5, "got %lu\n", text->value.length );
ok( !memcmp( text->value.bytes, "value", 5 ), "wrong data\n" );
attr = elem->attributes[1];
ok( attr->singleQuote == 1, "got %u\n", attr->singleQuote );
ok( !attr->isXmlNs, "got %u\n", attr->isXmlNs );
ok( attr->prefix != NULL, "prefix not set\n" );
- ok( !attr->prefix->length, "got %u\n", attr->prefix->length );
+ ok( !attr->prefix->length, "got %lu\n", attr->prefix->length );
ok( attr->prefix->bytes == NULL, "bytes set\n" );
ok( attr->localName != NULL, "localName not set\n" );
- ok( attr->localName->length == 5, "got %u\n", attr->localName->length );
+ ok( attr->localName->length == 5, "got %lu\n", attr->localName->length );
ok( !memcmp( attr->localName->bytes, "attr2", 5 ), "wrong data\n" );
ok( attr->ns != NULL, "ns not set\n" );
- ok( !attr->ns->length, "got %u\n", attr->ns->length );
+ ok( !attr->ns->length, "got %lu\n", attr->ns->length );
ok( attr->ns->bytes == NULL, "bytes set\n" );
ok( attr->value != NULL, "value not set\n" );
text = (WS_XML_UTF8_TEXT *)attr->value;
ok( attr->value->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", attr->value->textType );
- ok( text->value.length == 6, "got %u\n", text->value.length );
+ ok( text->value.length == 6, "got %lu\n", text->value.length );
ok( !memcmp( text->value.bytes, "value2", 6 ), "wrong data\n" );
}
hr = set_input( reader, data7, sizeof(data7) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data7) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_COMMENT_NODE *comment = (WS_XML_COMMENT_NODE *)node;
ok( comment->node.nodeType == WS_XML_NODE_TYPE_COMMENT, "got %u\n", comment->node.nodeType );
- ok( comment->value.length == 9, "got %u\n", comment->value.length );
+ ok( comment->value.length == 9, "got %lu\n", comment->value.length );
ok( !memcmp( comment->value.bytes, " comment ", 9 ), "wrong data\n" );
}
dict = (WS_XML_DICTIONARY *)0xdeadbeef;
hr = WsGetDictionary( WS_ENCODING_XML_UTF8, &dict, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( dict == NULL, "got %p\n", dict );
dict = NULL;
hr = WsGetDictionary( WS_ENCODING_XML_BINARY_1, &dict, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( dict != NULL, "dict not set\n" );
dict = NULL;
hr = WsGetDictionary( WS_ENCODING_XML_BINARY_SESSION_1, &dict, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( dict != NULL, "dict not set\n" );
WsFreeReader( reader );
@@ -1360,13 +1360,13 @@ static void prepare_type_test( WS_XML_READER *reader, const char *data, ULONG si
HRESULT hr;
hr = set_input( reader, data, size );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
}
static void test_WsReadType(void)
@@ -1398,32 +1398,32 @@ static void test_WsReadType(void)
WS_XML_QNAME val_qname, *ptr_qname;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
prepare_type_test( reader, data2, sizeof(data2) - 1 );
hr = WsReadType( NULL, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &val_str, sizeof(val_str), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &val_str, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, NULL, sizeof(val_str), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &val_str, sizeof(val_str) + 1, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
val_str = NULL;
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &val_str, sizeof(val_str), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_str != NULL, "pointer not set\n" );
if (val_str) ok( !wcscmp( val_str, L"test" ), "wrong data\n" );
@@ -1431,261 +1431,261 @@ static void test_WsReadType(void)
prepare_type_test( reader, "<t>true</t>", sizeof("<t>true</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BOOL_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_bool, sizeof(BOOL), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_bool == TRUE, "got %d\n", val_bool );
val_bool = -1;
prepare_type_test( reader, "<t>false</t>", sizeof("<t>false</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BOOL_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_bool, sizeof(BOOL), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_bool == FALSE, "got %d\n", val_bool );
val_bool = -1;
prepare_type_test( reader, "<t>FALSE</t>", sizeof("<t>FALSE</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BOOL_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_bool, sizeof(val_bool), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
ok( val_bool == -1, "got %d\n", val_bool );
val_bool = -1;
prepare_type_test( reader, "<t>1</t>", sizeof("<t>1</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BOOL_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_bool, sizeof(val_bool), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_bool == TRUE, "got %d\n", val_bool );
val_bool = -1;
prepare_type_test( reader, "<t>2</t>", sizeof("<t>2</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BOOL_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_bool, sizeof(val_bool), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
ok( val_bool == -1, "got %d\n", val_bool );
val_bool = -1;
prepare_type_test( reader, "<t>0</t>", sizeof("<t>0</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BOOL_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_bool, sizeof(val_bool), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_bool == FALSE, "got %d\n", val_bool );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BOOL_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_bool, sizeof(val_bool), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BOOL_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_bool, sizeof(ptr_bool), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
val_int8 = 0;
prepare_type_test( reader, "<t>-128</t>", sizeof("<t>-128</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT8_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int8, sizeof(val_int8), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_int8 == -128, "got %d\n", val_int8 );
prepare_type_test( reader, "<t> </t>", sizeof("<t> </t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT8_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int8, sizeof(val_int8), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT8_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int8, sizeof(val_int8), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t>-</t>", sizeof("<t>-</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT8_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int8, sizeof(val_int8), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
val_int8 = -1;
prepare_type_test( reader, "<t>-0</t>", sizeof("<t>-0</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT8_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int8, sizeof(val_int8), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( !val_int8, "got %d\n", val_int8 );
prepare_type_test( reader, "<t>-129</t>", sizeof("<t>-129</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT8_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int8, sizeof(val_int8), NULL );
- ok( hr == WS_E_NUMERIC_OVERFLOW, "got %08x\n", hr );
+ ok( hr == WS_E_NUMERIC_OVERFLOW, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT8_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_int8, sizeof(ptr_int8), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
val_int16 = 0;
prepare_type_test( reader, "<t>-32768</t>", sizeof("<t>-32768</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT16_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int16, sizeof(val_int16), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_int16 == -32768, "got %d\n", val_int16 );
prepare_type_test( reader, "<t>-32769</t>", sizeof("<t>-32769</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT16_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int16, sizeof(val_int16), NULL );
- ok( hr == WS_E_NUMERIC_OVERFLOW, "got %08x\n", hr );
+ ok( hr == WS_E_NUMERIC_OVERFLOW, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT16_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int16, sizeof(val_int16), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT16_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_int16, sizeof(ptr_int16), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
val_int32 = 0;
prepare_type_test( reader, "<t>-2147483648</t>", sizeof("<t>-2147483648</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT32_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int32, sizeof(val_int32), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_int32 == -2147483647 - 1, "got %d\n", val_int32 );
prepare_type_test( reader, "<t>-2147483649</t>", sizeof("<t>-2147483649</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT32_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int32, sizeof(val_int32), NULL );
- todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT32_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int32, sizeof(val_int32), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT32_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_int32, sizeof(ptr_int32), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
val_int64 = 0;
prepare_type_test( reader, "<t>-9223372036854775808</t>", sizeof("<t>-9223372036854775808</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT64_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int64, sizeof(val_int64), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_int64 == -9223372036854775807 - 1, "wrong value\n" );
prepare_type_test( reader, "<t>-9223372036854775809</t>", sizeof("<t>-9223372036854775809</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT64_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int64, sizeof(val_int64), NULL );
- todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT64_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_int64, sizeof(val_int64), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_INT64_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_int64, sizeof(ptr_int64), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
val_uint8 = 0;
prepare_type_test( reader, "<t> 255 </t>", sizeof("<t> 255 </t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT8_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint8, sizeof(val_uint8), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_uint8 == 255, "got %u\n", val_uint8 );
prepare_type_test( reader, "<t>+255</t>", sizeof("<t>+255</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT8_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint8, sizeof(val_uint8), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t>-255</t>", sizeof("<t>-255</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT8_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint8, sizeof(val_uint8), NULL );
- todo_wine ok( hr == WS_E_NUMERIC_OVERFLOW, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_NUMERIC_OVERFLOW, "got %#lx\n", hr );
prepare_type_test( reader, "<t>0xff</t>", sizeof("<t>0xff</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT8_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint8, sizeof(val_uint8), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t>256</t>", sizeof("<t>256</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT8_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint8, sizeof(val_uint8), NULL );
- ok( hr == WS_E_NUMERIC_OVERFLOW, "got %08x\n", hr );
+ ok( hr == WS_E_NUMERIC_OVERFLOW, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT8_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint8, sizeof(val_uint8), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT8_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_uint8, sizeof(ptr_uint8), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
val_uint16 = 0;
prepare_type_test( reader, "<t>65535</t>", sizeof("<t>65535</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT16_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint16, sizeof(val_uint16), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_uint16 == 65535, "got %u\n", val_uint16 );
prepare_type_test( reader, "<t>65536</t>", sizeof("<t>65536</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT16_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint16, sizeof(val_uint16), NULL );
- ok( hr == WS_E_NUMERIC_OVERFLOW, "got %08x\n", hr );
+ ok( hr == WS_E_NUMERIC_OVERFLOW, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT16_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint16, sizeof(val_uint16), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT16_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_uint16, sizeof(ptr_uint16), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
val_uint32 = 0;
prepare_type_test( reader, "<t>4294967295</t>", sizeof("<t>4294967295</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT32_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint32, sizeof(val_uint32), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_uint32 == ~0, "got %u\n", val_uint32 );
prepare_type_test( reader, "<t>4294967296</t>", sizeof("<t>4294967296</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT32_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint32, sizeof(val_uint32), NULL );
- ok( hr == WS_E_NUMERIC_OVERFLOW, "got %08x\n", hr );
+ ok( hr == WS_E_NUMERIC_OVERFLOW, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT32_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint32, sizeof(val_uint32), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT32_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_uint32, sizeof(ptr_uint32), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
val_uint64 = 0;
prepare_type_test( reader, "<t>18446744073709551615</t>", sizeof("<t>18446744073709551615</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT64_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint64, sizeof(val_uint64), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_uint64 == ~0, "wrong value\n" );
prepare_type_test( reader, "<t>18446744073709551616</t>", sizeof("<t>18446744073709551616</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT64_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint64, sizeof(val_uint64), NULL );
- todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT64_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_uint64, sizeof(val_uint64), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UINT64_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_uint64, sizeof(ptr_uint64), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
enum_desc.values = enum_values;
enum_desc.valueCount = ARRAY_SIZE( enum_values );
@@ -1696,31 +1696,31 @@ static void test_WsReadType(void)
prepare_type_test( reader, "<t>ONE</t>", sizeof("<t>ONE</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_ENUM_TYPE, &enum_desc,
WS_READ_REQUIRED_VALUE, heap, &val_enum, sizeof(val_enum), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_enum == 1, "got %d\n", val_enum );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_ENUM_TYPE, &enum_desc,
WS_READ_REQUIRED_VALUE, heap, &val_enum, sizeof(val_enum), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_ENUM_TYPE, &enum_desc,
WS_READ_REQUIRED_POINTER, heap, &ptr_enum, sizeof(ptr_enum), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t>{00000000-0000-0000-0000-000000000000}</t>",
sizeof("<t>{00000000-0000-0000-0000-000000000000}</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_GUID_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_guid, sizeof(val_guid), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
memset( &val_guid, 0xff, sizeof(val_guid) );
prepare_type_test( reader, "<t> 00000000-0000-0000-0000-000000000000 </t>",
sizeof("<t> 00000000-0000-0000-0000-000000000000 </t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_GUID_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_guid, sizeof(val_guid), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( IsEqualGUID( &val_guid, &guid_null ), "wrong guid\n" );
memset( &val_guid, 0, sizeof(val_guid) );
@@ -1728,7 +1728,7 @@ static void test_WsReadType(void)
sizeof("<t>00000000-0000-0000-0000-0000000000a1</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_GUID_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_guid, sizeof(val_guid), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( IsEqualGUID( &val_guid, &guid ), "wrong guid\n" );
memset( &val_guid, 0, sizeof(val_guid) );
@@ -1736,61 +1736,61 @@ static void test_WsReadType(void)
sizeof("<t>00000000-0000-0000-0000-0000000000A1</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_GUID_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_guid, sizeof(val_guid), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( IsEqualGUID( &val_guid, &guid ), "wrong guid\n" );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_GUID_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_guid, sizeof(val_guid), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_GUID_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_guid, sizeof(ptr_guid), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
memset( &val_bytes, 0, sizeof(val_bytes) );
prepare_type_test( reader, "<t>dGVzdA==</t>", sizeof("<t>dGVzdA==</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BYTES_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_bytes, sizeof(val_bytes), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( val_bytes.length == 4, "got %u\n", val_bytes.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( val_bytes.length == 4, "got %lu\n", val_bytes.length );
ok( !memcmp( val_bytes.bytes, "test", 4 ), "wrong data\n" );
memset( &val_bytes, 0, sizeof(val_bytes) );
prepare_type_test( reader, "<t> dGVzdA== </t>", sizeof("<t> dGVzdA== </t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BYTES_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_bytes, sizeof(val_bytes), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( val_bytes.length == 4, "got %u\n", val_bytes.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( val_bytes.length == 4, "got %lu\n", val_bytes.length );
ok( !memcmp( val_bytes.bytes, "test", 4 ), "wrong data\n" );
prepare_type_test( reader, "<t>dGVzdA===</t>", sizeof("<t>dGVzdA===</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BYTES_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_bytes, sizeof(val_bytes), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
val_bytes.length = 0xdeadbeef;
val_bytes.bytes = (BYTE *)0xdeadbeef;
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BYTES_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_bytes, sizeof(val_bytes), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !val_bytes.length, "got %u\n", val_bytes.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !val_bytes.length, "got %lu\n", val_bytes.length );
todo_wine ok( val_bytes.bytes != NULL, "got %p\n", val_bytes.bytes );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_BYTES_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_bytes, sizeof(ptr_bytes), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !ptr_bytes->length, "got %u\n", ptr_bytes->length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !ptr_bytes->length, "got %lu\n", ptr_bytes->length );
todo_wine ok( ptr_bytes->bytes != NULL, "got %p\n", ptr_bytes->bytes );
val_str = NULL;
prepare_type_test( reader, utf8, sizeof(utf8) );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &val_str, sizeof(val_str), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_str != NULL, "pointer not set\n" );
ok( !lstrcmpW( val_str, L"\x2019" ), "got %s\n", wine_dbgstr_w(val_str) );
@@ -1798,7 +1798,7 @@ static void test_WsReadType(void)
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &val_str, sizeof(val_str), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val_str != NULL, "got %p\n", val_str );
ok( !val_str[0], "got %s\n", wine_dbgstr_w(val_str) );
@@ -1806,8 +1806,8 @@ static void test_WsReadType(void)
prepare_type_test( reader, "<t> test </t>", sizeof("<t> test </t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_XML_STRING_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_xmlstr, sizeof(val_xmlstr), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( val_xmlstr.length == 6, "got %u\n", val_xmlstr.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( val_xmlstr.length == 6, "got %lu\n", val_xmlstr.length );
ok( !memcmp( val_xmlstr.bytes, " test ", 6 ), "wrong data\n" );
val_xmlstr.length = 0xdeadbeef;
@@ -1815,22 +1815,22 @@ static void test_WsReadType(void)
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_XML_STRING_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_xmlstr, sizeof(val_xmlstr), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !val_xmlstr.length, "got %u\n", val_bytes.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !val_xmlstr.length, "got %lu\n", val_bytes.length );
todo_wine ok( val_xmlstr.bytes != NULL, "got %p\n", val_bytes.bytes );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_XML_STRING_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_xmlstr, sizeof(ptr_xmlstr), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !ptr_xmlstr->length, "got %u\n", ptr_bytes->length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !ptr_xmlstr->length, "got %lu\n", ptr_bytes->length );
todo_wine ok( ptr_xmlstr->bytes != NULL, "got %p\n", ptr_bytes->bytes );
memset( &val_string, 0, sizeof(val_string) );
prepare_type_test( reader, "<t> test </t>", sizeof("<t> test </t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRING_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_string, sizeof(val_string), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( val_string.length == 6, "got %u\n", val_string.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( val_string.length == 6, "got %lu\n", val_string.length );
ok( !memcmp( val_string.chars, L" test ", 12 ), "wrong data\n" );
val_string.length = 0xdeadbeef;
@@ -1838,14 +1838,14 @@ static void test_WsReadType(void)
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRING_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_string, sizeof(val_string), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !val_string.length, "got %u\n", val_string.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !val_string.length, "got %lu\n", val_string.length );
todo_wine ok( val_string.chars != NULL, "got %p\n", val_string.chars );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRING_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_string, sizeof(ptr_string), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !ptr_string->length, "got %u\n", ptr_string->length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !ptr_string->length, "got %lu\n", ptr_string->length );
todo_wine ok( ptr_string->chars != NULL, "got %p\n", ptr_string->chars );
memset( &val_id, 0, sizeof(val_id) );
@@ -1853,8 +1853,8 @@ static void test_WsReadType(void)
prepare_type_test( reader, "<t> test </t>", sizeof("<t> test </t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UNIQUE_ID_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_id, sizeof(val_id), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( val_id.uri.length == 6, "got %u\n", val_string.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( val_id.uri.length == 6, "got %lu\n", val_string.length );
ok( !memcmp( val_id.uri.chars, L" test ", 12 ), "wrong data\n" );
ok( IsEqualGUID( &val_id.guid, &guid_null ), "wrong guid\n" );
@@ -1863,62 +1863,62 @@ static void test_WsReadType(void)
sizeof("<t>urn:uuid:00000000-0000-0000-0000-0000000000a1</t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UNIQUE_ID_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_id, sizeof(val_id), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !val_id.uri.length, "got %u\n", val_string.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !val_id.uri.length, "got %lu\n", val_string.length );
ok( val_id.uri.chars == NULL, "chars set %s\n", wine_dbgstr_wn(val_id.uri.chars, val_id.uri.length) );
ok( IsEqualGUID( &val_id.guid, &guid ), "wrong guid\n" );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UNIQUE_ID_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_id, sizeof(val_id), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_type_test( reader, "<t></t>", sizeof("<t></t>") - 1 );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_UNIQUE_ID_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_id, sizeof(ptr_id), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
memset( &val_qname, 0, sizeof(val_qname) );
hr = set_input( reader, "<t>u</t>", sizeof("<t>u</t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_XML_QNAME_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_qname, sizeof(val_qname), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( val_qname.localName.length == 1, "got %u\n", val_qname.localName.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( val_qname.localName.length == 1, "got %lu\n", val_qname.localName.length );
ok( val_qname.localName.bytes[0] == 'u', "wrong data\n" );
- ok( !val_qname.ns.length, "got %u\n", val_qname.ns.length );
+ ok( !val_qname.ns.length, "got %lu\n", val_qname.ns.length );
ok( val_qname.ns.bytes != NULL, "bytes not set\n" );
memset( &val_qname, 0, sizeof(val_qname) );
hr = set_input( reader, "<p:t xmlns:p=\"ns\"> p:u </p:t>", sizeof("<p:t xmlns:p=\"ns\"> p:u </p:t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_XML_QNAME_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_qname, sizeof(val_qname), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( val_qname.localName.length == 1, "got %u\n", val_qname.localName.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( val_qname.localName.length == 1, "got %lu\n", val_qname.localName.length );
ok( val_qname.localName.bytes[0] == 'u', "wrong data\n" );
- ok( val_qname.ns.length == 2, "got %u\n", val_qname.ns.length );
+ ok( val_qname.ns.length == 2, "got %lu\n", val_qname.ns.length );
ok( !memcmp( val_qname.ns.bytes, "ns", 2 ), "wrong data\n" );
hr = set_input( reader, "<t></t>", sizeof("<t></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_XML_QNAME_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val_qname, sizeof(val_qname), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_input( reader, "<t></t>", sizeof("<t></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_XML_QNAME_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &ptr_qname, sizeof(ptr_qname), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
WsFreeReader( reader );
WsFreeHeap( heap );
@@ -1935,20 +1935,20 @@ static void test_WsGetXmlAttribute(void)
int found;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, data9, sizeof(data9) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(data9) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == TRUE, "got %d\n", found );
xmlstr.bytes = (BYTE *)"attr";
@@ -1958,9 +1958,9 @@ static void test_WsGetXmlAttribute(void)
str = NULL;
count = 0;
hr = WsGetXmlAttribute( reader, &xmlstr, heap, &str, &count, NULL );
- todo_wine ok( hr == S_OK, "got %08x\n", hr );
+ todo_wine ok( hr == S_OK, "got %#lx\n", hr );
todo_wine ok( str != NULL, "str not set\n" );
- todo_wine ok( count == 5, "got %u\n", count );
+ todo_wine ok( count == 5, "got %lu\n", count );
/* string is not null-terminated */
if (str) ok( !memcmp( str, L"value", count * sizeof(WCHAR) ), "wrong data\n" );
@@ -1971,9 +1971,9 @@ static void test_WsGetXmlAttribute(void)
str = (WCHAR *)0xdeadbeef;
count = 0xdeadbeef;
hr = WsGetXmlAttribute( reader, &xmlstr, heap, &str, &count, NULL );
- todo_wine ok( hr == S_FALSE, "got %08x\n", hr );
+ todo_wine ok( hr == S_FALSE, "got %#lx\n", hr );
todo_wine ok( str == NULL, "str not set\n" );
- todo_wine ok( !count, "got %u\n", count );
+ todo_wine ok( !count, "got %lu\n", count );
WsFreeReader( reader );
WsFreeHeap( heap );
@@ -1986,44 +1986,44 @@ static void test_WsXmlStringEquals(void)
HRESULT hr;
hr = WsXmlStringEquals( NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsXmlStringEquals( &str1, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsXmlStringEquals( NULL, &str2, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsXmlStringEquals( &str1, &str2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
str1.length = 1;
str1.bytes = (BYTE *)"a";
hr = WsXmlStringEquals( &str1, &str1, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
str2.length = 1;
str2.bytes = (BYTE *)"b";
hr = WsXmlStringEquals( &str1, &str2, NULL );
- ok( hr == S_FALSE, "got %08x\n", hr );
+ ok( hr == S_FALSE, "got %#lx\n", hr );
str2.length = 1;
str2.bytes = bom;
hr = WsXmlStringEquals( &str1, &str2, NULL );
- ok( hr == S_FALSE, "got %08x\n", hr );
+ ok( hr == S_FALSE, "got %#lx\n", hr );
str1.length = 3;
hr = WsXmlStringEquals( &str1, &str2, NULL );
- ok( hr == S_FALSE, "got %08x\n", hr );
+ ok( hr == S_FALSE, "got %#lx\n", hr );
str2.length = 3;
hr = WsXmlStringEquals( &str1, &str2, NULL );
- ok( hr == S_FALSE, "got %08x\n", hr );
+ ok( hr == S_FALSE, "got %#lx\n", hr );
str1.length = 3;
str1.bytes = bom;
hr = WsXmlStringEquals( &str1, &str2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
}
static void test_WsAlloc(void)
@@ -2035,34 +2035,34 @@ static void test_WsAlloc(void)
ULONG size;
hr = WsCreateHeap( 256, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ptr = (void *)0xdeadbeef;
hr = WsAlloc( NULL, 16, &ptr, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
ok( ptr == (void *)0xdeadbeef, "ptr set\n" );
ptr = (void *)0xdeadbeef;
hr = WsAlloc( heap, 512, &ptr, NULL );
- ok( hr == WS_E_QUOTA_EXCEEDED, "got %08x\n", hr );
+ ok( hr == WS_E_QUOTA_EXCEEDED, "got %#lx\n", hr );
ok( ptr == (void *)0xdeadbeef, "ptr set\n" );
ptr = NULL;
hr = WsAlloc( heap, 16, &ptr, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( ptr != NULL, "ptr not set\n" );
requested = 0xdeadbeef;
size = sizeof(requested);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_REQUESTED_SIZE, &requested, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( requested == 16, "got %u\n", (ULONG)requested );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( requested == 16, "got %Iu\n", requested );
actual = 0xdeadbeef;
size = sizeof(actual);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_ACTUAL_SIZE, &actual, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- todo_wine ok( actual == 128, "got %u\n", (ULONG)actual );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ todo_wine ok( actual == 128, "got %Iu\n", actual );
WsFreeHeap( heap );
}
@@ -2080,236 +2080,236 @@ static void test_WsMoveReader(void)
WS_XML_UTF8_TEXT utf8;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveReader( NULL, WS_MOVE_TO_EOF, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
/* reader must be set to an XML buffer */
hr = WsMoveReader( reader, WS_MOVE_TO_EOF, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_input( reader, data8, sizeof(data8) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveReader( reader, WS_MOVE_TO_EOF, NULL, NULL );
- todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
WsFreeReader( reader );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* <a><b/></a> */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname2, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveReader( reader, WS_MOVE_TO_EOF, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsSetInputToBuffer( reader, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* first element is child node of BOF node */
hr = WsMoveReader( reader, WS_MOVE_TO_BOF, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveReader( reader, WS_MOVE_TO_CHILD_NODE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
elem = (WS_XML_ELEMENT_NODE *)node;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "a", 1 ), "wrong data\n" );
hr = WsMoveReader( reader, WS_MOVE_TO_CHILD_NODE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
elem = (WS_XML_ELEMENT_NODE *)node;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "b", 1 ), "wrong data\n" );
hr = WsMoveReader( reader, WS_MOVE_TO_NEXT_NODE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* EOF node is last child of BOF node */
hr = WsMoveReader( reader, WS_MOVE_TO_BOF, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveReader( reader, WS_MOVE_TO_CHILD_NODE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
hr = WsMoveReader( reader, WS_MOVE_TO_NEXT_NODE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
hr = WsMoveReader( reader, WS_MOVE_TO_ROOT_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
elem = (WS_XML_ELEMENT_NODE *)node;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "a", 1 ), "wrong data\n" );
hr = WsMoveReader( reader, WS_MOVE_TO_CHILD_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
elem = (WS_XML_ELEMENT_NODE *)node;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "b", 1 ), "wrong data\n" );
hr = WsMoveReader( reader, WS_MOVE_TO_END_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
hr = WsMoveReader( reader, WS_MOVE_TO_PARENT_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
elem = (WS_XML_ELEMENT_NODE *)node;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "b", 1 ), "wrong data\n" );
hr = WsMoveReader( reader, WS_MOVE_TO_PARENT_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
elem = (WS_XML_ELEMENT_NODE *)node;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "a", 1 ), "wrong data\n" );
hr = WsMoveReader( reader, WS_MOVE_TO_PARENT_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
hr = WsMoveReader( reader, WS_MOVE_TO_PARENT_ELEMENT, NULL, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
WsFreeWriter( writer );
WsFreeHeap( heap );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* <a><b>test</b></a> */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname2, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset(&utf8, 0, sizeof(utf8));
utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
utf8.value.bytes = (BYTE *)"test";
utf8.value.length = sizeof("test") - 1;
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetInputToBuffer( reader, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveReader( reader, WS_MOVE_TO_ROOT_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
hr = WsMoveReader( reader, WS_MOVE_TO_NEXT_NODE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
hr = WsMoveReader( reader, WS_MOVE_TO_ROOT_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveReader( reader, WS_MOVE_TO_CHILD_NODE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
elem = (WS_XML_ELEMENT_NODE *)node;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "b", 1 ), "wrong data\n" );
hr = WsMoveReader( reader, WS_MOVE_TO_NEXT_NODE, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
WsFreeReader( reader );
@@ -2323,7 +2323,7 @@ static void prepare_struct_type_test( WS_XML_READER *reader, const char *data )
ULONG size = strlen( data );
hr = set_input( reader, data, size );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
}
static void test_simple_struct_type(void)
@@ -2340,18 +2340,18 @@ static void test_simple_struct_type(void)
struct test { WCHAR *str; } *test;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
prepare_struct_type_test( reader, "<str>test</str>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, NULL,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
/* element field mapping */
@@ -2373,25 +2373,25 @@ static void test_simple_struct_type(void)
prepare_struct_type_test( reader, "<?xml version=\"1.0\" encoding=\"utf-8\"?><str>test</str><str>test2</str>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_struct_type_test( reader, "<?xml version=\"1.0\" encoding=\"utf-8\"?><str>test</str><str>test2</str>" );
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
s.structOptions = WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT;
prepare_struct_type_test( reader, "<?xml version=\"1.0\" encoding=\"utf-8\"?><str>test</str><str>test2</str>" );
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
s.structOptions = 0;
test = NULL;
prepare_struct_type_test( reader, "<?xml version=\"1.0\" encoding=\"utf-8\"?><str>test</str>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
if (test)
{
@@ -2400,14 +2400,14 @@ static void test_simple_struct_type(void)
}
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
test = NULL;
prepare_struct_type_test( reader, "<str>test</str>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
if (test)
{
@@ -2416,14 +2416,14 @@ static void test_simple_struct_type(void)
}
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
test = NULL;
prepare_struct_type_test( reader, "<str>test</str>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
if (test)
{
@@ -2432,24 +2432,24 @@ static void test_simple_struct_type(void)
}
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
prepare_struct_type_test( reader, "<str>test</str>" );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
elem = (const WS_XML_ELEMENT_NODE *)node;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->localName->length == 3, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 3, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "str", 3 ), "wrong data\n" );
test = NULL;
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
if (test)
{
@@ -2458,7 +2458,7 @@ static void test_simple_struct_type(void)
}
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
/* attribute field mapping */
@@ -2467,11 +2467,11 @@ static void test_simple_struct_type(void)
test = NULL;
prepare_struct_type_test( reader, "<test str=\"test\"/>" );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
if (test)
{
@@ -2480,7 +2480,7 @@ static void test_simple_struct_type(void)
}
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
WsFreeReader( reader );
@@ -2495,33 +2495,33 @@ static void test_cdata(void)
const WS_XML_NODE *node;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, test, sizeof(test) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof(test) - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_CDATA, "got %u\n", node->nodeType );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_TEXT_NODE *text = (WS_XML_TEXT_NODE *)node;
@@ -2531,23 +2531,23 @@ static void test_cdata(void)
{
WS_XML_UTF8_TEXT *utf8 = (WS_XML_UTF8_TEXT *)text->text;
ok( utf8->text.textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", utf8->text.textType );
- ok( utf8->value.length == 6, "got %u\n", utf8->value.length );
+ ok( utf8->value.length == 6, "got %lu\n", utf8->value.length );
ok( !memcmp( utf8->value.bytes, "<data>", 6 ), "wrong data\n" );
}
}
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_END_CDATA, "got %u\n", node->nodeType );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node) ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
WsFreeReader( reader );
@@ -2564,106 +2564,106 @@ static void test_WsFindAttribute(void)
HRESULT hr;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, test, sizeof(test) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFindAttribute( reader, &localname, &ns, TRUE, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_input( reader, test, sizeof(test) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFindAttribute( reader, &localname, NULL, TRUE, &index, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_input( reader, test, sizeof(test) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFindAttribute( reader, NULL, &ns, TRUE, &index, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_input( reader, test, sizeof(test) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
index = 0xdeadbeef;
hr = WsFindAttribute( reader, &localname, &ns, TRUE, &index, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !index, "got %u\n", index );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !index, "got %lu\n", index );
index = 0xdeadbeef;
hr = WsFindAttribute( reader, &localname2, &ns, TRUE, &index, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( index == 1, "got %u\n", index );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( index == 1, "got %lu\n", index );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
index = 0xdeadbeef;
hr = WsFindAttribute( reader, &localname, &ns, TRUE, &index, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
- ok( index == 0xdeadbeef, "got %u\n", index );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
+ ok( index == 0xdeadbeef, "got %lu\n", index );
hr = set_input( reader, test, sizeof(test) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
index = 0xdeadbeef;
hr = WsFindAttribute( reader, &localname3, &ns, TRUE, &index, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
- ok( index == 0xdeadbeef, "got %u\n", index );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
+ ok( index == 0xdeadbeef, "got %lu\n", index );
hr = set_input( reader, test, sizeof(test) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
index = 0xdeadbeef;
hr = WsFindAttribute( reader, &localname3, &ns, FALSE, &index, NULL );
- ok( hr == S_FALSE, "got %08x\n", hr );
- ok( index == ~0u, "got %u\n", index );
+ ok( hr == S_FALSE, "got %#lx\n", hr );
+ ok( index == ~0u, "got %lu\n", index );
hr = set_input( reader, test2, sizeof(test2) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
index = 0xdeadbeef;
hr = WsFindAttribute( reader, &localname, &ns, TRUE, &index, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !index, "got %u\n", index );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !index, "got %lu\n", index );
hr = WsFindAttribute( reader, &localname2, &ns2, TRUE, &index, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFindAttribute( reader, &localname2, &ns, TRUE, &index, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_input( reader, test2, sizeof(test2) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFindAttribute( reader, &localname, &ns2, TRUE, &index, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
WsFreeReader( reader );
}
@@ -2674,10 +2674,10 @@ static void prepare_namespace_test( WS_XML_READER *reader, const char *data )
ULONG size = strlen( data );
hr = set_input( reader, data, size );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
}
static void test_WsGetNamespaceFromPrefix(void)
@@ -2689,78 +2689,78 @@ static void test_WsGetNamespaceFromPrefix(void)
HRESULT hr;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetNamespaceFromPrefix( NULL, NULL, FALSE, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetNamespaceFromPrefix( NULL, NULL, FALSE, &ns, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetNamespaceFromPrefix( NULL, &prefix, FALSE, &ns, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
ns = (const WS_XML_STRING *)0xdeadbeef;
hr = WsGetNamespaceFromPrefix( reader, &prefix, TRUE, &ns, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
ok( ns == (const WS_XML_STRING *)0xdeadbeef, "ns set\n" );
hr = set_input( reader, "<prefix:t xmlns:prefix2='ns'/>", sizeof("<prefix:t xmlns:prefix2='ns'/>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadStartElement( reader, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_namespace_test( reader, "<t></t>" );
ns = NULL;
hr = WsGetNamespaceFromPrefix( reader, &prefix, TRUE, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( ns != NULL, "ns not set\n" );
- if (ns) ok( !ns->length, "got %u\n", ns->length );
+ if (ns) ok( !ns->length, "got %lu\n", ns->length );
prepare_namespace_test( reader, "<t xmls='ns'></t>" );
ns = NULL;
hr = WsGetNamespaceFromPrefix( reader, &prefix, TRUE, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( ns != NULL, "ns not set\n" );
- if (ns) ok( !ns->length, "got %u\n", ns->length );
+ if (ns) ok( !ns->length, "got %lu\n", ns->length );
prepare_namespace_test( reader, "<prefix:t xmlns:prefix='ns'></t>" );
ns = NULL;
hr = WsGetNamespaceFromPrefix( reader, &prefix, TRUE, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( ns != NULL, "ns not set\n" );
- if (ns) ok( !ns->length, "got %u\n", ns->length );
+ if (ns) ok( !ns->length, "got %lu\n", ns->length );
prepare_namespace_test( reader, "<prefix:t xmlns:prefix='ns'></t>" );
prefix.bytes = (BYTE *)"prefix";
prefix.length = 6;
ns = NULL;
hr = WsGetNamespaceFromPrefix( reader, &prefix, TRUE, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( ns != NULL, "ns not set\n" );
if (ns)
{
- ok( ns->length == 2, "got %u\n", ns->length );
+ ok( ns->length == 2, "got %lu\n", ns->length );
ok( !memcmp( ns->bytes, "ns", 2 ), "wrong data\n" );
}
prepare_namespace_test( reader, "<t xmlns:prefix='ns'></t>" );
ns = NULL;
hr = WsGetNamespaceFromPrefix( reader, &prefix, TRUE, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( ns != NULL, "ns not set\n" );
if (ns)
{
- ok( ns->length == 2, "got %u\n", ns->length );
+ ok( ns->length == 2, "got %lu\n", ns->length );
ok( !memcmp( ns->bytes, "ns", 2 ), "wrong data\n" );
}
hr = set_input( reader, "<t xmlns:prefix='ns'></t>", sizeof("<t xmlns:prefix='ns'></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_ELEMENT_NODE *elem = (WS_XML_ELEMENT_NODE *)node;
@@ -2769,54 +2769,54 @@ static void test_WsGetNamespaceFromPrefix(void)
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
ok( elem->prefix != NULL, "prefix not set\n" );
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
ok( elem->prefix->bytes == NULL, "bytes not set\n" );
ok( elem->ns != NULL, "ns not set\n" );
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "bytes not set\n" );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( elem->attributes != NULL, "attributes not set\n" );
attr = elem->attributes[0];
ok( attr->singleQuote, "singleQuote not set\n" );
ok( attr->isXmlNs, "isXmlNs not set\n" );
ok( attr->prefix != NULL, "prefix not set\n" );
- ok( attr->prefix->length == 6, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 6, "got %lu\n", attr->prefix->length );
ok( attr->prefix->bytes != NULL, "bytes not set\n" );
ok( !memcmp( attr->prefix->bytes, "prefix", 6 ), "wrong data\n" );
ok( attr->localName != NULL, "localName not set\n" );
- ok( attr->localName->length == 6, "got %u\n", attr->localName->length );
+ ok( attr->localName->length == 6, "got %lu\n", attr->localName->length );
ok( !memcmp( attr->localName->bytes, "prefix", 6 ), "wrong data\n" );
ok( attr->ns != NULL, "ns not set\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( attr->ns->bytes != NULL, "bytes not set\n" );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong data\n" );
ok( attr->value != NULL, "value not set\n" );
text = (WS_XML_UTF8_TEXT *)attr->value;
ok( attr->value->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", attr->value->textType );
- ok( !text->value.length, "got %u\n", text->value.length );
+ ok( !text->value.length, "got %lu\n", text->value.length );
ok( text->value.bytes == NULL, "bytes set\n" );
}
prepare_namespace_test( reader, "<t xmlns:prefix='ns'></t>" );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadEndElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetNamespaceFromPrefix( reader, &prefix, TRUE, &ns, NULL );
- todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_namespace_test( reader, "<t></t>" );
ns = NULL;
prefix.bytes = (BYTE *)"xml";
prefix.length = 3;
hr = WsGetNamespaceFromPrefix( reader, &prefix, TRUE, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( ns != NULL, "ns not set\n" );
if (ns)
{
- ok( ns->length == 36, "got %u\n", ns->length );
+ ok( ns->length == 36, "got %lu\n", ns->length );
ok( !memcmp( ns->bytes, "http://www.w3.org/XML/1998/namespace", 36 ), "wrong data\n" );
}
@@ -2825,11 +2825,11 @@ static void test_WsGetNamespaceFromPrefix(void)
prefix.bytes = (BYTE *)"xmlns";
prefix.length = 5;
hr = WsGetNamespaceFromPrefix( reader, &prefix, TRUE, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( ns != NULL, "ns not set\n" );
if (ns)
{
- ok( ns->length == 29, "got %u\n", ns->length );
+ ok( ns->length == 29, "got %lu\n", ns->length );
ok( !memcmp( ns->bytes, "http://www.w3.org/2000/xmlns/", 29 ), "wrong data\n" );
}
@@ -2838,7 +2838,7 @@ static void test_WsGetNamespaceFromPrefix(void)
prefix.bytes = (BYTE *)"prefix2";
prefix.length = 7;
hr = WsGetNamespaceFromPrefix( reader, &prefix, TRUE, &ns, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
ok( ns == (WS_XML_STRING *)0xdeadbeef, "ns set\n" );
prepare_namespace_test( reader, "<t></t>" );
@@ -2846,84 +2846,84 @@ static void test_WsGetNamespaceFromPrefix(void)
prefix.bytes = (BYTE *)"prefix2";
prefix.length = 7;
hr = WsGetNamespaceFromPrefix( reader, &prefix, FALSE, &ns, NULL );
- ok( hr == S_FALSE, "got %08x\n", hr );
+ ok( hr == S_FALSE, "got %#lx\n", hr );
ok( ns == NULL, "ns not set\n" );
hr = set_input( reader, "<t prefix:attr='' xmlns:prefix='ns'></t>", sizeof("<t prefix:attr='' xmlns:prefix='ns'></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_ELEMENT_NODE *elem = (WS_XML_ELEMENT_NODE *)node;
WS_XML_ATTRIBUTE *attr;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->attributeCount == 2, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 2, "got %lu\n", elem->attributeCount );
ok( elem->attributes != NULL, "attributes not set\n" );
attr = elem->attributes[0];
ok( attr->singleQuote, "singleQuote not set\n" );
ok( !attr->isXmlNs, "isXmlNs is set\n" );
ok( attr->prefix != NULL, "prefix not set\n" );
- ok( attr->prefix->length == 6, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 6, "got %lu\n", attr->prefix->length );
ok( attr->prefix->bytes != NULL, "bytes not set\n" );
ok( !memcmp( attr->prefix->bytes, "prefix", 6 ), "wrong data\n" );
ok( attr->localName != NULL, "localName not set\n" );
- ok( attr->localName->length == 4, "got %u\n", attr->localName->length );
+ ok( attr->localName->length == 4, "got %lu\n", attr->localName->length );
ok( !memcmp( attr->localName->bytes, "attr", 4 ), "wrong data\n" );
ok( attr->ns != NULL, "ns not set\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( attr->ns->bytes != NULL, "bytes not set\n" );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong data\n" );
}
hr = set_input( reader, "<t xmlns:p='ns'><u xmlns:p='ns2'/></t>", sizeof("<t xmlns:p='ns'><u xmlns:p='ns2'/></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, "<t xmlns:p='ns'><p:u p:a=''/></t>", sizeof("<t xmlns:p='ns'><p:u p:a=''/></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_ELEMENT_NODE *elem = (WS_XML_ELEMENT_NODE *)node;
WS_XML_ATTRIBUTE *attr;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( elem->attributes != NULL, "attributes not set\n" );
attr = elem->attributes[0];
ok( attr->prefix != NULL, "prefix not set\n" );
- ok( attr->prefix->length == 1, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 1, "got %lu\n", attr->prefix->length );
ok( attr->prefix->bytes != NULL, "bytes set\n" );
ok( !memcmp( attr->prefix->bytes, "p", 1 ), "wrong data\n" );
ok( attr->localName != NULL, "localName not set\n" );
- ok( attr->localName->length == 1, "got %u\n", attr->localName->length );
+ ok( attr->localName->length == 1, "got %lu\n", attr->localName->length );
ok( !memcmp( attr->localName->bytes, "a", 1 ), "wrong data\n" );
ok( attr->ns != NULL, "ns not set\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( attr->ns->bytes != NULL, "bytes not set\n" );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong data\n" );
}
hr = set_input( reader, "<t xmlns='ns'></t>", sizeof("<t xmlns='ns'></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (node)
{
WS_XML_ELEMENT_NODE *elem = (WS_XML_ELEMENT_NODE *)node;
@@ -2931,41 +2931,41 @@ static void test_WsGetNamespaceFromPrefix(void)
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
ok( elem->prefix != NULL, "prefix not set\n" );
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
ok( elem->prefix->bytes == NULL, "bytes not set\n" );
ok( elem->ns != NULL, "ns not set\n" );
- ok( elem->ns->length == 2, "got %u\n", elem->ns->length );
+ ok( elem->ns->length == 2, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "bytes not set\n" );
ok( !memcmp( elem->ns->bytes, "ns", 2 ), "wrong data\n" );
attr = elem->attributes[0];
ok( attr->isXmlNs, "isXmlNs is not set\n" );
ok( attr->prefix != NULL, "prefix not set\n" );
- ok( !attr->prefix->length, "got %u\n", attr->prefix->length );
+ ok( !attr->prefix->length, "got %lu\n", attr->prefix->length );
ok( attr->prefix->bytes == NULL, "bytes set\n" );
ok( attr->localName != NULL, "localName not set\n" );
- ok( attr->localName->length == 5, "got %u\n", attr->localName->length );
+ ok( attr->localName->length == 5, "got %lu\n", attr->localName->length );
ok( !memcmp( attr->localName->bytes, "xmlns", 5 ), "wrong data\n" );
ok( attr->ns != NULL, "ns not set\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( attr->ns->bytes != NULL, "bytes not set\n" );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong data\n" );
}
hr = set_input( reader, "<t xmlns:p='ns' xmlns:p='ns2'></t>", sizeof("<t xmlns:p='ns' xmlns:p='ns2'></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_input( reader, "<t xmlns:p='ns' xmlns:p='ns'></t>", sizeof("<t xmlns:p='ns' xmlns:p='ns'></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_input( reader, "<t xmlns:p='ns' xmlns:P='ns2'></t>", sizeof("<t xmlns:p='ns' xmlns:P='ns2'></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeReader( reader );
}
@@ -2983,10 +2983,10 @@ static void test_text_field_mapping(void)
} *test;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
prepare_struct_type_test( reader, "<a>test</a>" );
@@ -3004,7 +3004,7 @@ static void test_text_field_mapping(void)
test = NULL;
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
ok( test->str != NULL, "str not set\n" );
ok( !wcscmp( test->str, L"test" ), "got %s\n", wine_dbgstr_w(test->str) );
@@ -3053,35 +3053,35 @@ static void test_complex_struct_type(void)
prop.value = &langid;
prop.valueSize = sizeof(langid);
hr = WsCreateError( &prop, 1, &error );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* element content type mapping */
prepare_struct_type_test( reader, data );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
elem = (const WS_XML_ELEMENT_NODE *)node;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->localName->length == 12, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 12, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "OfficeConfig", 12 ), "wrong data\n" );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
elem = (const WS_XML_ELEMENT_NODE *)node;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->localName->length == 8, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 8, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "services", 8 ), "wrong data\n" );
memset( &f2, 0, sizeof(f2) );
@@ -3120,70 +3120,70 @@ static void test_complex_struct_type(void)
test = NULL;
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), error );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
ok( !wcscmp( test->services->generationtime, L"2015-09-03T18:47:54" ), "wrong data\n" );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadEndElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
hr = WsReadEndElement( reader, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
/* element type mapping */
prepare_struct_type_test( reader, data );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
elem = (const WS_XML_ELEMENT_NODE *)node;
ok( elem->node.nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", elem->node.nodeType );
- ok( elem->localName->length == 12, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 12, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "OfficeConfig", 12 ), "wrong data\n" );
test = NULL;
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), error );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
if (test) ok( !wcscmp( test->services->generationtime, L"2015-09-03T18:47:54" ), "wrong data\n" );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
/* trailing content */
prepare_struct_type_test( reader, data2 );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
s.structOptions = WS_STRUCT_IGNORE_TRAILING_ELEMENT_CONTENT;
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), error );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
prepare_struct_type_test( reader, data2 );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
s.structOptions = 0;
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), error );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
WsFreeReader( reader );
WsFreeHeap( heap );
@@ -3267,10 +3267,10 @@ static void test_repeating_element(void)
} *test5;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
prepare_struct_type_test( reader, data );
@@ -3307,10 +3307,10 @@ static void test_repeating_element(void)
test = NULL;
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
ok( test->service != NULL, "service not set\n" );
- ok( test->service_count == 2, "got %u\n", test->service_count );
+ ok( test->service_count == 2, "got %lu\n", test->service_count );
ok( test->service[0].id == 1, "got %u\n", test->service[0].id );
ok( test->service[1].id == 2, "got %u\n", test->service[1].id );
@@ -3320,11 +3320,11 @@ static void test_repeating_element(void)
test4 = NULL;
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test4, sizeof(test4), NULL );
- ok( hr == S_OK || broken(hr == E_INVALIDARG) /* win7 */, "got %08x\n", hr );
+ ok( hr == S_OK || broken(hr == E_INVALIDARG) /* win7 */, "got %#lx\n", hr );
if (test4)
{
ok( test4->service != NULL, "service not set\n" );
- ok( test4->service_count == 2, "got %u\n", test4->service_count );
+ ok( test4->service_count == 2, "got %lu\n", test4->service_count );
ok( test4->service[0]->id == 1, "got %u\n", test4->service[0]->id );
ok( test4->service[1]->id == 2, "got %u\n", test4->service[1]->id );
}
@@ -3338,10 +3338,10 @@ static void test_repeating_element(void)
test = NULL;
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
ok( test->service != NULL, "service not set\n" );
- ok( !test->service_count, "got %u\n", test->service_count );
+ ok( !test->service_count, "got %lu\n", test->service_count );
/* wrapper element */
prepare_struct_type_test( reader, data3 );
@@ -3351,10 +3351,10 @@ static void test_repeating_element(void)
test = NULL;
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
ok( test->service != NULL, "service not set\n" );
- ok( test->service_count == 2, "got %u\n", test->service_count );
+ ok( test->service_count == 2, "got %lu\n", test->service_count );
ok( test->service[0].id == 1, "got %u\n", test->service[0].id );
ok( test->service[1].id == 2, "got %u\n", test->service[1].id );
@@ -3369,10 +3369,10 @@ static void test_repeating_element(void)
test2 = NULL;
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test2, sizeof(test2), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test2 != NULL, "test2 not set\n" );
ok( test2->service != NULL, "service not set\n" );
- ok( test2->service_count == 2, "got %u\n", test2->service_count );
+ ok( test2->service_count == 2, "got %lu\n", test2->service_count );
ok( !wcscmp( test2->service[0].id, L"1" ), "wrong data\n" );
ok( !wcscmp( test2->service[1].id, L"2" ), "wrong data\n" );
@@ -3392,10 +3392,10 @@ static void test_repeating_element(void)
test3 = NULL;
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test3, sizeof(test3), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test3 != NULL, "test3 not set\n" );
ok( test3->service != NULL, "service not set\n" );
- ok( test3->service_count == 2, "got %u\n", test3->service_count );
+ ok( test3->service_count == 2, "got %lu\n", test3->service_count );
ok( !wcscmp( test3->service[0].name, L"1" ), "wrong data\n" );
ok( !wcscmp( test3->service[0].id, L"1" ), "wrong data\n" );
ok( !wcscmp( test3->service[1].name, L"2" ), "wrong data\n" );
@@ -3440,11 +3440,11 @@ static void test_repeating_element(void)
test5 = NULL;
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test5, sizeof(test5), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test5 != NULL, "test5 not set\n" );
ok( test5->service != NULL, "service not set\n" );
- ok( test5->service_count == 1, "got %u\n", test5->service_count );
- ok( !test5->service[0].name.length, "got %u\n", test5->service[0].name.length );
+ ok( test5->service_count == 1, "got %lu\n", test5->service_count );
+ ok( !test5->service[0].name.length, "got %lu\n", test5->service[0].name.length );
todo_wine ok( test5->service[0].name.chars != NULL, "chars set\n" );
WsFreeReader( reader );
@@ -3460,67 +3460,67 @@ static void test_WsResetHeap(void)
void *ptr;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
requested = 0xdeadbeef;
size = sizeof(requested);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_REQUESTED_SIZE, &requested, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !requested, "got %u\n", (ULONG)requested );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !requested, "got %Iu\n", requested );
actual = 0xdeadbeef;
size = sizeof(actual);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_ACTUAL_SIZE, &actual, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !actual, "got %u\n", (ULONG)actual );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !actual, "got %Iu\n", actual );
hr = WsAlloc( heap, 128, &ptr, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
requested = 0xdeadbeef;
size = sizeof(requested);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_REQUESTED_SIZE, &requested, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( requested == 128, "got %u\n", (ULONG)requested );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( requested == 128, "got %Iu\n", requested );
actual = 0xdeadbeef;
size = sizeof(actual);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_ACTUAL_SIZE, &actual, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( actual == 128, "got %u\n", (ULONG)actual );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( actual == 128, "got %Iu\n", actual );
hr = WsAlloc( heap, 1, &ptr, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
requested = 0xdeadbeef;
size = sizeof(requested);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_REQUESTED_SIZE, &requested, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( requested == 129, "got %u\n", (ULONG)requested );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( requested == 129, "got %Iu\n", requested );
actual = 0xdeadbeef;
size = sizeof(actual);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_ACTUAL_SIZE, &actual, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- todo_wine ok( actual == 384, "got %u\n", (ULONG)actual );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ todo_wine ok( actual == 384, "got %Iu\n", actual );
hr = WsResetHeap( NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsResetHeap( heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
requested = 0xdeadbeef;
size = sizeof(requested);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_REQUESTED_SIZE, &requested, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !requested, "got %u\n", (ULONG)requested );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !requested, "got %Iu\n", requested );
actual = 0xdeadbeef;
size = sizeof(actual);
hr = WsGetHeapProperty( heap, WS_HEAP_PROPERTY_ACTUAL_SIZE, &actual, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- todo_wine ok( actual == 128, "got %u\n", (ULONG)actual );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ todo_wine ok( actual == 128, "got %Iu\n", actual );
WsFreeHeap( heap );
}
@@ -3588,21 +3588,21 @@ static void test_datetime(void)
ULONG i;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
memset( &date, 0, sizeof(date) );
prepare_type_test( reader, tests[i].str, strlen(tests[i].str) );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_DATETIME_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &date, sizeof(date), NULL );
- ok( hr == tests[i].hr, "%u: got %08x\n", i, hr );
+ ok( hr == tests[i].hr, "%lu: got %#lx\n", i, hr );
if (hr == S_OK)
{
- ok( date.ticks == tests[i].ticks, "%u: got %s\n", i, wine_dbgstr_longlong(date.ticks) );
- ok( date.format == tests[i].format, "%u: got %u\n", i, date.format );
+ ok( date.ticks == tests[i].ticks, "%lu: got %s\n", i, wine_dbgstr_longlong(date.ticks) );
+ ok( date.format == tests[i].format, "%lu: got %u\n", i, date.format );
}
}
@@ -3634,25 +3634,25 @@ static void test_WsDateTimeToFileTime(void)
ULONG i;
hr = WsDateTimeToFileTime( NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
dt.ticks = 0x701ce172277000;
dt.format = WS_DATETIME_FORMAT_UTC;
hr = WsDateTimeToFileTime( &dt, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsDateTimeToFileTime( NULL, &ft, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
memset( &ft, 0, sizeof(ft) );
hr = WsDateTimeToFileTime( &tests[i].dt, &ft, NULL );
- ok( hr == tests[i].hr, "%u: got %08x\n", i, hr );
+ ok( hr == tests[i].hr, "%lu: got %#lx\n", i, hr );
if (hr == S_OK)
{
- ok( ft.dwLowDateTime == tests[i].ft.dwLowDateTime, "%u: got %08x\n", i, ft.dwLowDateTime );
- ok( ft.dwHighDateTime == tests[i].ft.dwHighDateTime, "%u: got %08x\n", i, ft.dwHighDateTime );
+ ok( ft.dwLowDateTime == tests[i].ft.dwLowDateTime, "%lu: got %#lx\n", i, ft.dwLowDateTime );
+ ok( ft.dwHighDateTime == tests[i].ft.dwHighDateTime, "%lu: got %#lx\n", i, ft.dwHighDateTime );
}
}
}
@@ -3664,41 +3664,41 @@ static void test_WsFileTimeToDateTime(void)
HRESULT hr;
hr = WsFileTimeToDateTime( NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
ft.dwLowDateTime = ft.dwHighDateTime = 0;
hr = WsFileTimeToDateTime( &ft, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsFileTimeToDateTime( NULL, &dt, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
dt.ticks = 0xdeadbeef;
dt.format = 0xdeadbeef;
hr = WsFileTimeToDateTime( &ft, &dt, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( dt.ticks == 0x701ce1722770000, "got %s\n", wine_dbgstr_longlong(dt.ticks) );
ok( dt.format == WS_DATETIME_FORMAT_UTC, "got %u\n", dt.format );
ft.dwLowDateTime = 0xd1c03fff;
ft.dwHighDateTime = 0x24c85a5e;
hr = WsFileTimeToDateTime( &ft, &dt, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( dt.ticks == 0x2bca2875f4373fff, "got %s\n", wine_dbgstr_longlong(dt.ticks) );
ok( dt.format == WS_DATETIME_FORMAT_UTC, "got %u\n", dt.format );
ft.dwLowDateTime++;
hr = WsFileTimeToDateTime( &ft, &dt, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
ft.dwLowDateTime = 0xdd88ffff;
ft.dwHighDateTime = 0xf8fe31e8;
hr = WsFileTimeToDateTime( &ft, &dt, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
ft.dwLowDateTime++;
hr = WsFileTimeToDateTime( &ft, &dt, NULL );
- ok( hr == WS_E_NUMERIC_OVERFLOW, "got %08x\n", hr );
+ ok( hr == WS_E_NUMERIC_OVERFLOW, "got %#lx\n", hr );
}
static void test_double(void)
@@ -3780,10 +3780,10 @@ static void test_double(void)
ULONG i;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
@@ -3791,8 +3791,8 @@ static void test_double(void)
prepare_type_test( reader, tests[i].str, strlen(tests[i].str) );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_DOUBLE_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val, sizeof(val), NULL );
- ok( hr == tests[i].hr, "%u: got %08x\n", i, hr );
- if (hr == tests[i].hr) ok( val == tests[i].val, "%u: got %s\n", i, wine_dbgstr_longlong(val) );
+ ok( hr == tests[i].hr, "%lu: got %#lx\n", i, hr );
+ if (hr == tests[i].hr) ok( val == tests[i].val, "%lu: got %s\n", i, wine_dbgstr_longlong(val) );
}
WsFreeReader( reader );
@@ -3808,7 +3808,7 @@ static void test_WsReadElement(void)
UINT32 val;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
desc.elementLocalName = &localname;
desc.elementNs = &ns;
@@ -3817,20 +3817,20 @@ static void test_WsReadElement(void)
prepare_struct_type_test( reader, "<t>1</t>" );
hr = WsReadElement( NULL, &desc, WS_READ_REQUIRED_VALUE, NULL, &val, sizeof(val), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
prepare_struct_type_test( reader, "<t>1</t>" );
hr = WsReadElement( reader, NULL, WS_READ_REQUIRED_VALUE, NULL, &val, sizeof(val), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
prepare_struct_type_test( reader, "<t>1</t>" );
hr = WsReadElement( reader, &desc, WS_READ_REQUIRED_VALUE, NULL, NULL, sizeof(val), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
prepare_struct_type_test( reader, "<t>1</t>" );
val = 0xdeadbeef;
hr = WsReadElement( reader, &desc, WS_READ_REQUIRED_VALUE, NULL, &val, sizeof(val), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val == 1, "got %u\n", val );
WsFreeReader( reader );
@@ -3843,46 +3843,46 @@ static void test_WsReadValue(void)
UINT32 val;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
prepare_struct_type_test( reader, "<t>1</t>" );
hr = WsReadValue( NULL, WS_UINT32_VALUE_TYPE, &val, sizeof(val), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
prepare_struct_type_test( reader, "<t>1</t>" );
hr = WsReadValue( reader, WS_UINT32_VALUE_TYPE, NULL, sizeof(val), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
/* reader must be positioned correctly */
prepare_struct_type_test( reader, "<t>1</t>" );
hr = WsReadValue( reader, WS_UINT32_VALUE_TYPE, &val, sizeof(val), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_struct_type_test( reader, "<t>1</t>" );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadValue( reader, WS_UINT32_VALUE_TYPE, &val, sizeof(val), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
prepare_struct_type_test( reader, "<t>1</t>" );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
val = 0xdeadbeef;
hr = WsReadValue( reader, WS_UINT32_VALUE_TYPE, &val, sizeof(val), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val == 1, "got %u\n", val );
prepare_struct_type_test( reader, "<u t='1'></u>" );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadValue( reader, WS_UINT32_VALUE_TYPE, &val, sizeof(val), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
WsFreeReader( reader );
}
@@ -3896,26 +3896,26 @@ static void test_WsResetError(void)
HRESULT hr;
hr = WsResetError( NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
error = NULL;
hr = WsCreateError( NULL, 0, &error );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( error != NULL, "error not set\n" );
code = 0xdeadbeef;
size = sizeof(code);
hr = WsSetErrorProperty( error, WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE, &code, size );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsResetError( error );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
code = 0xdeadbeef;
size = sizeof(code);
hr = WsGetErrorProperty( error, WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE, &code, size );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !code, "got %u\n", code );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !code, "got %lu\n", code );
WsFreeError( error );
@@ -3924,21 +3924,21 @@ static void test_WsResetError(void)
prop.value = &langid;
prop.valueSize = sizeof(langid);
hr = WsCreateError( &prop, 1, &error );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
langid = 0xdead;
size = sizeof(langid);
hr = WsGetErrorProperty( error, WS_ERROR_PROPERTY_LANGID, &langid, size );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( langid == MAKELANGID( LANG_DUTCH, SUBLANG_DEFAULT ), "got %u\n", langid );
hr = WsResetError( error );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
langid = 0xdead;
size = sizeof(langid);
hr = WsGetErrorProperty( error, WS_ERROR_PROPERTY_LANGID, &langid, size );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( langid == MAKELANGID( LANG_DUTCH, SUBLANG_DEFAULT ), "got %u\n", langid );
WsFreeError( error );
@@ -3953,36 +3953,36 @@ static void test_WsGetReaderPosition(void)
HRESULT hr;
hr = WsGetReaderPosition( NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* reader must be set to an XML buffer */
hr = WsGetReaderPosition( reader, &pos, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_input( reader, "<t/>", sizeof("<t/>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderPosition( reader, &pos, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetInputToBuffer( reader, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderPosition( reader, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
pos.buffer = pos.node = NULL;
hr = WsGetReaderPosition( reader, &pos, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( pos.buffer != NULL, "buffer not set\n" );
ok( pos.node != NULL, "node not set\n" );
@@ -3999,39 +3999,39 @@ static void test_WsSetReaderPosition(void)
HRESULT hr;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetReaderPosition( NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buf1, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetInputToBuffer( reader, buf1, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetReaderPosition( reader, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
pos.buffer = pos.node = NULL;
hr = WsGetReaderPosition( reader, &pos, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( pos.buffer == buf1, "wrong buffer\n" );
ok( pos.node != NULL, "node not set\n" );
hr = WsSetReaderPosition( reader, &pos, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* different buffer */
hr = WsCreateXmlBuffer( heap, NULL, 0, &buf2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
pos.buffer = buf2;
hr = WsSetReaderPosition( reader, &pos, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeReader( reader );
WsFreeHeap( heap );
@@ -4131,39 +4131,39 @@ static void test_entities(void)
ULONG i;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
hr = set_input( reader, tests[i].str, strlen(tests[i].str) );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsReadNode( reader, NULL );
- ok( hr == tests[i].hr, "%u: got %08x\n", i, hr );
+ ok( hr == tests[i].hr, "%lu: got %#lx\n", i, hr );
if (hr != S_OK) continue;
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
utf8 = (const WS_XML_UTF8_TEXT *)((const WS_XML_TEXT_NODE *)node)->text;
- ok( utf8->value.length == strlen(tests[i].res), "%u: got %u\n", i, utf8->value.length );
- ok( !memcmp( utf8->value.bytes, tests[i].res, strlen(tests[i].res) ), "%u: wrong data\n", i );
+ ok( utf8->value.length == strlen(tests[i].res), "%lu: got %lu\n", i, utf8->value.length );
+ ok( !memcmp( utf8->value.bytes, tests[i].res, strlen(tests[i].res) ), "%lu: wrong data\n", i );
}
hr = set_input( reader, "<t a='

'/>", sizeof("<t a='

'/>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
utf8 = (const WS_XML_UTF8_TEXT *)((const WS_XML_ELEMENT_NODE *)node)->attributes[0]->value;
- ok( utf8->value.length == 2, "got %u\n", utf8->value.length );
+ ok( utf8->value.length == 2, "got %lu\n", utf8->value.length );
ok( !memcmp( utf8->value.bytes, "\n\n", 2 ), "wrong data\n" );
WsFreeReader( reader );
@@ -4196,13 +4196,13 @@ static void test_field_options(void)
} *test;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, xml, sizeof(xml) - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_ELEMENT_FIELD_MAPPING;
@@ -4266,7 +4266,7 @@ static void test_field_options(void)
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( !test->wsz, "wsz is set\n" );
ok( !test->s, "s is set\n" );
ok( test->int32 == -1, "got %d\n", test->int32 );
@@ -4287,106 +4287,106 @@ static void test_WsReadBytes(void)
ULONG count;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadBytes( NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadBytes( reader, NULL, 0, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_input( reader, "<t>dGV4dA==</t>", sizeof("<t>dGV4dA==</t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadBytes( reader, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_input( reader, "<t>dGV4dA==</t>", sizeof("<t>dGV4dA==</t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadBytes( reader, buf, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_input( reader, "<t>dGV4dA==</t>", sizeof("<t>dGV4dA==</t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
count = 0xdeadbeef;
hr = WsReadBytes( reader, NULL, 0, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
count = 0xdeadbeef;
hr = WsReadBytes( reader, NULL, 1, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadBytes( reader, buf, 0, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
ok( !buf[0], "wrong data\n" );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadBytes( reader, buf, 2, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
ok( !buf[0], "wrong data\n" );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadBytes( reader, buf, 2, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
ok( !buf[0], "wrong data\n" );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
count = 0xdeadbeef;
hr = WsReadBytes( reader, NULL, 0, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadBytes( reader, buf, 2, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( count == 2, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( count == 2, "got %lu\n", count );
ok( !memcmp( buf, "te", 2 ), "wrong data\n" );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text = (const WS_XML_TEXT_NODE *)node;
ok( text->node.nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", text->node.nodeType );
utf8 = (const WS_XML_UTF8_TEXT *)text->text;
ok( text->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text->text->textType );
- ok( utf8->value.length == 8, "got %u\n", utf8->value.length );
+ ok( utf8->value.length == 8, "got %lu\n", utf8->value.length );
ok( !memcmp( utf8->value.bytes, "dGV4dA==", 8 ), "wrong data\n" );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadBytes( reader, buf, 2, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( count == 2, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( count == 2, "got %lu\n", count );
ok( !memcmp( buf, "xt", 2 ), "wrong data\n" );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text = (const WS_XML_TEXT_NODE *)node;
ok( text->node.nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", text->node.nodeType );
count = 0xdeadbeef;
hr = WsReadBytes( reader, buf, 1, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text = (const WS_XML_TEXT_NODE *)node;
ok( text->node.nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", text->node.nodeType );
@@ -4405,107 +4405,107 @@ static void test_WsReadChars(void)
ULONG count;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadChars( NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadChars( reader, NULL, 0, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_input( reader, "<t>text</t>", sizeof("<t>text</t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadChars( reader, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_input( reader, "<t>text</t>", sizeof("<t>text</t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadChars( reader, bufW, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_input( reader, "<t>text</t>", sizeof("<t>text</t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
count = 0xdeadbeef;
hr = WsReadChars( reader, NULL, 0, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
count = 0xdeadbeef;
hr = WsReadChars( reader, NULL, 1, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadChars( reader, bufW, 0, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
ok( !buf[0], "wrong data\n" );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadChars( reader, bufW, 2, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
ok( !buf[0], "wrong data\n" );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadChars( reader, bufW, 2, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
ok( !buf[0], "wrong data\n" );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
count = 0xdeadbeef;
hr = WsReadChars( reader, NULL, 0, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadChars( reader, bufW, 2, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( count == 2, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( count == 2, "got %lu\n", count );
ok( !memcmp( bufW, L"te", 2 * sizeof(WCHAR) ), "wrong data\n" );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text = (const WS_XML_TEXT_NODE *)node;
ok( text->node.nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", text->node.nodeType );
utf8 = (const WS_XML_UTF8_TEXT *)text->text;
ok( text->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text->text->textType );
- ok( utf8->value.length == 4, "got %u\n", utf8->value.length );
+ ok( utf8->value.length == 4, "got %lu\n", utf8->value.length );
ok( !memcmp( utf8->value.bytes, "text", 4 ), "wrong data\n" );
/* continue reading in a different encoding */
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadCharsUtf8( reader, buf, 2, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( count == 2, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( count == 2, "got %lu\n", count );
ok( !memcmp( buf, "xt", 2 ), "wrong data\n" );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text = (const WS_XML_TEXT_NODE *)node;
ok( text->node.nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", text->node.nodeType );
count = 0xdeadbeef;
hr = WsReadCharsUtf8( reader, buf, 1, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text = (const WS_XML_TEXT_NODE *)node;
ok( text->node.nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", text->node.nodeType );
@@ -4523,106 +4523,106 @@ static void test_WsReadCharsUtf8(void)
ULONG count;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadCharsUtf8( NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadCharsUtf8( reader, NULL, 0, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_input( reader, "<t>text</t>", sizeof("<t>text</t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadCharsUtf8( reader, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_input( reader, "<t>text</t>", sizeof("<t>text</t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadCharsUtf8( reader, buf, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_input( reader, "<t>text</t>", sizeof("<t>text</t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
count = 0xdeadbeef;
hr = WsReadCharsUtf8( reader, NULL, 0, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
count = 0xdeadbeef;
hr = WsReadCharsUtf8( reader, NULL, 1, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadCharsUtf8( reader, buf, 0, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
ok( !buf[0], "wrong data\n" );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadCharsUtf8( reader, buf, 2, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
ok( !buf[0], "wrong data\n" );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadCharsUtf8( reader, buf, 2, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
ok( !buf[0], "wrong data\n" );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
count = 0xdeadbeef;
hr = WsReadCharsUtf8( reader, NULL, 0, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadCharsUtf8( reader, buf, 2, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( count == 2, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( count == 2, "got %lu\n", count );
ok( !memcmp( buf, "te", 2 ), "wrong data\n" );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text = (const WS_XML_TEXT_NODE *)node;
ok( text->node.nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", text->node.nodeType );
utf8 = (const WS_XML_UTF8_TEXT *)text->text;
ok( text->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text->text->textType );
- ok( utf8->value.length == 4, "got %u\n", utf8->value.length );
+ ok( utf8->value.length == 4, "got %lu\n", utf8->value.length );
ok( !memcmp( utf8->value.bytes, "text", 4 ), "wrong data\n" );
buf[0] = 0;
count = 0xdeadbeef;
hr = WsReadCharsUtf8( reader, buf, 2, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( count == 2, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( count == 2, "got %lu\n", count );
ok( !memcmp( buf, "xt", 2 ), "wrong data\n" );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text = (const WS_XML_TEXT_NODE *)node;
ok( text->node.nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", text->node.nodeType );
count = 0xdeadbeef;
hr = WsReadCharsUtf8( reader, buf, 1, &count, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !count, "got %u\n", count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !count, "got %lu\n", count );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text = (const WS_XML_TEXT_NODE *)node;
ok( text->node.nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", text->node.nodeType );
@@ -4672,66 +4672,66 @@ static void test_WsReadQualifiedName(void)
};
hr = WsReadQualifiedName( NULL, NULL, NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadQualifiedName( reader, NULL, NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadQualifiedName( reader, heap, NULL, NULL, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_input( reader, "<t/>", sizeof("<t/>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadQualifiedName( reader, heap, NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_input( reader, "<t/>", sizeof("<t/>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadQualifiedName( reader, heap, NULL, &localname, NULL, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
hr = set_input( reader, tests[i].str, strlen(tests[i].str) );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
prefix.length = localname.length = ns.length = 0xdeadbeef;
prefix.bytes = localname.bytes = ns.bytes = (BYTE *)0xdeadbeef;
hr = WsReadQualifiedName( reader, heap, &prefix, &localname, &ns, NULL );
- ok( hr == tests[i].hr, "%u: got %08x\n", i, hr );
+ ok( hr == tests[i].hr, "%lu: got %#lx\n", i, hr );
if (tests[i].hr == S_OK && hr == S_OK)
{
- ok( prefix.length == strlen( tests[i].prefix ), "%u: got %u\n", i, prefix.length );
- ok( !memcmp( prefix.bytes, tests[i].prefix, prefix.length ), "%u: wrong data\n", i );
+ ok( prefix.length == strlen( tests[i].prefix ), "%lu: got %lu\n", i, prefix.length );
+ ok( !memcmp( prefix.bytes, tests[i].prefix, prefix.length ), "%lu: wrong data\n", i );
- ok( localname.length == strlen( tests[i].localname ), "%u: got %u\n", i, localname.length );
- ok( !memcmp( localname.bytes, tests[i].localname, localname.length ), "%u: wrong data\n", i );
+ ok( localname.length == strlen( tests[i].localname ), "%lu: got %lu\n", i, localname.length );
+ ok( !memcmp( localname.bytes, tests[i].localname, localname.length ), "%lu: wrong data\n", i );
- ok( ns.length == strlen( tests[i].ns ), "%u: got %u\n", i, ns.length );
- ok( !memcmp( ns.bytes, tests[i].ns, ns.length ), "%u: wrong data\n", i );
+ ok( ns.length == strlen( tests[i].ns ), "%lu: got %lu\n", i, ns.length );
+ ok( !memcmp( ns.bytes, tests[i].ns, ns.length ), "%lu: wrong data\n", i );
}
else if (tests[i].hr != S_OK)
{
- ok( prefix.length == 0xdeadbeef, "got %u\n", prefix.length );
+ ok( prefix.length == 0xdeadbeef, "got %lu\n", prefix.length );
ok( prefix.bytes == (BYTE *)0xdeadbeef, "got %p\n", prefix.bytes );
- ok( localname.length == 0xdeadbeef, "got %u\n", localname.length );
+ ok( localname.length == 0xdeadbeef, "got %lu\n", localname.length );
ok( localname.bytes == (BYTE *)0xdeadbeef, "got %p\n", localname.bytes );
- ok( ns.length == 0xdeadbeef, "got %u\n", ns.length );
+ ok( ns.length == 0xdeadbeef, "got %lu\n", ns.length );
ok( ns.bytes == (BYTE *)0xdeadbeef, "got %p\n", ns.bytes );
}
}
@@ -4751,40 +4751,40 @@ static void test_WsReadAttribute(void)
HRESULT hr;
hr = WsReadAttribute( NULL, NULL, 0, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadAttribute( reader, NULL, 0, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
desc.attributeLocalName = &localname;
desc.attributeNs = &ns;
desc.type = WS_UINT32_TYPE;
desc.typeDescription = NULL;
hr = WsReadAttribute( reader, &desc, 0, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadAttribute( reader, &desc, WS_READ_REQUIRED_POINTER, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 8, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadAttribute( reader, &desc, WS_READ_REQUIRED_POINTER, heap, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsReadAttribute( reader, &desc, WS_READ_REQUIRED_POINTER, heap, &val, sizeof(val), NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
prepare_struct_type_test( reader, "<t a='1'>" );
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
val = NULL;
hr = WsReadAttribute( reader, &desc, WS_READ_REQUIRED_POINTER, heap, &val, sizeof(val), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( val != NULL, "val not set\n" );
ok( *val == 1, "got %u\n", *val );
@@ -4799,53 +4799,53 @@ static void test_WsSkipNode(void)
HRESULT hr;
hr = WsSkipNode( NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSkipNode( reader, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_input( reader, "<t><u></u></t>", sizeof("<t><u></u></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
/* BOF */
hr = WsSkipNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
/* element */
hr = WsSkipNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
/* EOF */
hr = WsSkipNode( reader, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_input( reader, "<!--comment--><t></t>", sizeof("<!--comment--><t></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* non-element */
hr = WsSkipNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_COMMENT, "got %u\n", node->nodeType );
hr = WsSkipNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
WsFreeReader( reader );
@@ -4985,147 +4985,147 @@ static void test_binary_encoding(void)
} *typetest3;
hr = WsGetDictionary( WS_ENCODING_XML_BINARY_1, &dict, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* short element */
hr = set_input_bin( reader, test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
ok( elem->prefix->bytes == NULL, "bytes set\n" );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
ok( elem->localName->dictionary != NULL, "dictionary not set\n" );
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "bytes not set\n" );
- ok( !elem->attributeCount, "got %u\n", elem->attributeCount );
+ ok( !elem->attributeCount, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* single character prefix element */
hr = set_input_bin( reader, test2, sizeof(test2), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( elem->prefix->length == 1, "got %u\n", elem->prefix->length );
+ ok( elem->prefix->length == 1, "got %lu\n", elem->prefix->length );
ok( !memcmp( elem->prefix->bytes, "p", 1 ), "wrong prefix\n" );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( elem->ns->length == 2, "got %u\n", elem->ns->length );
+ ok( elem->ns->length == 2, "got %lu\n", elem->ns->length );
ok( !memcmp( elem->ns->bytes, "ns", 2 ), "wrong namespace\n" );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( attr->prefix->length == 1, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 1, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p", 1 ), "wrong prefix\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* element */
hr = set_input_bin( reader, test3, sizeof(test3), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( elem->prefix->length == 2, "got %u\n", elem->prefix->length );
+ ok( elem->prefix->length == 2, "got %lu\n", elem->prefix->length );
ok( !memcmp( elem->prefix->bytes, "p2", 2 ), "wrong prefix\n" );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( elem->ns->length == 2, "got %u\n", elem->ns->length );
+ ok( elem->ns->length == 2, "got %lu\n", elem->ns->length );
ok( !memcmp( elem->ns->bytes, "ns", 2 ), "wrong namespace\n" );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( attr->prefix->length == 2, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 2, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p2", 2 ), "wrong prefix\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* element with text */
hr = set_input_bin( reader, test4, sizeof(test4), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( elem->prefix->length == 2, "got %u\n", elem->prefix->length );
+ ok( elem->prefix->length == 2, "got %lu\n", elem->prefix->length );
ok( !memcmp( elem->prefix->bytes, "p2", 2 ), "wrong prefix\n" );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( elem->ns->length == 2, "got %u\n", elem->ns->length );
+ ok( elem->ns->length == 2, "got %lu\n", elem->ns->length );
ok( !memcmp( elem->ns->bytes, "ns", 2 ), "wrong namespace\n" );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( attr->prefix->length == 2, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 2, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p2", 2 ), "wrong prefix\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", node->nodeType );
text_node = (const WS_XML_TEXT_NODE *)node;
ok( text_node->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text_node->text->textType );
utf8_text = (const WS_XML_UTF8_TEXT *)text_node->text;
- ok( utf8_text->value.length == 4, "got %u\n", utf8_text->value.length );
+ ok( utf8_text->value.length == 4, "got %lu\n", utf8_text->value.length );
ok( !memcmp( utf8_text->value.bytes, "test", 4 ), "wrong text\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* bool text, TRUE */
hr = set_input_bin( reader, test7, sizeof(test7), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_BOOL, "got %u\n", text_node->text->textType );
@@ -5134,7 +5134,7 @@ static void test_binary_encoding(void)
/* bool text, FALSE */
hr = set_input_bin( reader, test8, sizeof(test8), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_BOOL, "got %u\n", text_node->text->textType );
@@ -5143,7 +5143,7 @@ static void test_binary_encoding(void)
/* zero text */
hr = set_input_bin( reader, test9, sizeof(test9), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_INT32, "got %u\n", text_node->text->textType );
@@ -5152,7 +5152,7 @@ static void test_binary_encoding(void)
/* one text */
hr = set_input_bin( reader, test10, sizeof(test10), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_INT32, "got %u\n", text_node->text->textType );
@@ -5161,7 +5161,7 @@ static void test_binary_encoding(void)
/* false text */
hr = set_input_bin( reader, test11, sizeof(test11), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_BOOL, "got %u\n", text_node->text->textType );
@@ -5170,7 +5170,7 @@ static void test_binary_encoding(void)
/* true text */
hr = set_input_bin( reader, test12, sizeof(test12), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_BOOL, "got %u\n", text_node->text->textType );
@@ -5179,7 +5179,7 @@ static void test_binary_encoding(void)
/* int32 text, int8 record */
hr = set_input_bin( reader, test13, sizeof(test13), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_INT32, "got %u\n", text_node->text->textType );
@@ -5188,7 +5188,7 @@ static void test_binary_encoding(void)
/* int32 text, int16 record */
hr = set_input_bin( reader, test14, sizeof(test14), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_INT32, "got %u\n", text_node->text->textType );
@@ -5197,7 +5197,7 @@ static void test_binary_encoding(void)
/* int32 text, int32 record */
hr = set_input_bin( reader, test15, sizeof(test15), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_INT32, "got %u\n", text_node->text->textType );
@@ -5206,7 +5206,7 @@ static void test_binary_encoding(void)
/* int64 text, int64 record */
hr = set_input_bin( reader, test16, sizeof(test16), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_INT64, "got %u\n", text_node->text->textType );
@@ -5215,7 +5215,7 @@ static void test_binary_encoding(void)
/* double text */
hr = set_input_bin( reader, test17, sizeof(test17), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_DOUBLE, "got %u\n", text_node->text->textType );
@@ -5224,7 +5224,7 @@ static void test_binary_encoding(void)
/* datetime text */
hr = set_input_bin( reader, test18, sizeof(test18), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_DATETIME, "got %u\n", text_node->text->textType );
@@ -5234,88 +5234,88 @@ static void test_binary_encoding(void)
/* utf8 text, chars8 record */
hr = set_input_bin( reader, test19, sizeof(test19), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text_node->text->textType );
utf8_text = (WS_XML_UTF8_TEXT *)text_node->text;
- ok( utf8_text->value.length == 1, "got %u\n", utf8_text->value.length );
+ ok( utf8_text->value.length == 1, "got %lu\n", utf8_text->value.length );
ok( utf8_text->value.bytes[0] == 'a', "got %02x\n", utf8_text->value.bytes[0] );
/* utf8 text, chars16 record */
hr = set_input_bin( reader, test20, sizeof(test20), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text_node->text->textType );
utf8_text = (WS_XML_UTF8_TEXT *)text_node->text;
- ok( utf8_text->value.length == 1, "got %u\n", utf8_text->value.length );
+ ok( utf8_text->value.length == 1, "got %lu\n", utf8_text->value.length );
ok( utf8_text->value.bytes[0] == 'a', "got %02x\n", utf8_text->value.bytes[0] );
/* utf8 text, chars32 record */
hr = set_input_bin( reader, test21, sizeof(test21), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text_node->text->textType );
utf8_text = (WS_XML_UTF8_TEXT *)text_node->text;
- ok( utf8_text->value.length == 1, "got %u\n", utf8_text->value.length );
+ ok( utf8_text->value.length == 1, "got %lu\n", utf8_text->value.length );
ok( utf8_text->value.bytes[0] == 'a', "got %02x\n", utf8_text->value.bytes[0] );
/* base64 text, bytes8 record */
hr = set_input_bin( reader, test22, sizeof(test22), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_BASE64, "got %u\n", text_node->text->textType );
base64_text = (WS_XML_BASE64_TEXT *)text_node->text;
- ok( base64_text->length == 1, "got %u\n", base64_text->length );
+ ok( base64_text->length == 1, "got %lu\n", base64_text->length );
ok( base64_text->bytes[0] == 'a', "got %02x\n", base64_text->bytes[0] );
/* base64 text, bytes16 record */
hr = set_input_bin( reader, test23, sizeof(test23), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_BASE64, "got %u\n", text_node->text->textType );
base64_text = (WS_XML_BASE64_TEXT *)text_node->text;
- ok( base64_text->length == 1, "got %u\n", base64_text->length );
+ ok( base64_text->length == 1, "got %lu\n", base64_text->length );
ok( base64_text->bytes[0] == 'a', "got %02x\n", base64_text->bytes[0] );
/* base64 text, bytes32 record */
hr = set_input_bin( reader, test24, sizeof(test24), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_BASE64, "got %u\n", text_node->text->textType );
base64_text = (WS_XML_BASE64_TEXT *)text_node->text;
- ok( base64_text->length == 1, "got %u\n", base64_text->length );
+ ok( base64_text->length == 1, "got %lu\n", base64_text->length );
ok( base64_text->bytes[0] == 'a', "got %02x\n", base64_text->bytes[0] );
/* empty text */
hr = set_input_bin( reader, test25, sizeof(test25), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text_node->text->textType );
utf8_text = (WS_XML_UTF8_TEXT *)text_node->text;
- ok( !utf8_text->value.length, "got %u\n", utf8_text->value.length );
+ ok( !utf8_text->value.length, "got %lu\n", utf8_text->value.length );
ok( utf8_text->value.bytes != NULL, "bytes not set\n" );
/* dictionary text */
hr = set_input_bin( reader, test26, sizeof(test26), dict );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text_node->text->textType );
utf8_text = (WS_XML_UTF8_TEXT *)text_node->text;
- ok( utf8_text->value.length == 2, "got %u\n", utf8_text->value.length );
+ ok( utf8_text->value.length == 2, "got %lu\n", utf8_text->value.length );
ok( utf8_text->value.bytes[0] == 'T', "got %02x\n", utf8_text->value.bytes[0] );
ok( utf8_text->value.bytes[1] == 'o', "got %02x\n", utf8_text->value.bytes[0] );
/* unique id text */
hr = set_input_bin( reader, test27, sizeof(test27), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_UNIQUE_ID, "got %u\n", text_node->text->textType );
@@ -5324,7 +5324,7 @@ static void test_binary_encoding(void)
/* guid text */
hr = set_input_bin( reader, test28, sizeof(test28), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_GUID, "got %u\n", text_node->text->textType );
@@ -5333,7 +5333,7 @@ static void test_binary_encoding(void)
/* uint64 text */
hr = set_input_bin( reader, test29, sizeof(test29), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text_node = read_text_node( reader );
ok( text_node != NULL, "no text\n" );
ok( text_node->text->textType == WS_XML_TEXT_TYPE_UINT64, "got %u\n", text_node->text->textType );
@@ -5342,282 +5342,282 @@ static void test_binary_encoding(void)
/* short xmlns attribute */
hr = set_input_bin( reader, test30, sizeof(test30), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
ok( elem->prefix->bytes == NULL, "bytes set\n" );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( elem->ns->length == 2, "got %u\n", elem->ns->length );
+ ok( elem->ns->length == 2, "got %lu\n", elem->ns->length );
ok( !memcmp( elem->ns->bytes, "ns", 2 ), "wrong namespace\n" );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( !attr->prefix->length, "got %u\n", attr->prefix->length );
+ ok( !attr->prefix->length, "got %lu\n", attr->prefix->length );
ok( attr->prefix->bytes == NULL, "bytes set\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
/* xmlns attribute */
hr = set_input_bin( reader, test31, sizeof(test31), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
ok( elem->prefix->bytes == NULL, "bytes set\n" );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "bytes not set\n" );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( attr->prefix->length == 1, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 1, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p", 1 ), "wrong prefix\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
/* short attribute */
hr = set_input_bin( reader, test100, sizeof(test100), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "bytes not set\n" );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( !attr->isXmlNs, "is xmlns\n" );
- ok( !attr->prefix->length, "got %u\n", attr->prefix->length );
- ok( attr->localName->length == 1, "got %u\n", attr->localName->length );
+ ok( !attr->prefix->length, "got %lu\n", attr->prefix->length );
+ ok( attr->localName->length == 1, "got %lu\n", attr->localName->length );
ok( !memcmp( attr->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( !attr->ns->length, "got %u\n", attr->ns->length );
+ ok( !attr->ns->length, "got %lu\n", attr->ns->length );
ok( elem->ns->bytes != NULL, "bytes not set\n" );
ok( attr->value != NULL, "value not set\n" );
utf8_text = (const WS_XML_UTF8_TEXT *)attr->value;
ok( utf8_text->text.textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", utf8_text->text.textType );
- ok( !utf8_text->value.length, "got %u\n", utf8_text->value.length );
+ ok( !utf8_text->value.length, "got %lu\n", utf8_text->value.length );
ok( utf8_text->value.bytes != NULL, "bytes not set\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* single character prefix attribute */
hr = set_input_bin( reader, test101, sizeof(test101), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "ns not set\n" );
- ok( elem->attributeCount == 2, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 2, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( !attr->isXmlNs, "is xmlns\n" );
- ok( attr->prefix->length == 1, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 1, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p", 1 ), "wrong prefix\n" );
- ok( attr->localName->length == 1, "got %u\n", attr->localName->length );
+ ok( attr->localName->length == 1, "got %lu\n", attr->localName->length );
ok( !memcmp( attr->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
ok( attr->value != NULL, "value not set\n" );
utf8_text = (const WS_XML_UTF8_TEXT *)attr->value;
ok( utf8_text->text.textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", utf8_text->text.textType );
- ok( !utf8_text->value.length, "got %u\n", utf8_text->value.length );
+ ok( !utf8_text->value.length, "got %lu\n", utf8_text->value.length );
ok( utf8_text->value.bytes != NULL, "bytes not set\n" );
attr = elem->attributes[1];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( attr->prefix->length == 1, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 1, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p", 1 ), "wrong prefix\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* attribute */
hr = set_input_bin( reader, test102, sizeof(test102), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "ns not set\n" );
- ok( elem->attributeCount == 2, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 2, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( !attr->isXmlNs, "is xmlns\n" );
- ok( attr->prefix->length == 2, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 2, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p2", 2 ), "wrong prefix\n" );
- ok( attr->localName->length == 1, "got %u\n", attr->localName->length );
+ ok( attr->localName->length == 1, "got %lu\n", attr->localName->length );
ok( !memcmp( attr->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
ok( attr->value != NULL, "value not set\n" );
utf8_text = (const WS_XML_UTF8_TEXT *)attr->value;
ok( utf8_text->text.textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", utf8_text->text.textType );
- ok( !utf8_text->value.length, "got %u\n", utf8_text->value.length );
+ ok( !utf8_text->value.length, "got %lu\n", utf8_text->value.length );
ok( utf8_text->value.bytes != NULL, "bytes not set\n" );
attr = elem->attributes[1];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( attr->prefix->length == 2, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 2, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p2", 2 ), "wrong prefix\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* attribute with value */
hr = set_input_bin( reader, test103, sizeof(test103), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "ns not set\n" );
- ok( elem->attributeCount == 2, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 2, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( !attr->isXmlNs, "is xmlns\n" );
- ok( attr->prefix->length == 2, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 2, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p2", 2 ), "wrong prefix\n" );
- ok( attr->localName->length == 1, "got %u\n", attr->localName->length );
+ ok( attr->localName->length == 1, "got %lu\n", attr->localName->length );
ok( !memcmp( attr->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
ok( attr->value != NULL, "value not set\n" );
utf8_text = (const WS_XML_UTF8_TEXT *)attr->value;
ok( utf8_text->text.textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", utf8_text->text.textType );
- ok( utf8_text->value.length == 4, "got %u\n", utf8_text->value.length );
+ ok( utf8_text->value.length == 4, "got %lu\n", utf8_text->value.length );
ok( !memcmp( utf8_text->value.bytes, "test", 4 ), "wrong value\n" );
attr = elem->attributes[1];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( attr->prefix->length == 2, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 2, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p2", 2 ), "wrong prefix\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
/* comment */
hr = set_input_bin( reader, test200, sizeof(test200), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_COMMENT, "got %u\n", node->nodeType );
comment = (const WS_XML_COMMENT_NODE *)node;
- ok( comment->value.length == 7, "got %u\n", comment->value.length );
+ ok( comment->value.length == 7, "got %lu\n", comment->value.length );
ok( !memcmp( comment->value.bytes, "comment", 7 ), "wrong data\n" );
hr = set_input_bin( reader, test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
found = -1;
hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( found == TRUE, "got %d\n", found );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadEndElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* element with byte record text */
hr = set_input_bin( reader, test5, sizeof(test5), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", node->nodeType );
text_node = (const WS_XML_TEXT_NODE *)node;
ok( text_node->text->textType == WS_XML_TEXT_TYPE_BASE64, "got %u\n", text_node->text->textType );
base64_text = (const WS_XML_BASE64_TEXT *)text_node->text;
- ok( base64_text->length == 1, "got %u\n", base64_text->length );
+ ok( base64_text->length == 1, "got %lu\n", base64_text->length );
ok( base64_text->bytes[0] == 'a', "wrong data %02x\n", base64_text->bytes[0] );
/* element with mixed byte record text */
hr = set_input_bin( reader, test6, sizeof(test6), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 8, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_ELEMENT_FIELD_MAPPING;
@@ -5635,16 +5635,16 @@ static void test_binary_encoding(void)
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &typetest, sizeof(typetest), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( typetest->data.length == 2, "got %u\n", typetest->data.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( typetest->data.length == 2, "got %lu\n", typetest->data.length );
ok( !memcmp( typetest->data.bytes, "ab", 2 ), "wrong data\n" );
/* record value too large for description type */
hr = set_input_bin( reader, test32, sizeof(test32), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 8, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_ELEMENT_FIELD_MAPPING;
@@ -5662,14 +5662,14 @@ static void test_binary_encoding(void)
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &typetest2, sizeof(typetest2), NULL );
- ok( hr == WS_E_NUMERIC_OVERFLOW, "got %08x\n", hr );
+ ok( hr == WS_E_NUMERIC_OVERFLOW, "got %#lx\n", hr );
/* record value too small for description type */
hr = set_input_bin( reader, test16, sizeof(test16), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 8, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_ELEMENT_FIELD_MAPPING;
@@ -5687,7 +5687,7 @@ static void test_binary_encoding(void)
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &typetest3, sizeof(typetest3), NULL );
- ok( hr == WS_E_NUMERIC_OVERFLOW, "got %08x\n", hr );
+ ok( hr == WS_E_NUMERIC_OVERFLOW, "got %#lx\n", hr );
WsFreeHeap( heap );
WsFreeReader( reader );
@@ -5727,7 +5727,7 @@ static void test_dictionary(void)
HRESULT hr;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
strings[0].length = 0;
strings[0].bytes = NULL;
@@ -5761,333 +5761,333 @@ static void test_dictionary(void)
/* short dictionary element */
hr = set_input_bin( reader, test, sizeof(test), &dict );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
ok( elem->prefix->bytes == NULL, "bytes set\n" );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
ok( elem->localName->dictionary == &dict, "unexpected dict\n" );
- ok( elem->localName->id == ~0u, "unexpected id %08x\n", elem->localName->id );
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( elem->localName->id == ~0u, "unexpected id %#lx\n", elem->localName->id );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "bytes not set\n" );
- ok( !elem->attributeCount, "got %u\n", elem->attributeCount );
+ ok( !elem->attributeCount, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* single character prefix dictionary element */
hr = set_input_bin( reader, test2, sizeof(test2), &dict );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( elem->prefix->length == 1, "got %u\n", elem->prefix->length );
+ ok( elem->prefix->length == 1, "got %lu\n", elem->prefix->length );
ok( !memcmp( elem->prefix->bytes, "p", 1 ), "wrong prefix\n" );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "u", 1 ), "wrong name\n" );
- ok( elem->ns->length == 2, "got %u\n", elem->ns->length );
+ ok( elem->ns->length == 2, "got %lu\n", elem->ns->length );
ok( !memcmp( elem->ns->bytes, "ns", 2 ), "wrong namespace\n" );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( attr->prefix->length == 1, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 1, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p", 1 ), "wrong prefix\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
ok( attr->ns->dictionary == &dict, "unexpected dict\n" );
- ok( attr->ns->id == 5, "unexpected id %08x\n", attr->ns->id );
+ ok( attr->ns->id == 5, "unexpected id %#lx\n", attr->ns->id );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* dictionary element */
hr = set_input_bin( reader, test3, sizeof(test3), &dict );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( elem->prefix->length == 2, "got %u\n", elem->prefix->length );
+ ok( elem->prefix->length == 2, "got %lu\n", elem->prefix->length );
ok( !memcmp( elem->prefix->bytes, "p2", 2 ), "wrong prefix\n" );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "u", 1 ), "wrong name\n" );
ok( elem->localName->dictionary == &dict, "unexpected dict\n" );
- ok( elem->localName->id == 3, "unexpected id %08x\n", elem->localName->id );
- ok( elem->ns->length == 2, "got %u\n", elem->ns->length );
+ ok( elem->localName->id == 3, "unexpected id %#lx\n", elem->localName->id );
+ ok( elem->ns->length == 2, "got %lu\n", elem->ns->length );
ok( !memcmp( elem->ns->bytes, "ns", 2 ), "wrong namespace\n" );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( attr->prefix->length == 2, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 2, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p2", 2 ), "wrong prefix\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* short dictionary attribute */
hr = set_input_bin( reader, test4, sizeof(test4), &dict );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "u", 1 ), "wrong name\n" );
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "bytes not set\n" );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( !attr->isXmlNs, "is xmlns\n" );
- ok( !attr->prefix->length, "got %u\n", attr->prefix->length );
- ok( attr->localName->length == 1, "got %u\n", attr->localName->length );
+ ok( !attr->prefix->length, "got %lu\n", attr->prefix->length );
+ ok( attr->localName->length == 1, "got %lu\n", attr->localName->length );
ok( attr->localName->dictionary == &dict, "unexpected dict\n" );
- ok( attr->localName->id == 3, "unexpected id %08x\n", attr->localName->id );
+ ok( attr->localName->id == 3, "unexpected id %#lx\n", attr->localName->id );
ok( !memcmp( attr->localName->bytes, "u", 1 ), "wrong name\n" );
- ok( !attr->ns->length, "got %u\n", attr->ns->length );
+ ok( !attr->ns->length, "got %lu\n", attr->ns->length );
ok( elem->ns->bytes != NULL, "bytes not set\n" );
ok( attr->value != NULL, "value not set\n" );
utf8 = (const WS_XML_UTF8_TEXT *)attr->value;
ok( utf8->text.textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", utf8->text.textType );
- ok( !utf8->value.length, "got %u\n", utf8->value.length );
+ ok( !utf8->value.length, "got %lu\n", utf8->value.length );
ok( utf8->value.bytes != NULL, "bytes not set\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* single character prefix dictionary attribute */
hr = set_input_bin( reader, test5, sizeof(test5), &dict );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "u", 1 ), "wrong name\n" );
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "ns not set\n" );
- ok( elem->attributeCount == 2, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 2, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( !attr->isXmlNs, "is xmlns\n" );
- ok( attr->prefix->length == 1, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 1, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p", 1 ), "wrong prefix\n" );
- ok( attr->localName->length == 1, "got %u\n", attr->localName->length );
+ ok( attr->localName->length == 1, "got %lu\n", attr->localName->length );
ok( !memcmp( attr->localName->bytes, "u", 1 ), "wrong name\n" );
ok( attr->localName->dictionary == &dict, "unexpected dict\n" );
- ok( attr->localName->id == 3, "unexpected id %08x\n", attr->localName->id );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->localName->id == 3, "unexpected id %#lx\n", attr->localName->id );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
ok( attr->value != NULL, "value not set\n" );
utf8 = (const WS_XML_UTF8_TEXT *)attr->value;
ok( utf8->text.textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", utf8->text.textType );
- ok( !utf8->value.length, "got %u\n", utf8->value.length );
+ ok( !utf8->value.length, "got %lu\n", utf8->value.length );
ok( utf8->value.bytes != NULL, "bytes not set\n" );
attr = elem->attributes[1];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( attr->prefix->length == 1, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 1, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p", 1 ), "wrong prefix\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* dictionary attribute */
hr = set_input_bin( reader, test6, sizeof(test6), &dict );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "u", 1 ), "wrong name\n" );
- ok( !elem->ns->length, "got %u\n", elem->ns->length );
+ ok( !elem->ns->length, "got %lu\n", elem->ns->length );
ok( elem->ns->bytes != NULL, "ns not set\n" );
- ok( elem->attributeCount == 2, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 2, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( !attr->isXmlNs, "is xmlns\n" );
- ok( attr->prefix->length == 2, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 2, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p2", 2 ), "wrong prefix\n" );
- ok( attr->localName->length == 1, "got %u\n", attr->localName->length );
+ ok( attr->localName->length == 1, "got %lu\n", attr->localName->length );
ok( !memcmp( attr->localName->bytes, "u", 1 ), "wrong name\n" );
ok( attr->localName->dictionary == &dict, "unexpected dict\n" );
- ok( attr->localName->id == 3, "unexpected id %08x\n", attr->localName->id );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->localName->id == 3, "unexpected id %#lx\n", attr->localName->id );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
ok( attr->value != NULL, "value not set\n" );
utf8 = (const WS_XML_UTF8_TEXT *)attr->value;
ok( utf8->text.textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", utf8->text.textType );
- ok( !utf8->value.length, "got %u\n", utf8->value.length );
+ ok( !utf8->value.length, "got %lu\n", utf8->value.length );
ok( utf8->value.bytes != NULL, "bytes not set\n" );
attr = elem->attributes[1];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( attr->prefix->length == 2, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 2, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p2", 2 ), "wrong prefix\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
/* short dictionary xmlns attribute */
hr = set_input_bin( reader, test7, sizeof(test7), &dict );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( !attr->prefix->length, "got %u\n", attr->prefix->length );
+ ok( !attr->prefix->length, "got %lu\n", attr->prefix->length );
ok( attr->prefix->bytes == NULL, "bytes set\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
ok( attr->ns->dictionary == &dict, "unexpected dict\n" );
- ok( attr->ns->id == 5, "unexpected id %08x\n", attr->ns->id );
+ ok( attr->ns->id == 5, "unexpected id %#lx\n", attr->ns->id );
utf8 = (const WS_XML_UTF8_TEXT *)attr->value;
ok( utf8->text.textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", utf8->text.textType );
- ok( !utf8->value.length, "got %u\n", utf8->value.length );
+ ok( !utf8->value.length, "got %lu\n", utf8->value.length );
todo_wine ok( utf8->value.bytes != NULL, "bytes not set\n" );
/* dictionary xmlns attribute */
hr = set_input_bin( reader, test8, sizeof(test8), &dict );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( !elem->prefix->length, "got %u\n", elem->prefix->length );
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( !elem->prefix->length, "got %lu\n", elem->prefix->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( !memcmp( elem->localName->bytes, "t", 1 ), "wrong name\n" );
- ok( elem->attributeCount == 1, "got %u\n", elem->attributeCount );
+ ok( elem->attributeCount == 1, "got %lu\n", elem->attributeCount );
ok( !elem->isEmpty, "empty\n" );
attr = elem->attributes[0];
ok( !attr->singleQuote, "single quote\n" );
ok( attr->isXmlNs, "not xmlns\n" );
- ok( attr->prefix->length == 1, "got %u\n", attr->prefix->length );
+ ok( attr->prefix->length == 1, "got %lu\n", attr->prefix->length );
ok( !memcmp( attr->prefix->bytes, "p", 1 ), "wrong prefix\n" );
- ok( attr->ns->length == 2, "got %u\n", attr->ns->length );
+ ok( attr->ns->length == 2, "got %lu\n", attr->ns->length );
ok( !memcmp( attr->ns->bytes, "ns", 2 ), "wrong namespace\n" );
ok( attr->ns->dictionary == &dict, "unexpected dict\n" );
- ok( attr->ns->id == 5, "unexpected id %08x\n", attr->ns->id );
+ ok( attr->ns->id == 5, "unexpected id %#lx\n", attr->ns->id );
utf8 = (const WS_XML_UTF8_TEXT *)attr->value;
ok( utf8->text.textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", utf8->text.textType );
- ok( !utf8->value.length, "got %u\n", utf8->value.length );
+ ok( !utf8->value.length, "got %lu\n", utf8->value.length );
todo_wine ok( utf8->value.bytes != NULL, "bytes not set\n" );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* element name string id out of range */
hr = set_input_bin( reader, test9, sizeof(test9), &dict );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
/* text string id out of range */
hr = set_input_bin( reader, test10, sizeof(test10), &dict );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
hr = WsReadNode( reader, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = WsGetDictionary( 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetDictionary( WS_ENCODING_XML_UTF8, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
dict2 = (WS_XML_DICTIONARY *)0xdeadbeef;
hr = WsGetDictionary( WS_ENCODING_XML_UTF8, &dict2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( dict2 == NULL, "got %p\n", dict2 );
dict2 = NULL;
hr = WsGetDictionary( WS_ENCODING_XML_BINARY_1, &dict2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( dict2 != NULL, "dict2 not set\n" );
ok( dict2 != &dict, "got %p\n", dict2 );
dict2 = NULL;
hr = WsGetDictionary( WS_ENCODING_XML_BINARY_SESSION_1, &dict2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( dict2 != NULL, "dict2 not set\n" );
ok( dict2 != &dict, "got %p\n", dict2 );
ok( !memcmp( &dict2->guid, &dict_static, sizeof(dict_static) ),
"got %s\n", wine_dbgstr_guid(&dict2->guid) );
- ok( dict2->stringCount == 488 || dict2->stringCount == 487 /* < win10 */, "got %u\n", dict2->stringCount );
- ok( dict2->strings[0].length == 14, "got %u\n", dict2->strings[0].length );
+ ok( dict2->stringCount == 488 || dict2->stringCount == 487 /* < win10 */, "got %lu\n", dict2->stringCount );
+ ok( dict2->strings[0].length == 14, "got %lu\n", dict2->strings[0].length );
ok( !memcmp( dict2->strings[0].bytes, "mustUnderstand", 14 ), "wrong data\n" );
WsFreeReader( reader );
@@ -6109,18 +6109,18 @@ static void check_output_buffer( WS_XML_BUFFER *buffer, const char *expected, un
HRESULT hr;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteXmlBuffer( writer, buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &bytes, 0, sizeof(bytes) );
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
- ok( hr == S_OK, "%u: got %08x\n", line, hr );
- ok( bytes.length == len, "%u: got %u expected %u\n", line, bytes.length, len );
+ ok( hr == S_OK, "%u: got %#lx\n", line, hr );
+ ok( bytes.length == len, "%u: got %lu expected %d\n", line, bytes.length, len );
if (bytes.length != len) return;
ok( !memcmp( bytes.bytes, expected, len ), "%u: got %s expected %s\n", line, bytes.bytes, expected );
@@ -6135,25 +6135,25 @@ static HRESULT prepare_xml_buffer_test( WS_XML_READER *reader, WS_HEAP *heap )
HRESULT hr;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname2, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetInputToBuffer( reader, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
WsFreeWriter( writer );
return S_OK;
}
@@ -6167,124 +6167,124 @@ static void test_WsReadXmlBuffer(void)
HRESULT hr;
hr = WsReadXmlBuffer( NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadXmlBuffer( reader, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadXmlBuffer( reader, heap, NULL, NULL );
- ok( hr == E_FAIL, "got %08x\n", hr );
+ ok( hr == E_FAIL, "got %#lx\n", hr );
hr = WsReadXmlBuffer( reader, heap, &buffer, NULL );
- todo_wine ok( hr == E_FAIL, "got %08x\n", hr );
+ todo_wine ok( hr == E_FAIL, "got %#lx\n", hr );
hr = set_input( reader, "<t><u><v/></u></t></w>", sizeof("<t><u><v/></u></t></w>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
/* reader positioned at element */
buffer = NULL;
hr = WsReadXmlBuffer( reader, heap, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( buffer != NULL, "buffer not set\n" );
check_output_buffer( buffer, "<u><v/></u>", __LINE__ );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* reader positioned at end element */
hr = WsReadXmlBuffer( reader, heap, &buffer, NULL );
- ok( hr == E_FAIL, "got %08x\n", hr );
+ ok( hr == E_FAIL, "got %#lx\n", hr );
hr = set_input( reader, "<t><u/></t><v/>", sizeof("<t><u/></t><v/>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
/* reader positioned at BOF */
hr = WsReadXmlBuffer( reader, heap, &buffer, NULL );
- todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
todo_wine ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
hr = set_input( reader, "<!--comment--><t></t>", sizeof("<!--comment--><t></t>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_COMMENT, "got %u\n", node->nodeType );
/* reader positioned at non-element */
hr = WsReadXmlBuffer( reader, heap, &buffer, NULL );
- ok( hr == E_FAIL, "got %08x\n", hr );
+ ok( hr == E_FAIL, "got %#lx\n", hr );
hr = prepare_xml_buffer_test( reader, heap );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
/* reader positioned at BOF, input buffer */
hr = WsReadXmlBuffer( reader, heap, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<t><u/></t>", __LINE__ );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
/* reader positioned at EOF, input buffer */
hr = WsReadXmlBuffer( reader, heap, &buffer, NULL );
- ok( hr == E_FAIL, "got %08x\n", hr );
+ ok( hr == E_FAIL, "got %#lx\n", hr );
hr = prepare_xml_buffer_test( reader, heap );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadNode( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
/* reader positioned at element, input buffer */
hr = WsReadXmlBuffer( reader, heap, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<u/>", __LINE__ );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
/* reader positioned at end element, input buffer */
hr = WsReadXmlBuffer( reader, heap, &buffer, NULL );
- ok( hr == E_FAIL, "got %08x\n", hr );
+ ok( hr == E_FAIL, "got %#lx\n", hr );
WsFreeReader( reader );
WsFreeHeap( heap );
@@ -6314,10 +6314,10 @@ static void test_union_type(void)
} *test;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.value = CHOICE_A;
@@ -6363,19 +6363,19 @@ static void test_union_type(void)
prepare_struct_type_test( reader, "<a>test</a>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
ok( test->choice == CHOICE_A, "got %d\n", test->choice );
ok( !wcscmp(test->value.a, L"test"), "got %s\n", wine_dbgstr_w(test->value.a) );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
test = NULL;
prepare_struct_type_test( reader, "<b>123</b>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
ok( test->choice == CHOICE_B, "got %d\n", test->choice );
ok( test->value.b == 123, "got %u\n", test->value.b );
@@ -6383,36 +6383,36 @@ static void test_union_type(void)
prepare_struct_type_test( reader, "<c>456</c>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
f_struct.options = WS_FIELD_NILLABLE;
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
f_struct.options = WS_FIELD_POINTER|WS_FIELD_NILLABLE;
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
f_struct.options = WS_FIELD_POINTER;
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
test = NULL;
f_struct.options = WS_FIELD_OPTIONAL;
prepare_struct_type_test( reader, "<c>456</c>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- todo_wine ok( hr == S_OK, "got %08x\n", hr );
+ todo_wine ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
ok( test->choice == CHOICE_NONE, "got %d\n", test->choice );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
WsFreeReader( reader );
@@ -6488,10 +6488,10 @@ static void test_float(void)
ULONG val, i;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
@@ -6499,8 +6499,8 @@ static void test_float(void)
prepare_type_test( reader, tests[i].str, strlen(tests[i].str) );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_FLOAT_TYPE, NULL,
WS_READ_REQUIRED_VALUE, heap, &val, sizeof(val), NULL );
- ok( hr == tests[i].hr, "%u: got %08x\n", i, hr );
- if (hr == tests[i].hr) ok( val == tests[i].val, "%u: got %08x\n", i, val );
+ ok( hr == tests[i].hr, "%lu: got %#lx\n", i, hr );
+ if (hr == tests[i].hr) ok( val == tests[i].val, "%lu: got %#lx\n", i, val );
}
WsFreeReader( reader );
@@ -6536,10 +6536,10 @@ static void test_repeating_element_choice(void)
} *test;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.value = CHOICE_A;
@@ -6588,9 +6588,9 @@ static void test_repeating_element_choice(void)
prepare_struct_type_test( reader, "<t><a>test</a></t>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
- ok( test->count == 1, "got %u\n", test->count );
+ ok( test->count == 1, "got %lu\n", test->count );
ok( test->items[0].choice == CHOICE_A, "got %d\n", test->items[0].choice );
ok( !wcscmp(test->items[0].value.a, L"test"), "got %s\n", wine_dbgstr_w(test->items[0].value.a) );
@@ -6598,9 +6598,9 @@ static void test_repeating_element_choice(void)
prepare_struct_type_test( reader, "<t><b>123</b></t>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
- ok( test->count == 1, "got %u\n", test->count );
+ ok( test->count == 1, "got %lu\n", test->count );
ok( test->items[0].choice == CHOICE_B, "got %d\n", test->items[0].choice );
ok( test->items[0].value.b == 123, "got %u\n", test->items[0].value.b );
@@ -6608,9 +6608,9 @@ static void test_repeating_element_choice(void)
prepare_struct_type_test( reader, "<t><a>test</a><b>123</b></t>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
- ok( test->count == 2, "got %u\n", test->count );
+ ok( test->count == 2, "got %lu\n", test->count );
ok( test->items[0].choice == CHOICE_A, "got %d\n", test->items[0].choice );
ok( !wcscmp(test->items[0].value.a, L"test"), "got %s\n", wine_dbgstr_w(test->items[0].value.a) );
ok( test->items[1].choice == CHOICE_B, "got %d\n", test->items[1].choice );
@@ -6619,27 +6619,27 @@ static void test_repeating_element_choice(void)
prepare_struct_type_test( reader, "<t><c>123</c></t>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
todo_wine ok( node->nodeType == WS_XML_NODE_TYPE_ELEMENT, "got %u\n", node->nodeType );
if (node->nodeType == WS_XML_NODE_TYPE_ELEMENT)
{
const WS_XML_ELEMENT_NODE *elem = (const WS_XML_ELEMENT_NODE *)node;
- ok( elem->localName->length == 1, "got %u\n", elem->localName->length );
+ ok( elem->localName->length == 1, "got %lu\n", elem->localName->length );
ok( elem->localName->bytes[0] == 'c', "got '%c'\n", elem->localName->bytes[0] );
}
prepare_struct_type_test( reader, "<t></t>" );
hr = WsReadType( reader, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
- ok( !test->count, "got %u\n", test->count );
+ ok( !test->count, "got %lu\n", test->count );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
WsFreeReader( reader );
@@ -6676,10 +6676,10 @@ static void test_empty_text_field(void)
} *test5;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_TEXT_FIELD_MAPPING;
@@ -6699,9 +6699,9 @@ static void test_empty_text_field(void)
prepare_struct_type_test( reader, "<t></t>" );
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
- ok( !test->str.length, "got %u\n", test->str.length );
+ ok( !test->str.length, "got %lu\n", test->str.length );
todo_wine ok( test->str.chars != NULL, "chars not set\n" );
memset( &f, 0, sizeof(f) );
@@ -6722,7 +6722,7 @@ static void test_empty_text_field(void)
prepare_struct_type_test( reader, "<t></t>" );
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test2, sizeof(test2), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test2 != NULL, "test2 not set\n" );
ok( test2->str != NULL, "str not set\n" );
ok( !test2->str[0], "not empty\n" );
@@ -6744,7 +6744,7 @@ static void test_empty_text_field(void)
prepare_struct_type_test( reader, "<t></t>" );
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test3, sizeof(test3), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_TEXT_FIELD_MAPPING;
@@ -6764,9 +6764,9 @@ static void test_empty_text_field(void)
prepare_struct_type_test( reader, "<t></t>" );
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test4, sizeof(test4), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test4 != NULL, "test4 not set\n" );
- ok( !test4->str.length, "got %u\n", test4->str.length );
+ ok( !test4->str.length, "got %lu\n", test4->str.length );
todo_wine ok( test4->str.bytes != NULL, "bytes not set\n" );
memset( &f, 0, sizeof(f) );
@@ -6787,9 +6787,9 @@ static void test_empty_text_field(void)
prepare_struct_type_test( reader, "<t></t>" );
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test5, sizeof(test5), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test5 != NULL, "test5 not set\n" );
- ok( !test5->bytes.length, "got %u\n", test5->bytes.length );
+ ok( !test5->bytes.length, "got %lu\n", test5->bytes.length );
todo_wine ok( test5->bytes.bytes != NULL, "bytes not set\n" );
WsFreeReader( reader );
@@ -6840,61 +6840,61 @@ static void test_stream_input(void)
ULONG i, size;
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
stream.input.inputType = WS_XML_READER_INPUT_TYPE_STREAM;
stream.readCallback = read_callback;
stream.readCallbackState = (void *)&stream_tests[2];
hr = WsSetInput( reader, &text.encoding, &stream.input, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
size = sizeof(charset);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_CHARSET, &charset, size, NULL );
- todo_wine ok( hr == WS_E_QUOTA_EXCEEDED, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_QUOTA_EXCEEDED, "got %#lx\n", hr );
hr = WsSetInput( reader, &text.encoding, &stream.input, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, strlen(stream_tests[2].xml), NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
charset = 0xdeadbeef;
size = sizeof(charset);
hr = WsGetReaderProperty( reader, WS_XML_READER_PROPERTY_CHARSET, &charset, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( charset == WS_CHARSET_UTF8, "got %u\n", charset );
found = -1;
hr = WsReadToStartElement( reader, &str_t, &str_ns, &found, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE(stream_tests); i++)
{
stream.readCallbackState = (void *)&stream_tests[i];
hr = WsSetInput( reader, &text.encoding, &stream.input, NULL, 0, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsFillReader( reader, strlen( stream_tests[i].xml ), NULL, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
found = -1;
hr = WsReadToStartElement( reader, &str_t, &str_ns, &found, NULL );
- todo_wine_if(stream_tests[i].todo) ok( hr == stream_tests[i].hr, "%u: got %08x\n", i, hr );
+ todo_wine_if(stream_tests[i].todo) ok( hr == stream_tests[i].hr, "%lu: got %#lx\n", i, hr );
if (hr == S_OK)
{
- ok( found == TRUE, "%u: got %d\n", i, found );
+ ok( found == TRUE, "%lu: got %d\n", i, found );
hr = WsReadStartElement( reader, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
- if (node) ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "%u: got %u\n", i, node->nodeType );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
+ if (node) ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "%lu: got %u\n", i, node->nodeType );
}
}
@@ -6917,10 +6917,10 @@ static void test_description_type(void)
} *test;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_TYPE_ATTRIBUTE_FIELD_MAPPING;
@@ -6945,12 +6945,12 @@ static void test_description_type(void)
prepare_struct_type_test( reader, "<t val=\"-1\" xmlns=\"ns\"/>" );
hr = WsReadToStartElement( reader, &localname, &ns2, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
test = NULL;
hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( test != NULL, "test not set\n" );
if (test)
{
diff --git a/dlls/webservices/tests/url.c b/dlls/webservices/tests/url.c
index 4343dc6a3dd..054752c0665 100644
--- a/dlls/webservices/tests/url.c
+++ b/dlls/webservices/tests/url.c
@@ -109,20 +109,20 @@ static void test_WsDecodeUrl(void)
UINT i;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsDecodeUrl( NULL, 0, heap, (WS_URL **)&url, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
str.chars = NULL;
str.length = 0;
hr = WsDecodeUrl( &str, 0, heap, (WS_URL **)&url, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
str.chars = (WCHAR *)url1;
str.length = lstrlenW( url1 );
hr = WsDecodeUrl( &str, 0, NULL, (WS_URL **)&url, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
@@ -132,7 +132,7 @@ static void test_WsDecodeUrl(void)
hr = WsDecodeUrl( &str, 0, heap, (WS_URL **)&url, NULL );
ok( hr == tests[i].hr ||
broken(hr == WS_E_INVALID_FORMAT && str.length >= 8 && !memcmp(L"net.pipe", str.chars, 8)),
- "%u: got %08x\n", i, hr );
+ "%u: got %#lx\n", i, hr );
if (hr != S_OK) continue;
ok( url->url.scheme == tests[i].scheme, "%u: got %u\n", i, url->url.scheme );
@@ -140,43 +140,43 @@ static void test_WsDecodeUrl(void)
if (tests[i].host)
{
- ok( url->host.length == tests[i].host_len, "%u: got %u\n", i, url->host.length );
+ ok( url->host.length == tests[i].host_len, "%u: got %lu\n", i, url->host.length );
ok( !memcmp( url->host.chars, tests[i].host, url->host.length * sizeof(WCHAR) ),
"%u: got %s\n", i, wine_dbgstr_wn(url->host.chars, url->host.length) );
}
- else ok( !url->host.length, "%u: got %u\n", i, url->host.length );
+ else ok( !url->host.length, "%u: got %lu\n", i, url->host.length );
if (tests[i].port_str)
{
- ok( url->portAsString.length == tests[i].port_len, "%u: got %u\n", i, url->portAsString.length );
+ ok( url->portAsString.length == tests[i].port_len, "%u: got %lu\n", i, url->portAsString.length );
ok( !memcmp( url->portAsString.chars, tests[i].port_str, url->portAsString.length * sizeof(WCHAR) ),
"%u: got %s\n", i, wine_dbgstr_wn(url->portAsString.chars, url->portAsString.length) );
}
- else ok( !url->portAsString.length, "%u: got %u\n", i, url->portAsString.length );
+ else ok( !url->portAsString.length, "%u: got %lu\n", i, url->portAsString.length );
if (tests[i].path)
{
- ok( url->path.length == tests[i].path_len, "%u: got %u\n", i, url->path.length );
+ ok( url->path.length == tests[i].path_len, "%u: got %lu\n", i, url->path.length );
ok( !memcmp( url->path.chars, tests[i].path, url->path.length * sizeof(WCHAR) ),
"%u: got %s\n", i, wine_dbgstr_wn(url->path.chars, url->path.length) );
}
- else ok( !url->path.length, "%u: got %u\n", i, url->path.length );
+ else ok( !url->path.length, "%u: got %lu\n", i, url->path.length );
if (tests[i].query)
{
- ok( url->query.length == tests[i].query_len, "%u: got %u\n", i, url->query.length );
+ ok( url->query.length == tests[i].query_len, "%u: got %lu\n", i, url->query.length );
ok( !memcmp( url->query.chars, tests[i].query, url->query.length * sizeof(WCHAR) ),
"%u: got %s\n", i, wine_dbgstr_wn(url->query.chars, url->query.length) );
}
- else ok( !url->query.length, "%u: got %u\n", i, url->query.length );
+ else ok( !url->query.length, "%u: got %lu\n", i, url->query.length );
if (tests[i].fragment)
{
- ok( url->fragment.length == tests[i].fragment_len, "%u: got %u\n", i, url->fragment.length );
+ ok( url->fragment.length == tests[i].fragment_len, "%u: got %lu\n", i, url->fragment.length );
ok( !memcmp( url->fragment.chars, tests[i].fragment, url->fragment.length * sizeof(WCHAR) ),
"%u: got %s\n", i, wine_dbgstr_wn(url->fragment.chars, url->fragment.length) );
}
- else ok( !url->fragment.length, "%u: got %u\n", i, url->fragment.length );
+ else ok( !url->fragment.length, "%u: got %lu\n", i, url->fragment.length );
}
WsFreeHeap( heap );
@@ -240,16 +240,16 @@ static void test_WsEncodeUrl(void)
UINT i;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsEncodeUrl( NULL, 0, heap, &str, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsEncodeUrl( (const WS_URL *)&url, 0, NULL, &str, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsEncodeUrl( (const WS_URL *)&url, 0, heap, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
@@ -269,10 +269,10 @@ static void test_WsEncodeUrl(void)
memset( &str, 0, sizeof(str) );
hr = WsEncodeUrl( (const WS_URL *)&url, 0, heap, &str, NULL );
- ok( hr == tests[i].hr, "%u: got %08x\n", i, hr );
+ ok( hr == tests[i].hr, "%u: got %#lx\n", i, hr );
if (hr != S_OK) continue;
- ok( str.length == tests[i].len, "%u: got %u\n", i, str.length );
+ ok( str.length == tests[i].len, "%u: got %lu\n", i, str.length );
ok( !memcmp( str.chars, tests[i].chars, tests[i].len * sizeof(WCHAR) ),
"%u: wrong url %s\n", i, wine_dbgstr_wn(str.chars, str.length) );
}
diff --git a/dlls/webservices/tests/writer.c b/dlls/webservices/tests/writer.c
index ab74c2e84e3..c09a9916120 100644
--- a/dlls/webservices/tests/writer.c
+++ b/dlls/webservices/tests/writer.c
@@ -43,107 +43,107 @@ static void test_WsCreateWriter(void)
WS_BYTES bytes;
hr = WsCreateWriter( NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
writer = NULL;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( writer != NULL, "writer not set\n" );
/* can't retrieve properties before output is set */
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
ok( max_depth == 0xdeadbeef, "max_depth set\n" );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* check some defaults */
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_depth == 32, "got %u\n", max_depth );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_depth == 32, "got %lu\n", max_depth );
allow_fragment = TRUE;
size = sizeof(allow_fragment);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_ALLOW_FRAGMENT, &allow_fragment, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( !allow_fragment, "got %d\n", allow_fragment );
max_attrs = 0xdeadbeef;
size = sizeof(max_attrs);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_ATTRIBUTES, &max_attrs, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_attrs == 128, "got %u\n", max_attrs );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_attrs == 128, "got %lu\n", max_attrs );
write_decl = TRUE;
size = sizeof(write_decl);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_WRITE_DECLARATION, &write_decl, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( !write_decl, "got %d\n", write_decl );
indent = 0xdeadbeef;
size = sizeof(indent);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_INDENT, &indent, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !indent, "got %u\n", indent );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !indent, "got %lu\n", indent );
trim_size = 0xdeadbeef;
size = sizeof(trim_size);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE, &trim_size, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( trim_size == 4096, "got %u\n", trim_size );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( trim_size == 4096, "got %lu\n", trim_size );
charset = 0xdeadbeef;
size = sizeof(charset);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_CHARSET, &charset, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( charset == WS_CHARSET_UTF8, "got %u\n", charset );
buffers.bufferCount = 0xdeadbeef;
buffers.buffers = (WS_BYTES *)0xdeadbeef;
size = sizeof(buffers);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BUFFERS, &buffers, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !buffers.bufferCount, "got %u\n", buffers.bufferCount );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !buffers.bufferCount, "got %lu\n", buffers.bufferCount );
ok( !buffers.buffers, "got %p\n", buffers.buffers );
max_size = 0xdeadbeef;
size = sizeof(max_size);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE, &max_size, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_size == 65536, "got %u\n", max_size );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_size == 65536, "got %lu\n", max_size );
bytes.length = 0xdeadbeef;
bytes.bytes = (BYTE *)0xdeadbeef;
size = sizeof(bytes);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !bytes.length, "got %u\n", bytes.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !bytes.length, "got %lu\n", bytes.length );
ok( bytes.bytes != NULL, "got %p\n", bytes.bytes );
max_size = 0xdeadbeef;
size = sizeof(max_size);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE, &max_size, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_size == 65536, "got %u\n", max_size );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_size == 65536, "got %lu\n", max_size );
bytes.length = 0xdeadbeef;
bytes.bytes = (BYTE *)0xdeadbeef;
size = sizeof(bytes);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_INITIAL_BUFFER, &bytes, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( !bytes.length, "got %u\n", bytes.length );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( !bytes.length, "got %lu\n", bytes.length );
ok( !bytes.bytes, "got %p\n", bytes.bytes );
max_ns = 0xdeadbeef;
size = sizeof(max_ns);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_NAMESPACES, &max_ns, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_ns == 32, "got %u\n", max_ns );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_ns == 32, "got %lu\n", max_ns );
WsFreeWriter( writer );
/* change a property */
@@ -152,16 +152,16 @@ static void test_WsCreateWriter(void)
prop.value = &max_depth;
prop.valueSize = sizeof(max_depth);
hr = WsCreateWriter( &prop, 1, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_depth == 16, "got %u\n", max_depth );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_depth == 16, "got %lu\n", max_depth );
WsFreeWriter( writer );
/* show that some properties are read-only */
@@ -170,21 +170,21 @@ static void test_WsCreateWriter(void)
prop.value = &in_attr;
prop.valueSize = sizeof(in_attr);
hr = WsCreateWriter( &prop, 1, &writer, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
size = 1;
prop.id = WS_XML_WRITER_PROPERTY_BYTES_WRITTEN;
prop.value = &size;
prop.valueSize = sizeof(size);
hr = WsCreateWriter( &prop, 1, &writer, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
size = 1;
prop.id = WS_XML_WRITER_PROPERTY_BYTES_TO_CLOSE;
prop.value = &size;
prop.valueSize = sizeof(size);
hr = WsCreateWriter( &prop, 1, &writer, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
}
static void test_WsCreateXmlBuffer(void)
@@ -197,35 +197,35 @@ static void test_WsCreateXmlBuffer(void)
ULONG size;
hr = WsCreateXmlBuffer( NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( NULL, NULL, 0, &buffer, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
buffer = NULL;
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( buffer != NULL, "buffer not set\n" );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
size = sizeof(bytes);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
size = sizeof(bytes);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
- todo_wine ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ todo_wine ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeWriter( writer );
WsFreeHeap( heap );
@@ -241,10 +241,10 @@ static void test_WsSetOutput(void)
ULONG size, max_depth;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutput( NULL, NULL, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
encoding.encoding.encodingType = WS_XML_WRITER_ENCODING_TYPE_TEXT;
encoding.charSet = WS_CHARSET_UTF8;
@@ -252,11 +252,11 @@ static void test_WsSetOutput(void)
output.output.outputType = WS_XML_WRITER_OUTPUT_TYPE_BUFFER;
hr = WsSetOutput( writer, &encoding.encoding, &output.output, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* multiple calls are allowed */
hr = WsSetOutput( writer, &encoding.encoding, &output.output, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* writer properties can be set with WsSetOutput */
max_depth = 16;
@@ -264,13 +264,13 @@ static void test_WsSetOutput(void)
prop.value = &max_depth;
prop.valueSize = sizeof(max_depth);
hr = WsSetOutput( writer, &encoding.encoding, &output.output, &prop, 1, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_depth == 16, "got %u\n", max_depth );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_depth == 16, "got %lu\n", max_depth );
WsFreeWriter( writer );
}
@@ -284,26 +284,26 @@ static void test_WsSetOutputToBuffer(void)
ULONG size, max_depth;
hr = WsSetOutputToBuffer( NULL, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* multiple calls are allowed */
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* writer properties can be set with WsSetOutputToBuffer */
max_depth = 16;
@@ -311,13 +311,13 @@ static void test_WsSetOutputToBuffer(void)
prop.value = &max_depth;
prop.valueSize = sizeof(max_depth);
hr = WsSetOutputToBuffer( writer, buffer, &prop, 1, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( max_depth == 16, "got %u\n", max_depth );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( max_depth == 16, "got %lu\n", max_depth );
WsFreeWriter( writer );
WsFreeHeap( heap );
@@ -367,8 +367,8 @@ static void check_output( WS_XML_WRITER *writer, const char *expected, unsigned
memset( &bytes, 0, sizeof(bytes) );
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
- ok( hr == S_OK, "%u: got %08x\n", line, hr );
- ok( bytes.length == len, "%u: got %u expected %u\n", line, bytes.length, len );
+ ok( hr == S_OK, "%u: got %#lx\n", line, hr );
+ ok( bytes.length == len, "%u: got %lu expected %d\n", line, bytes.length, len );
if (bytes.length != len) return;
ok( !memcmp( bytes.bytes, expected, len ),
"%u: got %s expected %s\n", line, debugstr_bytes(bytes.bytes, bytes.length), expected );
@@ -382,86 +382,86 @@ static void test_WsWriteStartElement(void)
WS_XML_STRING localname = {1, (BYTE *)"a"}, localname2 = {1, (BYTE *)"b"}, empty = {0, NULL};
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( NULL, &prefix, &localname, &ns, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
/* first call to WsWriteStartElement doesn't output anything */
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
/* two ways to close an element */
hr = WsWriteEndStartElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:a xmlns:p=\"ns\">", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:a xmlns:p=\"ns\"></p:a>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:a xmlns:p=\"ns\"/>", __LINE__ );
/* nested elements */
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteStartElement( writer, NULL, &localname2, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:a xmlns:p=\"ns\">", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:a xmlns:p=\"ns\"><p:b/>", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:a xmlns:p=\"ns\"><p:b/></p:a>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteStartElement( writer, NULL, &localname2, &ns2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:a xmlns:p=\"ns\">", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:a xmlns:p=\"ns\"><b xmlns=\"ns2\"/>", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:a xmlns:p=\"ns\"><b xmlns=\"ns2\"/></p:a>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &empty, &localname, &empty, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndStartElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<a></a>", __LINE__ );
WsFreeWriter( writer );
@@ -476,72 +476,72 @@ static void test_WsWriteStartAttribute(void)
WS_XML_UTF8_TEXT text = {{WS_XML_TEXT_TYPE_UTF8}};
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( NULL, &prefix, &localname, &ns, FALSE, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
/* WsWriteStartAttribute doesn't output anything */
hr = WsWriteStartAttribute( writer, &prefix, &localname2, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
text.value.length = 1;
text.value.bytes = (BYTE *)"0";
hr = WsWriteText( writer, &text.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
/* WsWriteEndAttribute doesn't output anything */
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:str p:len=\"0\" xmlns:p=\"ns\"/>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, &empty, &localname2, &empty, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:str len=\"\" xmlns:p=\"ns\"/>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, NULL, &localname2, &empty, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, NULL, &localname, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:str len=\"\" p:str=\"\" xmlns:p=\"ns\"/>", __LINE__ );
WsFreeWriter( writer );
@@ -560,93 +560,93 @@ static void test_WsWriteType(void)
int val_enum;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
val_str = L"test";
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_WRITE_REQUIRED_POINTER, &val_str, sizeof(val_str), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* required value */
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_WRITE_REQUIRED_VALUE, NULL, sizeof(L"test"), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_WRITE_REQUIRED_VALUE, L"test", sizeof(L"test"), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
/* required pointer */
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_WRITE_REQUIRED_POINTER, NULL, sizeof(val_str), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_WRITE_REQUIRED_VALUE, L"test", sizeof(L"test"), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_WRITE_REQUIRED_POINTER, &val_str, sizeof(WCHAR **), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:str xmlns:p=\"ns\">test", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:str xmlns:p=\"ns\">test</p:str>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, NULL, &localname, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
val_str = L"test";
hr = WsWriteType( writer, WS_ATTRIBUTE_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_WRITE_REQUIRED_POINTER, &val_str, sizeof(val_str), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:str p:str=\"test\" xmlns:p=\"ns\"/>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
val_str = L"test";
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
WS_WRITE_REQUIRED_POINTER, &val_str, sizeof(val_str), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:str xmlns:p=\"ns\">test", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:str xmlns:p=\"ns\">test</p:str>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
enum_desc.values = enum_values;
enum_desc.valueCount = ARRAY_SIZE(enum_values);
@@ -656,20 +656,20 @@ static void test_WsWriteType(void)
val_enum = 0;
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_ENUM_TYPE, &enum_desc,
WS_WRITE_REQUIRED_VALUE, &val_enum, sizeof(val_enum), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
val_enum = 3;
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_ENUM_TYPE, &enum_desc,
WS_WRITE_REQUIRED_VALUE, &val_enum, sizeof(val_enum), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
val_enum = ONE;
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_ENUM_TYPE, &enum_desc,
WS_WRITE_REQUIRED_VALUE, &val_enum, sizeof(val_enum), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:str xmlns:p=\"ns\">ONE</p:str>", __LINE__ );
WsFreeWriter( writer );
@@ -681,9 +681,9 @@ static void prepare_basic_type_test( WS_XML_WRITER *writer )
HRESULT hr;
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
}
static void test_basic_type(void)
@@ -723,7 +723,7 @@ static void test_basic_type(void)
};
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* element content type mapping */
for (i = 0; i < ARRAY_SIZE( tests ); i++)
@@ -731,10 +731,10 @@ static void test_basic_type(void)
prepare_basic_type_test( writer );
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, tests[i].type, NULL,
WS_WRITE_REQUIRED_VALUE, &tests[i].val, tests[i].size, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, tests[i].result, __LINE__ );
}
@@ -746,10 +746,10 @@ static void test_basic_type(void)
prepare_basic_type_test( writer );
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, tests[i].type, NULL,
WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, tests[i].result, __LINE__ );
}
@@ -758,17 +758,17 @@ static void test_basic_type(void)
{
prepare_basic_type_test( writer );
hr = WsWriteStartAttribute( writer, NULL, &localname, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ATTRIBUTE_TYPE_MAPPING, tests[i].type, NULL,
WS_WRITE_REQUIRED_VALUE, &tests[i].val, tests[i].size, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, tests[i].result2, __LINE__ );
}
@@ -776,9 +776,9 @@ static void test_basic_type(void)
memset( &guid, 0, sizeof(guid) );
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_GUID_TYPE, NULL, WS_WRITE_REQUIRED_VALUE,
&guid, sizeof(guid), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>00000000-0000-0000-0000-000000000000</t>", __LINE__ );
prepare_basic_type_test( writer );
@@ -786,18 +786,18 @@ static void test_basic_type(void)
string.length = 4;
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_STRING_TYPE, NULL, WS_WRITE_REQUIRED_VALUE,
&string, sizeof(string), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>test</t>", __LINE__ );
prepare_basic_type_test( writer );
str = L"test";
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL, WS_WRITE_REQUIRED_POINTER,
&str, sizeof(str), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>test</t>", __LINE__ );
prepare_basic_type_test( writer );
@@ -805,9 +805,9 @@ static void test_basic_type(void)
xmlstr.length = 4;
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_XML_STRING_TYPE, NULL, WS_WRITE_REQUIRED_VALUE,
&xmlstr, sizeof(xmlstr), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>test</t>", __LINE__ );
prepare_basic_type_test( writer );
@@ -815,35 +815,35 @@ static void test_basic_type(void)
bytes.length = 4;
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_BYTES_TYPE, NULL, WS_WRITE_REQUIRED_VALUE,
&bytes, sizeof(bytes), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>dGVzdA==</t>", __LINE__ );
prepare_basic_type_test( writer );
bytes.length = 0;
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_BYTES_TYPE, NULL, WS_WRITE_REQUIRED_VALUE,
&bytes, sizeof(bytes), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t/>", __LINE__ );
prepare_basic_type_test( writer );
bytes.bytes = NULL;
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_BYTES_TYPE, NULL, WS_WRITE_REQUIRED_VALUE,
&bytes, sizeof(bytes), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t/>", __LINE__ );
prepare_basic_type_test( writer );
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_BYTES_TYPE, NULL, WS_WRITE_NILLABLE_VALUE,
&bytes, sizeof(bytes), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t a:nil=\"true\" xmlns:a=\"http://www.w3.org/2001/XMLSchema-instance\"/>",
__LINE__ );
@@ -851,9 +851,9 @@ static void test_basic_type(void)
memset( &id, 0, sizeof(id) );
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_UNIQUE_ID_TYPE, NULL, WS_WRITE_REQUIRED_VALUE,
&id, sizeof(id), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>urn:uuid:00000000-0000-0000-0000-000000000000</t>", __LINE__ );
prepare_basic_type_test( writer );
@@ -861,9 +861,9 @@ static void test_basic_type(void)
id.uri.chars = (WCHAR *)L"test";
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_UNIQUE_ID_TYPE, NULL, WS_WRITE_REQUIRED_VALUE,
&id, sizeof(id), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>test</t>", __LINE__ );
WsFreeWriter( writer );
@@ -882,13 +882,13 @@ static void test_simple_struct_type(void)
} *test;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_TEXT_FIELD_MAPPING;
@@ -905,67 +905,67 @@ static void test_simple_struct_type(void)
test->field = L"value";
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, NULL,
WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, NULL,
WS_WRITE_REQUIRED_VALUE, test, sizeof(*test), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<struct>value</struct>", __LINE__ );
/* required value */
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_VALUE, test, sizeof(*test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<struct>value</struct>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<struct>value</struct>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, NULL, &localname, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ATTRIBUTE_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<struct struct=\"value\"/>", __LINE__ );
free( test );
@@ -983,10 +983,10 @@ static void test_WsWriteElement(void)
struct test { const WCHAR *str; } *test;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* text field mapping */
memset( &f, 0, sizeof(f) );
@@ -1008,45 +1008,45 @@ static void test_WsWriteElement(void)
test = malloc( sizeof(*test) );
test->str = L"test";
hr = WsWriteElement( NULL, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteElement( writer, NULL, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteElement( writer, &desc, WS_WRITE_REQUIRED_POINTER, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteElement( writer, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<str>test</str>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteElement( writer, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<str><str>test</str>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* attribute field mapping */
f.mapping = WS_ATTRIBUTE_FIELD_MAPPING;
/* requires localName and ns to be set */
hr = WsWriteElement( writer, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
f.localName = &localname;
f.ns = &ns;
hr = WsWriteElement( writer, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<str str=\"test\"/>", __LINE__ );
free( test );
@@ -1085,51 +1085,51 @@ static void test_WsWriteValue(void)
};
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteValue( NULL, tests[0].type, &tests[0].val, tests[0].size, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteValue( writer, tests[0].type, &tests[0].val, tests[0].size, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* zero size */
hr = WsWriteValue( writer, tests[0].type, &tests[0].val, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* NULL value */
hr = WsWriteValue( writer, tests[0].type, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
/* element type mapping */
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteValue( writer, tests[i].type, &tests[i].val, tests[i].size, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, tests[i].result, __LINE__ );
}
@@ -1137,22 +1137,22 @@ static void test_WsWriteValue(void)
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, NULL, &localname, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteValue( writer, tests[i].type, &tests[i].val, tests[i].size, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, tests[i].result2, __LINE__ );
}
@@ -1170,10 +1170,10 @@ static void test_WsWriteAttribute(void)
struct test { const WCHAR *str; } *test;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* text field mapping */
memset( &f, 0, sizeof(f) );
@@ -1195,28 +1195,28 @@ static void test_WsWriteAttribute(void)
test = malloc( sizeof(*test) );
test->str = L"test";
hr = WsWriteAttribute( NULL, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteAttribute( writer, NULL, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteAttribute( writer, &desc, WS_WRITE_REQUIRED_POINTER, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsWriteAttribute( writer, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteAttribute( writer, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<str str=\"test\"/>", __LINE__ );
free( test );
@@ -1231,40 +1231,40 @@ static void test_WsWriteStartCData(void)
WS_XML_UTF8_TEXT text = {{WS_XML_TEXT_TYPE_UTF8}};
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndCData( writer, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteStartCData( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t><![CDATA[", __LINE__ );
text.value.bytes = (BYTE *)"<data>";
text.value.length = 6;
hr = WsWriteText( writer, &text.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t><![CDATA[<data>", __LINE__ );
hr = WsWriteEndCData( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t><![CDATA[<data>]]>", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t><![CDATA[<data>]]></t>", __LINE__ );
WsFreeWriter( writer );
@@ -1279,18 +1279,18 @@ static void check_output_buffer( WS_XML_BUFFER *buffer, const char *expected, un
HRESULT hr;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteXmlBuffer( writer, buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &bytes, 0, sizeof(bytes) );
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
- ok( hr == S_OK, "%u: got %08x\n", line, hr );
- ok( bytes.length == len, "%u: got %u expected %u\n", line, bytes.length, len );
+ ok( hr == S_OK, "%u: got %#lx\n", line, hr );
+ ok( bytes.length == len, "%u: got %lu expected %d\n", line, bytes.length, len );
if (bytes.length != len) return;
ok( !memcmp( bytes.bytes, expected, len ), "%u: got %s expected %s\n", line, bytes.bytes, expected );
@@ -1303,16 +1303,16 @@ static void prepare_xmlns_test( WS_XML_WRITER *writer, WS_HEAP **heap, WS_XML_BU
HRESULT hr;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( *heap, NULL, 0, buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, *buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
}
static void test_WsWriteXmlnsAttribute(void)
@@ -1327,149 +1327,149 @@ static void test_WsWriteXmlnsAttribute(void)
HRESULT hr;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteXmlnsAttribute( NULL, NULL, NULL, FALSE, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeHeap( heap );
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteXmlnsAttribute( writer, NULL, NULL, FALSE, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeHeap( heap );
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteXmlnsAttribute( writer, &prefix2, NULL, FALSE, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteXmlnsAttribute( writer, NULL, &ns, FALSE, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
WsFreeHeap( heap );
/* no prefix */
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteXmlnsAttribute( writer, NULL, &ns2, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<prefix:t xmlns:prefix=\"ns\" xmlns=\"ns2\"/>", __LINE__ );
WsFreeHeap( heap );
/* prefix */
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns2, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<prefix:t xmlns:prefix2=\"ns2\" xmlns:prefix=\"ns\"/>", __LINE__ );
WsFreeHeap( heap );
/* implicitly set element prefix namespace */
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<prefix:t xmlns:prefix=\"ns\"/>", __LINE__ );
WsFreeHeap( heap );
/* explicitly set element prefix namespace */
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteXmlnsAttribute( writer, &prefix, &ns, TRUE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<prefix:t xmlns:prefix='ns'/>", __LINE__ );
WsFreeHeap( heap );
/* repeated calls, same namespace */
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<prefix:t xmlns:prefix2=\"ns\" xmlns:prefix=\"ns\"/>", __LINE__ );
WsFreeHeap( heap );
/* repeated calls, different namespace */
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns2, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
WsFreeHeap( heap );
/* single quotes */
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns, TRUE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<prefix:t xmlns:prefix2='ns' xmlns:prefix=\"ns\"/>", __LINE__ );
WsFreeHeap( heap );
/* different namespace, different prefix */
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns2, TRUE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<prefix:t xmlns:prefix2='ns2' xmlns:prefix=\"ns\"/>", __LINE__ );
WsFreeHeap( heap );
/* different namespace, same prefix */
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteXmlnsAttribute( writer, &prefix, &ns2, TRUE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
WsFreeHeap( heap );
/* regular attribute */
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteStartAttribute( writer, &xmlns, &prefix2, &ns2, TRUE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
WsFreeHeap( heap );
/* attribute order */
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteXmlnsAttribute( writer, &prefix, &ns, TRUE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, &prefix, &attr, &ns, TRUE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns2, TRUE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<prefix:t prefix:attr='' xmlns:prefix='ns' xmlns:prefix2='ns2'/>", __LINE__ );
WsFreeHeap( heap );
/* scope */
prepare_xmlns_test( writer, &heap, &buffer );
hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns2, TRUE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix2, &localname, &ns2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<prefix:t xmlns:prefix2='ns2' xmlns:prefix=\"ns\"><prefix2:u/></prefix:t>",
__LINE__ );
WsFreeHeap( heap );
@@ -1483,11 +1483,11 @@ static void prepare_prefix_test( WS_XML_WRITER *writer )
HRESULT hr;
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &p, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndStartElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
}
static void test_WsGetPrefixFromNamespace(void)
@@ -1498,72 +1498,72 @@ static void test_WsGetPrefixFromNamespace(void)
HRESULT hr;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &p, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetPrefixFromNamespace( NULL, NULL, FALSE, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetPrefixFromNamespace( NULL, NULL, FALSE, &prefix, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsGetPrefixFromNamespace( writer, NULL, FALSE, &prefix, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
/* element must be committed */
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &p, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetPrefixFromNamespace( writer, &ns, TRUE, &prefix, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
/* but writer can't be positioned on end element node */
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &p, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetPrefixFromNamespace( writer, &ns, TRUE, &prefix, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
/* required = TRUE */
prefix = NULL;
prepare_prefix_test( writer );
hr = WsGetPrefixFromNamespace( writer, &ns, TRUE, &prefix, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( prefix != NULL, "prefix not set\n" );
if (prefix)
{
- ok( prefix->length == 1, "got %u\n", prefix->length );
+ ok( prefix->length == 1, "got %lu\n", prefix->length );
ok( !memcmp( prefix->bytes, "p", 1 ), "wrong prefix\n" );
}
prefix = (const WS_XML_STRING *)0xdeadbeef;
hr = WsGetPrefixFromNamespace( writer, &ns2, TRUE, &prefix, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
ok( prefix == (const WS_XML_STRING *)0xdeadbeef, "prefix set\n" );
/* required = FALSE */
prefix = NULL;
prepare_prefix_test( writer );
hr = WsGetPrefixFromNamespace( writer, &ns, FALSE, &prefix, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( prefix != NULL, "prefix not set\n" );
if (prefix)
{
- ok( prefix->length == 1, "got %u\n", prefix->length );
+ ok( prefix->length == 1, "got %lu\n", prefix->length );
ok( !memcmp( prefix->bytes, "p", 1 ), "wrong prefix\n" );
}
prefix = (const WS_XML_STRING *)0xdeadbeef;
hr = WsGetPrefixFromNamespace( writer, &ns2, FALSE, &prefix, NULL );
- ok( hr == S_FALSE, "got %08x\n", hr );
+ ok( hr == S_FALSE, "got %#lx\n", hr );
ok( prefix == NULL, "prefix not set\n" );
WsFreeWriter( writer );
@@ -1598,19 +1598,19 @@ static void test_complex_struct_type(void)
} *test;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &str_officeconfig, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f2, 0, sizeof(f2) );
f2.mapping = WS_ATTRIBUTE_FIELD_MAPPING;
@@ -1657,10 +1657,10 @@ static void test_complex_struct_type(void)
test->services->generationtime = L"2015-09-03T18:47:54";
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, expected, __LINE__ );
free( test );
@@ -1677,63 +1677,63 @@ static void test_WsMoveWriter(void)
HRESULT hr;
hr = WsMoveWriter( NULL, WS_MOVE_TO_EOF, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* writer must be set to an XML buffer */
hr = WsMoveWriter( writer, WS_MOVE_TO_EOF, NULL, NULL );
- todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveWriter( writer, WS_MOVE_TO_EOF, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* <a><b/></a> */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname2, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveWriter( writer, WS_MOVE_TO_EOF, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveWriter( writer, WS_MOVE_TO_ROOT_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveWriter( writer, WS_MOVE_TO_CHILD_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveWriter( writer, WS_MOVE_TO_END_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveWriter( writer, WS_MOVE_TO_PARENT_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveWriter( writer, WS_MOVE_TO_END_ELEMENT, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsMoveWriter( writer, WS_MOVE_TO_BOF, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
WsFreeWriter( writer );
WsFreeHeap( heap );
@@ -1748,36 +1748,36 @@ static void test_WsGetWriterPosition(void)
HRESULT hr;
hr = WsGetWriterPosition( NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetWriterPosition( writer, &pos, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* writer must be set to an XML buffer */
hr = WsGetWriterPosition( writer, &pos, NULL );
- todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetWriterPosition( writer, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
pos.buffer = pos.node = NULL;
hr = WsGetWriterPosition( writer, &pos, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( pos.buffer != NULL, "buffer not set\n" );
ok( pos.node != NULL, "node not set\n" );
@@ -1795,62 +1795,62 @@ static void test_WsSetWriterPosition(void)
HRESULT hr;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetWriterPosition( NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buf1, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buf1, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetWriterPosition( writer, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
pos.buffer = pos.node = NULL;
hr = WsGetWriterPosition( writer, &pos, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( pos.buffer == buf1, "wrong buffer\n" );
ok( pos.node != NULL, "node not set\n" );
hr = WsSetWriterPosition( writer, &pos, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* different buffer */
hr = WsCreateXmlBuffer( heap, NULL, 0, &buf2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
pos.buffer = buf2;
hr = WsSetWriterPosition( writer, &pos, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buf1, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* try to write at non-final position */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
pos.buffer = pos.node = NULL;
hr = WsGetWriterPosition( writer, &pos, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( pos.buffer == buf1, "wrong buffer\n" );
ok( pos.node != NULL, "node not set\n" );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buf1, "<t/>", __LINE__ );
hr = WsSetWriterPosition( writer, &pos, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
WsFreeWriter( writer );
WsFreeHeap( heap );
@@ -1865,48 +1865,48 @@ static void test_WsWriteXmlBuffer(void)
HRESULT hr;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( NULL, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer1, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer1, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer1, buffer1, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer1, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer1, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer1, "<t/>", __LINE__ );
hr = WsCreateWriter( NULL, 0, &writer2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer2, buffer2, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteXmlBuffer( writer2, buffer1, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer2, "<t/>", __LINE__ );
hr = WsMoveWriter( writer2, WS_MOVE_TO_PREVIOUS_ELEMENT, NULL, NULL );
- todo_wine ok( hr == S_OK, "got %08x\n", hr );
+ todo_wine ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteXmlBuffer( writer2, buffer1, NULL );
- todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
WsFreeWriter( writer1 );
WsFreeWriter( writer2 );
@@ -1928,22 +1928,22 @@ static void test_WsWriteNode(void)
HRESULT hr;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteNode( NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteNode( writer, NULL, NULL );
- todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
utf8.value.bytes = (BYTE *)"value";
utf8.value.length = sizeof("value") - 1;
@@ -1964,43 +1964,43 @@ static void test_WsWriteNode(void)
elem.attributes = attrs;
elem.isEmpty = FALSE;
hr = WsWriteNode( writer, &elem.node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
comment.value.bytes = (BYTE *)"comment";
comment.value.length = sizeof("comment") - 1;
hr = WsWriteNode( writer, &comment.node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node.nodeType = WS_XML_NODE_TYPE_EOF;
hr = WsWriteNode( writer, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node.nodeType = WS_XML_NODE_TYPE_BOF;
hr = WsWriteNode( writer, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node.nodeType = WS_XML_NODE_TYPE_CDATA;
hr = WsWriteNode( writer, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
utf8.value.bytes = (BYTE *)"cdata";
utf8.value.length = sizeof("cdata") - 1;
text.text = &utf8.text;
hr = WsWriteNode( writer, &text.node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node.nodeType = WS_XML_NODE_TYPE_END_CDATA;
hr = WsWriteNode( writer, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
utf8.value.bytes = (BYTE *)"text";
utf8.value.length = sizeof("text") - 1;
hr = WsWriteNode( writer, &text.node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
node.nodeType = WS_XML_NODE_TYPE_END_ELEMENT;
hr = WsWriteNode( writer, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<t attr='value'><!--comment--><![CDATA[cdata]]>text</t>", __LINE__ );
WsFreeWriter( writer );
@@ -2027,112 +2027,112 @@ static void test_WsCopyNode(void)
HRESULT hr;
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname2, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetWriterPosition( writer, &pos, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<t><u/></t>", __LINE__ );
hr = WsCreateReader( NULL, 0, &reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_input( reader, "<v/>", sizeof("<v/>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof("<v/>") - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetWriterPosition( writer, &pos, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCopyNode( writer, reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_buffer( buffer, "<t><u/><v/></t>", __LINE__ );
hr = WsGetWriterPosition( writer, &pos2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( pos2.buffer == pos.buffer, "wrong buffer\n" );
ok( pos2.node == pos.node, "wrong node\n" );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
/* reader positioned at EOF */
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCopyNode( writer, reader, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
/* reader positioned at BOF */
hr = set_input( reader, "<v/>", sizeof("<v/>") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFillReader( reader, sizeof("<v/>") - 1, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCopyNode( writer, reader, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<v/>", __LINE__ );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
memset( &bufs, 0, sizeof(bufs) );
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BUFFERS, &bufs, sizeof(bufs), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( bufs.bufferCount == 1, "got %u\n", bufs.bufferCount );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( bufs.bufferCount == 1, "got %lu\n", bufs.bufferCount );
ok( bufs.buffers != NULL, "buffers not set\n" );
/* reader positioned at BOF, single text node */
hr = set_input( reader, "text", sizeof("text") - 1 );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsGetReaderNode( reader, &node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
ok( node->nodeType == WS_XML_NODE_TYPE_BOF, "got %u\n", node->nodeType );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsCopyNode( writer, reader, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
WsFreeReader( reader );
WsFreeWriter( writer );
@@ -2185,36 +2185,36 @@ static void test_text_types(void)
val_qname.ns = &ns;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteText( writer, tests[i].text, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
check_output( writer, tests[i].result, __LINE__ );
}
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
val_qname.prefix = &prefix;
val_qname.localName = &localname2;
val_qname.ns = &ns2;
hr = WsWriteText( writer, &val_qname.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:t xmlns:p=\"ns\">p:u</p:t>", __LINE__ );
WsFreeWriter( writer );
@@ -2253,83 +2253,83 @@ static void test_double(void)
ULONG i;
hr = WsCreateWriter( NULL, 0, &writer, NULL ) ;
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text.text.textType = WS_XML_TEXT_TYPE_DOUBLE;
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
text.value = tests[i].val;
hr = WsWriteText( writer, &text.text, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
check_output( writer, tests[i].result, __LINE__ );
}
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text.value = NAN;
hr = WsWriteText( writer, &text.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>NaN</t>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text.value = INFINITY;
hr = WsWriteText( writer, &text.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>INF</t>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text.value = -INFINITY;
hr = WsWriteText( writer, &text.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>-INF</t>", __LINE__ );
fpword_orig = _control87( 0, 0 );
fpword = _control87( _MCW_EM | _RC_CHOP | _PC_64, _MCW_EM | _MCW_RC | _MCW_PC );
- ok( fpword == (_MCW_EM | _RC_CHOP | _PC_64), "got %08x\n", fpword );
+ ok( fpword == (_MCW_EM | _RC_CHOP | _PC_64), "got %#x\n", fpword );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
text.value = 100000000000000;
hr = WsWriteText( writer, &text.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>100000000000000</t>", __LINE__ );
fpword = _control87( 0, 0 );
- ok( fpword == (_MCW_EM | _RC_CHOP | _PC_64), "got %08x\n", fpword );
+ ok( fpword == (_MCW_EM | _RC_CHOP | _PC_64), "got %#x\n", fpword );
_control87( fpword_orig, _MCW_EM | _MCW_RC | _MCW_PC );
WsFreeWriter( writer );
@@ -2358,13 +2358,13 @@ static void test_field_options(void)
} test;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_ELEMENT_FIELD_MAPPING;
@@ -2420,10 +2420,10 @@ static void test_field_options(void)
test.int32_ptr = &val;
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, expected, __LINE__ );
WsFreeWriter( writer );
@@ -2439,185 +2439,185 @@ static void test_WsWriteText(void)
WS_XML_GUID_TEXT guid = {{WS_XML_TEXT_TYPE_GUID}};
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
utf8.value.bytes = (BYTE *)"test";
utf8.value.length = 4;
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* element, utf8 */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>test", __LINE__ );
utf8.value.bytes = (BYTE *)"tset";
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>testtset", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>testtset</t>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* attribute, utf8 */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, NULL, &localname2, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
utf8.value.bytes = (BYTE *)"test";
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t a=\"tsettest\"/>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* element, utf16 */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
utf16.bytes = (BYTE *)L"test";
utf16.byteCount = 8;
hr = WsWriteText( writer, &utf16.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>test", __LINE__ );
hr = WsWriteText( writer, &utf16.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>testtest", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>testtest</t>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* attribute, utf16 */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, NULL, &localname2, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteText( writer, &utf16.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteText( writer, &utf16.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t a=\"testtest\"/>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* element, guid */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteText( writer, &guid.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>00000000-0000-0000-0000-000000000000", __LINE__ );
hr = WsWriteText( writer, &guid.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>00000000-0000-0000-0000-00000000000000000000-0000-0000-0000-000000000000",
__LINE__ );
/* continue with different text type */
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>00000000-0000-0000-0000-00000000000000000000-0000-0000-0000-000000000000test",
__LINE__ );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* attribute, guid */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, NULL, &localname2, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteText( writer, &guid.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteText( writer, &guid.text, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* attribute, mix allowed text types */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, NULL, &localname2, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteText( writer, &utf16.text, NULL );
- todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* cdata */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartCData( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteText( writer, &guid.text, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndCData( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t><![CDATA[test00000000-0000-0000-0000-000000000000]]></t>", __LINE__ );
WsFreeWriter( writer );
@@ -2632,78 +2632,78 @@ static void test_WsWriteArray(void)
HRESULT hr;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteArray( writer, NULL, NULL, 0, NULL, 0, 0, 0, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteArray( writer, NULL, NULL, 0, NULL, 0, 0, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteArray( writer, &localname, NULL, 0, NULL, 0, 0, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteArray( writer, &localname, &ns, 0, NULL, 0, 0, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteArray( writer, &localname, &ns, ~0u, NULL, 0, 0, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteArray( writer, &localname, &ns, WS_BOOL_VALUE_TYPE, NULL, 0, 0, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
array_bool[0] = FALSE;
hr = WsWriteArray( writer, &localname, &ns, WS_BOOL_VALUE_TYPE, array_bool, 0, 0, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteArray( writer, &localname, &ns, WS_BOOL_VALUE_TYPE, array_bool, sizeof(array_bool), 0, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteArray( writer, &localname, &ns, WS_BOOL_VALUE_TYPE, NULL, sizeof(array_bool), 0, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteArray( writer, &localname, &ns, WS_BOOL_VALUE_TYPE, NULL, sizeof(array_bool), 0, 1, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteArray( writer, &localname, &ns, WS_BOOL_VALUE_TYPE, array_bool, sizeof(array_bool), 0, 1, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<item>false</item>", __LINE__ );
hr = WsWriteArray( writer, &localname, &ns, WS_BOOL_VALUE_TYPE, array_bool, sizeof(array_bool) - 1, 0, 2, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteArray( writer, &localname, &ns, WS_BOOL_VALUE_TYPE, array_bool, sizeof(array_bool), 0, 3, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname2, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
array_bool[1] = TRUE;
hr = WsWriteArray( writer, &localname, &ns, WS_BOOL_VALUE_TYPE, array_bool, sizeof(array_bool), 0, 2, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<array><item>false</item><item>true</item></array>", __LINE__ );
WsFreeWriter( writer );
@@ -2761,68 +2761,68 @@ static void test_escapes(void)
ULONG i;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests_elem ); i++)
{
hr = set_output( writer );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
utf8.value.bytes = (BYTE *)tests_elem[i].text;
utf8.value.length = strlen( tests_elem[i].text );
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
check_output( writer, tests_elem[i].result, __LINE__ );
}
for (i = 0; i < ARRAY_SIZE( tests_attr ); i++)
{
hr = set_output( writer );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteStartAttribute( writer, NULL, &localname, &ns, tests_attr[i].single, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
utf8.value.bytes = (BYTE *)tests_attr[i].text;
utf8.value.length = strlen( tests_attr[i].text );
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
check_output( writer, tests_attr[i].result, __LINE__ );
}
for (i = 0; i < ARRAY_SIZE( tests_cdata ); i++)
{
hr = set_output( writer );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteStartCData( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
utf8.value.bytes = (BYTE *)tests_cdata[i].text;
utf8.value.length = strlen( tests_cdata[i].text );
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndCData( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
check_output( writer, tests_cdata[i].result, __LINE__ );
}
@@ -2831,17 +2831,17 @@ static void test_escapes(void)
WS_XML_COMMENT_NODE comment = {{WS_XML_NODE_TYPE_COMMENT}};
hr = set_output( writer );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
comment.value.bytes = (BYTE *)tests_comment[i].text;
comment.value.length = strlen( tests_comment[i].text );
hr = WsWriteNode( writer, &comment.node, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
check_output( writer, tests_comment[i].result, __LINE__ );
}
@@ -2942,16 +2942,16 @@ static void test_write_option(void)
ULONG i;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
hr = set_output( writer );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, tests[i].type, NULL, tests[i].option, tests[i].value,
tests[i].size, NULL );
- ok( hr == tests[i].hr, "%u: got %08x\n", i, hr );
+ ok( hr == tests[i].hr, "%lu: got %#lx\n", i, hr );
WsWriteEndElement( writer, NULL );
if (hr == S_OK) check_output( writer, tests[i].result, __LINE__ );
}
@@ -3030,11 +3030,11 @@ static void test_datetime(void)
ULONG i;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
date.ticks = tests[i].ticks;
date.format = tests[i].format;
@@ -3042,13 +3042,13 @@ static void test_datetime(void)
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_DATETIME_TYPE, NULL, WS_WRITE_REQUIRED_VALUE,
&date, sizeof(date), NULL );
WsWriteEndElement( writer, NULL );
- ok( hr == tests[i].hr || broken(hr == tests[i].hr_broken), "%u: got %08x\n", i, hr );
+ ok( hr == tests[i].hr || broken(hr == tests[i].hr_broken), "%lu: got %#lx\n", i, hr );
if (hr != tests[i].hr && hr == tests[i].hr_broken) break;
if (hr == S_OK)
{
ok( check_result( writer, tests[i].result ) ||
(tests[i].result2 && broken(check_result( writer, tests[i].result2 ))),
- "%u: wrong result\n", i );
+ "%lu: wrong result\n", i );
}
}
@@ -3085,13 +3085,13 @@ static void test_repeating_element(void)
} *test3;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* array of strings, wrapper */
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_REPEATING_ELEMENT_FIELD_MAPPING;
@@ -3112,9 +3112,9 @@ static void test_repeating_element(void)
s.fieldCount = 1;
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
test = malloc( sizeof(*test) + 2 * sizeof(const WCHAR *) );
test->val = (const WCHAR **)(test + 1);
@@ -3123,17 +3123,17 @@ static void test_repeating_element(void)
test->count = 2;
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<test><wrapper><val>1</val><val>2</val></wrapper></test>", __LINE__ );
free( test );
/* array of integers, no wrapper */
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
f.type = WS_INT32_TYPE;
f.localName = NULL;
@@ -3146,16 +3146,16 @@ static void test_repeating_element(void)
test2->count = 2;
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_POINTER, &test2, sizeof(test2), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<test><val>1</val><val>2</val></test>", __LINE__ );
/* item range has no effect */
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
range.minItemCount = 0;
range.maxItemCount = 0;
@@ -3163,17 +3163,17 @@ static void test_repeating_element(void)
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_POINTER, &test2, sizeof(test2), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<test><val>1</val><val>2</val></test>", __LINE__ );
free( test2 );
/* nillable item */
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f2, 0, sizeof(f2) );
f2.mapping = WS_ELEMENT_FIELD_MAPPING;
@@ -3206,9 +3206,9 @@ static void test_repeating_element(void)
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_POINTER, &test3, sizeof(test3), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<test><wrapper><val><data>-1</data></val><val a:nil=\"true\" "
"xmlns:a=\"http://www.w3.org/2001/XMLSchema-instance\"/></wrapper></test>", __LINE__ );
free( test3 );
@@ -3259,19 +3259,19 @@ static void test_WsWriteQualifiedName(void)
};
hr = WsWriteQualifiedName( NULL, NULL, NULL, NULL, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteQualifiedName( writer, NULL, NULL, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteQualifiedName( writer, NULL, NULL, NULL, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( tests ); i++)
{
@@ -3279,17 +3279,17 @@ static void test_WsWriteQualifiedName(void)
const WS_XML_STRING *prefix_ptr, *localname_ptr, *ns_ptr;
hr = set_output( writer );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
prefix_ptr = init_xmlstring( tests[i].prefix, &prefix2 );
localname_ptr = init_xmlstring( tests[i].localname, &localname2 );
ns_ptr = init_xmlstring( tests[i].ns, &ns2 );
hr = WsWriteQualifiedName( writer, prefix_ptr, localname_ptr, ns_ptr, NULL );
- ok( hr == tests[i].hr, "%u: got %08x\n", i, hr );
+ ok( hr == tests[i].hr, "%lu: got %#lx\n", i, hr );
if (tests[i].hr == S_OK && hr == S_OK) check_output( writer, tests[i].result, __LINE__ );
}
@@ -3303,61 +3303,61 @@ static void test_WsWriteBytes(void)
HRESULT hr;
hr = WsWriteBytes( NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteBytes( writer, NULL, 0, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsWriteBytes( writer, "test", 0, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsWriteBytes( writer, NULL, 1, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsWriteBytes( writer, "test", sizeof("test"), NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteBytes( writer, "test", sizeof("test"), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* element */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteBytes( writer, "test", sizeof("test"), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>dGVzdAA=</t>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* attribute */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, NULL, &localname2, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteBytes( writer, "test", sizeof("test"), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t a=\"dGVzdAA=\"/>", __LINE__ );
WsFreeWriter( writer );
@@ -3370,67 +3370,67 @@ static void test_WsWriteChars(void)
HRESULT hr;
hr = WsWriteChars( NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteChars( writer, NULL, 0, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsWriteChars( writer, L"test", 0, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsWriteChars( writer, NULL, 1, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsWriteChars( writer, L"test", 4, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteChars( writer, L"test", 4, NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* element */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteChars( writer, L"test", 4, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteChars( writer, L"test", 4, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>testtest</t>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* attribute */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, NULL, &localname2, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteChars( writer, L"test", 4, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteChars( writer, L"test", 4, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t a=\"testtest\"/>", __LINE__ );
WsFreeWriter( writer );
@@ -3444,67 +3444,67 @@ static void test_WsWriteCharsUtf8(void)
HRESULT hr;
hr = WsWriteCharsUtf8( NULL, NULL, 0, NULL );
- ok( hr == E_INVALIDARG, "got %08x\n", hr );
+ ok( hr == E_INVALIDARG, "got %#lx\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteCharsUtf8( writer, NULL, 0, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsWriteCharsUtf8( writer, test, 0, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsWriteCharsUtf8( writer, NULL, 1, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = WsWriteCharsUtf8( writer, test, sizeof(test), NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteCharsUtf8( writer, test, sizeof(test), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* element */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteCharsUtf8( writer, test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteCharsUtf8( writer, test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t>testtest</t>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
/* attribute */
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, NULL, &localname2, &ns, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteCharsUtf8( writer, test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteCharsUtf8( writer, test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t a=\"testtest\"/>", __LINE__ );
WsFreeWriter( writer );
@@ -3518,8 +3518,8 @@ static void check_output_bin( WS_XML_WRITER *writer, const char *expected, int l
memset( &bytes, 0, sizeof(bytes) );
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
- ok( hr == S_OK, "%u: got %08x\n", line, hr );
- ok( bytes.length == len, "%u: got %u expected %u\n", line, bytes.length, len );
+ ok( hr == S_OK, "%u: got %#lx\n", line, hr );
+ ok( bytes.length == len, "%u: got %lu expected %d\n", line, bytes.length, len );
if (bytes.length != len) return;
ok( !memcmp( bytes.bytes, expected, bytes.length ), "%u: got %s expected %s\n", line,
debugstr_bytes(bytes.bytes, bytes.length), debugstr_bytes((const BYTE *)expected, len) );
@@ -3590,65 +3590,65 @@ static void test_binary_encoding(void)
};
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE( elem_tests ); i++)
{
hr = WsSetOutput( writer, &bin.encoding, &buf.output, NULL, 0, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
prefix_ptr = init_xmlstring( elem_tests[i].prefix, &str );
localname_ptr = init_xmlstring( elem_tests[i].localname, &str2 );
ns_ptr = init_xmlstring( elem_tests[i].ns, &str3 );
hr = WsWriteStartElement( writer, prefix_ptr, localname_ptr, ns_ptr, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
if (elem_tests[i].text)
{
utf8.value.length = strlen( elem_tests[i].text );
utf8.value.bytes = (BYTE *)elem_tests[i].text;
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
}
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
if (hr == S_OK) check_output_bin( writer, elem_tests[i].result, elem_tests[i].len_result, __LINE__ );
}
for (i = 0; i < ARRAY_SIZE( attr_tests ); i++)
{
hr = WsSetOutput( writer, &bin.encoding, &buf.output, NULL, 0, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
prefix_ptr = init_xmlstring( attr_tests[i].prefix, &str );
localname_ptr = init_xmlstring( attr_tests[i].localname, &str2 );
ns_ptr = init_xmlstring( elem_tests[i].ns, &str3 );
hr = WsWriteStartElement( writer, NULL, &localname2, &empty, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteStartAttribute( writer, prefix_ptr, localname_ptr, ns_ptr, FALSE, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
if (attr_tests[i].value)
{
utf8.value.length = strlen( attr_tests[i].value );
utf8.value.bytes = (BYTE *)attr_tests[i].value;
hr = WsWriteText( writer, &utf8.text, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
}
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
if (hr == S_OK) check_output_bin( writer, attr_tests[i].result, attr_tests[i].len_result, __LINE__ );
}
hr = WsSetOutput( writer, &bin.encoding, &buf.output, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
comment.value.bytes = (BYTE *)"comment";
comment.value.length = sizeof("comment") - 1;
hr = WsWriteNode( writer, &comment.node, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
if (hr == S_OK) check_output_bin( writer, res200, sizeof(res200), __LINE__ );
WsFreeWriter( writer );
@@ -3663,18 +3663,18 @@ static void test_namespaces(void)
HRESULT hr;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartAttribute( writer, &prefix2, &localname2, &ns2, FALSE, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<p:t q:a=\"\" xmlns:p=\"n\" xmlns:q=\"o\"/>", __LINE__ );
WsFreeWriter( writer );
@@ -3790,7 +3790,7 @@ static void test_dictionary(void)
};
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
strings[0].length = 0;
strings[0].bytes = NULL;
@@ -3827,36 +3827,36 @@ static void test_dictionary(void)
for (i = 0; i < ARRAY_SIZE( elem_tests ); i++)
{
hr = WsSetOutput( writer, &bin.encoding, &buf.output, NULL, 0, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
prefix_ptr = init_xmlstring_dict( &dict, elem_tests[i].prefix, &prefix );
localname_ptr = init_xmlstring_dict( &dict, elem_tests[i].localname, &localname );
ns_ptr = init_xmlstring_dict( &dict, elem_tests[i].ns, &ns );
hr = WsWriteStartElement( writer, prefix_ptr, localname_ptr, ns_ptr, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
if (hr == S_OK) check_output_bin( writer, elem_tests[i].result, elem_tests[i].len_result, __LINE__ );
}
for (i = 0; i < ARRAY_SIZE( attr_tests ); i++)
{
hr = WsSetOutput( writer, &bin.encoding, &buf.output, NULL, 0, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
prefix_ptr = init_xmlstring_dict( &dict, attr_tests[i].prefix, &prefix );
localname_ptr = init_xmlstring_dict( &dict, attr_tests[i].localname, &localname );
ns_ptr = init_xmlstring_dict( &dict, attr_tests[i].ns, &ns );
hr = WsWriteStartElement( writer, NULL, &strings[3], &strings[0], NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteStartAttribute( writer, prefix_ptr, localname_ptr, ns_ptr, FALSE, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndAttribute( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
if (hr == S_OK) check_output_bin( writer, attr_tests[i].result, attr_tests[i].len_result, __LINE__ );
}
@@ -3866,85 +3866,85 @@ static void test_dictionary(void)
bin.dynamicStringCallbackState = &call_count;
hr = WsSetOutput( writer, &bin.encoding, &buf.output, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
init_xmlstring( "t", &localname );
init_xmlstring( "ns", &ns );
call_count = 0;
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( call_count == 2, "got %u\n", call_count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( call_count == 2, "got %lu\n", call_count );
check_output_bin( writer, res5, sizeof(res5), __LINE__ );
/* unknown string */
hr = WsSetOutput( writer, &bin.encoding, &buf.output, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
init_xmlstring( "u", &localname );
init_xmlstring( "ns", &ns );
call_count = 0;
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( call_count == 2, "got %u\n", call_count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( call_count == 2, "got %lu\n", call_count );
check_output_bin( writer, res6, sizeof(res6), __LINE__ );
/* unknown string, error return from callback */
hr = WsSetOutput( writer, &bin.encoding, &buf.output, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
init_xmlstring( "v", &localname );
init_xmlstring( "ns", &ns );
call_count = 0;
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( call_count == 2, "got %u\n", call_count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( call_count == 2, "got %lu\n", call_count );
check_output_bin( writer, res7, sizeof(res7), __LINE__ );
/* dictionary and callback */
hr = WsGetDictionary( WS_ENCODING_XML_BINARY_1, &dict_builtin, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
bin.staticDictionary = dict_builtin;
/* string in dictionary, no string dictionary set */
hr = WsSetOutput( writer, &bin.encoding, &buf.output, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
init_xmlstring( "t", &localname );
init_xmlstring( "ns", &ns );
call_count = 0;
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( call_count == 2, "got %u\n", call_count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( call_count == 2, "got %lu\n", call_count );
check_output_bin( writer, res8, sizeof(res8), __LINE__ );
/* string not in dictionary, no string dictionary set */
hr = WsSetOutput( writer, &bin.encoding, &buf.output, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
init_xmlstring( "z", &localname );
init_xmlstring( "ns", &ns );
call_count = 0;
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( call_count == 2, "got %u\n", call_count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( call_count == 2, "got %lu\n", call_count );
check_output_bin( writer, res9, sizeof(res9), __LINE__ );
/* string in dictionary, string dictionary set */
hr = WsSetOutput( writer, &bin.encoding, &buf.output, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
init_xmlstring_dict( dict_builtin, 235, &localname );
init_xmlstring( "ns", &ns );
call_count = 0;
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
- ok( call_count == 1, "got %u\n", call_count );
+ ok( hr == S_OK, "got %#lx\n", hr );
+ ok( call_count == 1, "got %lu\n", call_count );
check_output_bin( writer, res10, sizeof(res10), __LINE__ );
WsFreeWriter( writer );
@@ -3974,7 +3974,7 @@ static void test_union_type(void)
} test;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.value = CHOICE_A;
@@ -4017,49 +4017,49 @@ static void test_union_type(void)
s.typeNs = &str_ns;
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &str_t, &str_ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
test.choice = CHOICE_A;
test.value.a = L"test";
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t><a>test</a></t>", __LINE__ );
u.valueIndices = index;
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &str_t, &str_ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
test.choice = CHOICE_B;
test.value.b = 123;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t><b>123</b></t>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &str_t, &str_ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
test.choice = CHOICE_C;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &str_t, &str_ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
test.choice = CHOICE_NONE;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
/* field value equals noneEnumValue */
memset( &f3, 0, sizeof(f3) );
@@ -4074,28 +4074,28 @@ static void test_union_type(void)
u.fieldCount = 3;
u.valueIndices = NULL;
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &str_t, &str_ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
test.choice = CHOICE_NONE;
test.value.none = TRUE;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t><none>true</none></t>", __LINE__ );
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &str_t, &str_ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
f_struct.options = WS_FIELD_OPTIONAL;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t/>", __LINE__ );
WsFreeWriter( writer );
@@ -4109,9 +4109,9 @@ static void prepare_binary_type_test( WS_XML_WRITER *writer, const WS_XML_STRING
HRESULT hr;
hr = WsSetOutput( writer, &bin.encoding, &buf.output, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, prefix, localname, ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
}
static void test_text_types_binary(void)
@@ -4221,7 +4221,7 @@ static void test_text_types_binary(void)
BYTE buf[256];
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.value = WS_XML_TEXT_TYPE_UTF8;
@@ -4349,9 +4349,9 @@ static void test_text_types_binary(void)
test.u.val_utf8.length = 4;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res, sizeof(res), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4360,9 +4360,9 @@ static void test_text_types_binary(void)
test.u.val_utf16.length = 4;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res, sizeof(res), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4371,9 +4371,9 @@ static void test_text_types_binary(void)
test.u.val_bytes.length = 4;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res2, sizeof(res2), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4382,9 +4382,9 @@ static void test_text_types_binary(void)
test.u.val_bytes.length = 3;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res2a, sizeof(res2a), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4393,9 +4393,9 @@ static void test_text_types_binary(void)
test.u.val_bytes.length = 1;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res2b, sizeof(res2b), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4404,9 +4404,9 @@ static void test_text_types_binary(void)
test.u.val_bytes.length = 0;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res2c, sizeof(res2c), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4416,9 +4416,9 @@ static void test_text_types_binary(void)
test.u.val_bytes.length = 255;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res2d, sizeof(res2d), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4427,9 +4427,9 @@ static void test_text_types_binary(void)
test.u.val_bytes.length = 256;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res2e, sizeof(res2e), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4438,9 +4438,9 @@ static void test_text_types_binary(void)
test.u.val_bytes.length = 6;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res2f, sizeof(res2f), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4448,9 +4448,9 @@ static void test_text_types_binary(void)
test.u.val_bool = TRUE;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res3, sizeof(res3), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4458,9 +4458,9 @@ static void test_text_types_binary(void)
test.u.val_int32 = -1;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res4, sizeof(res4), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4468,9 +4468,9 @@ static void test_text_types_binary(void)
test.u.val_int64 = -1;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res4, sizeof(res4), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4478,9 +4478,9 @@ static void test_text_types_binary(void)
test.u.val_uint64 = 1;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res5, sizeof(res5), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4488,9 +4488,9 @@ static void test_text_types_binary(void)
test.u.val_uint64 = 2;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res5b, sizeof(res5b), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4498,9 +4498,9 @@ static void test_text_types_binary(void)
test.u.val_double = 0.0;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res6, sizeof(res6), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4508,9 +4508,9 @@ static void test_text_types_binary(void)
test.u.val_double = 2.0;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res7, sizeof(res7), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4518,9 +4518,9 @@ static void test_text_types_binary(void)
test.u.val_double = 2.1;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res8, sizeof(res8), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4528,9 +4528,9 @@ static void test_text_types_binary(void)
test.u.val_double = INFINITY;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res8a, sizeof(res8a), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4538,9 +4538,9 @@ static void test_text_types_binary(void)
test.u.val_double = -INFINITY;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res8b, sizeof(res8b), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4548,9 +4548,9 @@ static void test_text_types_binary(void)
test.u.val_double = NAN;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res8c, sizeof(res8c), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4558,9 +4558,9 @@ static void test_text_types_binary(void)
memset( &test.u.val_guid, 0, sizeof(test.u.val_guid) );
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res9, sizeof(res9), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4568,9 +4568,9 @@ static void test_text_types_binary(void)
memset( &test.u.val_unique_id, 0, sizeof(test.u.val_unique_id) );
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res10, sizeof(res10), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4578,9 +4578,9 @@ static void test_text_types_binary(void)
memset( &test.u.val_datetime, 0, sizeof(test.u.val_datetime) );
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res11, sizeof(res11), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4589,9 +4589,9 @@ static void test_text_types_binary(void)
test.u.val_datetime.format = WS_DATETIME_FORMAT_LOCAL;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res11b, sizeof(res11b), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4600,9 +4600,9 @@ static void test_text_types_binary(void)
test.u.val_datetime.format = WS_DATETIME_FORMAT_NONE;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res11c, sizeof(res11c), __LINE__ );
prepare_binary_type_test( writer, NULL, &str_t, &str_ns );
@@ -4611,9 +4611,9 @@ static void test_text_types_binary(void)
test.u.val_datetime.ticks = 1;
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, WS_WRITE_REQUIRED_VALUE,
&test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output_bin( writer, res11d, sizeof(res11d), __LINE__ );
WsFreeWriter( writer );
@@ -4646,7 +4646,7 @@ static void test_repeating_element_choice(void)
} test;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.value = CHOICE_A;
@@ -4699,25 +4699,25 @@ static void test_repeating_element_choice(void)
test.count = 2;
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t><a>test</a><b>1</b></t>", __LINE__ );
items[0].choice = CHOICE_NONE;
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), NULL );
- ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
test.count = 0;
hr = set_output( writer );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t/>", __LINE__ );
WsFreeWriter( writer );
@@ -4740,9 +4740,9 @@ static CALLBACK HRESULT write_callback( void *state, const WS_BYTES *buf, ULONG
const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
{
ULONG i = *(ULONG *)state;
- ok( buf->length == stream_tests[i].ret_size, "%u: got %u\n", i, buf->length );
- ok( !memcmp( buf->bytes, "<t/>", stream_tests[i].ret_size ), "%u: wrong data\n", i );
- ok( count == 1, "%u: got %u\n", i, count );
+ ok( buf->length == stream_tests[i].ret_size, "%lu: got %lu\n", i, buf->length );
+ ok( !memcmp( buf->bytes, "<t/>", stream_tests[i].ret_size ), "%lu: wrong data\n", i );
+ ok( count == 1, "%lu: got %lu\n", i, count );
return S_OK;
}
@@ -4756,38 +4756,38 @@ static void test_stream_output(void)
ULONG i = 0;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFlushWriter( writer, 0, NULL, NULL );
- ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
+ ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
stream.output.outputType = WS_XML_WRITER_OUTPUT_TYPE_STREAM;
stream.writeCallback = write_callback;
stream.writeCallbackState = &i;
hr = WsSetOutput( writer, &text.encoding, &stream.output, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsSetOutput( writer, &text.encoding, &stream.output, NULL, 0, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteStartElement( writer, NULL, &str_t, &str_ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsFlushWriter( writer, 0, NULL, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
for (i = 0; i < ARRAY_SIZE(stream_tests); i++)
{
stream.writeCallbackState = &i;
hr = WsSetOutput( writer, &text.encoding, &stream.output, NULL, 0, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteStartElement( writer, NULL, &str_t, &str_ns, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
hr = WsFlushWriter( writer, stream_tests[i].min_size, NULL, NULL );
- ok( hr == S_OK, "%u: got %08x\n", i, hr );
+ ok( hr == S_OK, "%lu: got %#lx\n", i, hr );
}
WsFreeWriter( writer );
@@ -4807,7 +4807,7 @@ static void test_description_type(void)
} test;
hr = WsCreateWriter( NULL, 0, &writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
memset( &f, 0, sizeof(f) );
f.mapping = WS_TYPE_ATTRIBUTE_FIELD_MAPPING;
@@ -4835,14 +4835,14 @@ static void test_description_type(void)
hr = set_output( writer );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
hr = WsWriteEndElement( writer, NULL );
- ok( hr == S_OK, "got %08x\n", hr );
+ ok( hr == S_OK, "got %#lx\n", hr );
check_output( writer, "<t val=\"-1\"/>", __LINE__ );
WsFreeWriter( writer );
--
2.30.2
More information about the wine-devel
mailing list