schema.c File Reference

#include <stdio.h>
#include <assert.h>
#include "initguid.h"
#include "windows.h"
#include "ole2.h"
#include "msxml2.h"
#include "msxml2did.h"
#include "dispex.h"
#include "cguid.h"
#include "wine/test.h"

Include dependency graph for schema.c:

Go to the source code of this file.

Classes
struct	xdr_datatypes

Macros
#define	COBJMACROS
#define	_expect64(expr, str, base, TYPE, CONV)
#define	expect_int64(expr, x, base)   _expect64(expr, #x, base, LONG64, strtoll)
#define	expect_uint64(expr, x, base)   _expect64(expr, #x, base, ULONG64, strtoull)
#define	_create(cls)   cls, #cls
#define	create_document(iid)   _create_object(&_create(CLSID_DOMDocument), iid, __LINE__)
#define	create_document_version(v, iid)   _create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)
#define	create_cache(iid)   _create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)
#define	create_cache_version(v, iid)   _create_object(&_create(CLSID_XMLSchemaCache ## v), iid, __LINE__)

Functions
static ULONG	get_refcount (void *iface)
static BSTR	_bstr_ (const WCHAR *str)
static void	free_bstrs (void)
static VARIANT	_variantdoc_ (void *doc)
static void *	_create_object (const GUID *clsid, const char *name, const IID *iid, int line)
static void	test_schema_refs (void)
static void	test_collection_refs (void)
static void	test_length (void)
static void	test_collection_content (void)
static void	test_XDR_schemas (void)
static void	test_XDR_datatypes (void)
static void	test_obj_dispex (IUnknown *obj)
static void	test_dispex (void)
	START_TEST (schema)

Variables
static const WCHAR	xdr_schema1_uri [] = L"x-schema:test1.xdr"
static const WCHAR	xdr_schema1_xml []
static const WCHAR	xdr_schema2_uri [] = L"x-schema:test2.xdr"
static const WCHAR	xdr_schema2_xml []
static const WCHAR	xdr_schema3_uri [] = L"x-schema:test3.xdr"
static const WCHAR	xdr_schema3_xml []
static const WCHAR	xsd_schema1_uri [] = L"x-schema:test1.xsd"
static const WCHAR	szDatatypeXDR []
static const WCHAR	szDatatypeXML []
static const WCHAR	szOpenSeqXDR []
static const WCHAR	szOpenSeqXML1 [] = L"<test><x/><x/><y/><z/><z/></test>"
static const WCHAR	szOpenSeqXML2 [] = L"<test><x/><x/><y/><z/><z/><w/></test>"
static const WCHAR	szOpenSeqXML3 [] = L"<test><w/><x/><x/><y/><z/><z/></test>"
static const WCHAR	szOpenSeqXML4 [] = L"<test><x/><x/><y/><z/><z/><v/></test>"
static BSTR	alloced_bstrs [256]
static int	alloced_bstrs_count
static const xdr_datatypes	xdr_datatypes_data []

Macro Definition Documentation

_create

#define _create

(

cls

)

cls, #cls

Definition at line 414 of file schema.c.

_expect64

#define _expect64	(		expr,
			str,
			base,
			TYPE,
			CONV
	)

Value:

    { \
    TYPE v1 = expr; \
    TYPE v2 = CONV(str, NULL, base); \
    ok(v1 == v2, #expr "returned %s, expected %s\n", \
                  wine_dbgstr_longlong(v1), wine_dbgstr_longlong(v2)); \
}

Definition at line 366 of file schema.c.

COBJMACROS

#define COBJMACROS

Definition at line 24 of file schema.c.

create_cache

#define create_cache

(

iid

)

_create_object(&_create(CLSID_XMLSchemaCache), iid, __LINE__)

Definition at line 420 of file schema.c.

create_cache_version

#define create_cache_version	(		v,
			iid
	)		_create_object(&_create(CLSID_XMLSchemaCache ## v), iid, __LINE__)

Definition at line 422 of file schema.c.

create_document

#define create_document

(

iid

)

_create_object(&_create(CLSID_DOMDocument), iid, __LINE__)

Definition at line 416 of file schema.c.

create_document_version

#define create_document_version	(		v,
			iid
	)		_create_object(&_create(CLSID_DOMDocument ## v), iid, __LINE__)

Definition at line 418 of file schema.c.

expect_int64

#define expect_int64	(		expr,
			x,
			base
	)		_expect64(expr, #x, base, LONG64, strtoll)

Definition at line 373 of file schema.c.

expect_uint64

#define expect_uint64	(		expr,
			x,
			base
	)		_expect64(expr, #x, base, ULONG64, strtoull)

Definition at line 374 of file schema.c.

Function Documentation

_bstr_()

static BSTR _bstr_ ( const WCHAR *  str )

static

Definition at line 379 of file schema.c.

{
    assert(alloced_bstrs_count < ARRAY_SIZE(alloced_bstrs));
    alloced_bstrs[alloced_bstrs_count] = SysAllocString(str);
    return alloced_bstrs[alloced_bstrs_count++];
}

Referenced by test_collection_content(), test_collection_refs(), test_length(), test_XDR_datatypes(), and test_XDR_schemas().

_create_object()

static void * _create_object ( const GUID *  clsid, const char *  name, const IID *  iid, int  line  )

static

Definition at line 402 of file schema.c.

{
    void *obj = NULL;
    HRESULT hr;
 
    hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, &obj);
    if (hr != S_OK)
        win_skip_(__FILE__,line)("failed to create %s instance: hr %#lx.\n", name, hr);
 
    return obj;
}

_variantdoc_()

static VARIANT _variantdoc_ ( void *  doc )

static

Definition at line 394 of file schema.c.

{
    VARIANT v;
    V_VT(&v) = VT_DISPATCH;
    V_DISPATCH(&v) = (IDispatch*)doc;
    return v;
}

Referenced by test_collection_content(), test_collection_refs(), test_length(), and test_schema_refs().

free_bstrs()

static void free_bstrs ( void  )

static

Definition at line 386 of file schema.c.

{
    int i;
    for (i = 0; i < alloced_bstrs_count; i++)
        SysFreeString(alloced_bstrs[i]);
    alloced_bstrs_count = 0;
}

Referenced by test_collection_content(), test_collection_refs(), test_length(), test_XDR_datatypes(), and test_XDR_schemas().

get_refcount()

static ULONG get_refcount ( void *  iface )

static

Definition at line 360 of file schema.c.

{
    IUnknown_AddRef((IUnknown *)iface);
    return IUnknown_Release((IUnknown *)iface);
}

Referenced by test_collection_refs(), and test_schema_refs().

START_TEST()

START_TEST

(

schema

)

Definition at line 1553 of file schema.c.

{
    HRESULT r;
 
    r = CoInitialize( NULL );
    ok( r == S_OK, "failed to init com\n");
 
    test_schema_refs();
    test_collection_refs();
    test_length();
    test_collection_content();
    test_XDR_schemas();
    test_XDR_datatypes();
    test_dispex();
 
    CoUninitialize();
}

test_collection_content()

static void test_collection_content ( void  )

static

Definition at line 938 of file schema.c.

{
    IXMLDOMDocument2 *schema1, *schema2, *schema3;
    BSTR content[5] = {NULL, NULL, NULL, NULL, NULL};
    IXMLDOMSchemaCollection *cache1;
    VARIANT_BOOL b;
    LONG length;
    HRESULT hr;
    BSTR bstr;
    int i, j;
 
    schema1 = create_document_version(30, &IID_IXMLDOMDocument2);
    schema2 = create_document_version(30, &IID_IXMLDOMDocument2);
    schema3 = create_document_version(30, &IID_IXMLDOMDocument2);
 
    cache1 = create_cache_version(30, &IID_IXMLDOMSchemaCollection);
 
    if (!schema1 || !schema2 || !schema3 || !cache1)
    {
        if (schema1) IXMLDOMDocument2_Release(schema1);
        if (schema2) IXMLDOMDocument2_Release(schema2);
        if (schema3) IXMLDOMDocument2_Release(schema3);
 
        if (cache1) IXMLDOMSchemaCollection_Release(cache1);
 
        return;
    }
 
    hr = IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML\n");
 
    hr = IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML\n");
 
    hr = IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML\n");
 
    hr = IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema1_uri), _variantdoc_(schema1));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema2_uri), _variantdoc_(schema2));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema3_uri), _variantdoc_(schema3));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    length = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache1, &length);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(length == 3, "Unexpected length %ld.\n", length);
 
    IXMLDOMDocument2_Release(schema1);
    IXMLDOMDocument2_Release(schema2);
    IXMLDOMDocument2_Release(schema3);
 
    bstr = (void*)0xdeadbeef;
    /* error if index is out of range */
    hr = IXMLDOMSchemaCollection_get_namespaceURI(cache1, 3, &bstr);
    ok(hr == E_FAIL, "Unexpected hr %#lx.\n", hr);
    ok(bstr == (void*)0xdeadbeef, "got %p\n", bstr);
    /* error if return pointer is NULL */
    hr = IXMLDOMSchemaCollection_get_namespaceURI(cache1, 0, NULL);
    ok(hr == E_POINTER, "Unexpected hr %#lx.\n", hr);
    /* pointer is checked first */
    hr = IXMLDOMSchemaCollection_get_namespaceURI(cache1, 3, NULL);
    ok(hr == E_POINTER, "Unexpected hr %#lx.\n", hr);
 
    schema1 = NULL;
    /* no error if ns uri does not exist */
    hr = IXMLDOMSchemaCollection_get(cache1, _bstr_(xsd_schema1_uri), (IXMLDOMNode**)&schema1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!schema1, "expected NULL\n");
    /* a NULL bstr corresponds to no-uri ns */
    hr = IXMLDOMSchemaCollection_get(cache1, NULL, (IXMLDOMNode**)&schema1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(!schema1, "expected NULL\n");
    /* error if return pointer is NULL */
    hr = IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), NULL);
    ok(hr == E_POINTER, "Unexpected hr %#lx.\n", hr);
 
    for (i = 0; i < 3; ++i)
    {
        bstr = NULL;
        hr = IXMLDOMSchemaCollection_get_namespaceURI(cache1, i, &bstr);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
        ok(bstr != NULL && *bstr, "expected non-empty string\n");
        content[i] = bstr;
 
#ifdef __REACTOS__
        if (bstr == NULL) continue;
#endif
        for (j = 0; j < i; ++j)
            ok(wcscmp(content[j], bstr), "got duplicate entry\n");
    }
 
    for (i = 0; i < 3; ++i)
    {
        SysFreeString(content[i]);
        content[i] = NULL;
    }
 
    IXMLDOMSchemaCollection_Release(cache1);
    free_bstrs();
}

Referenced by START_TEST().

test_collection_refs()

static void test_collection_refs ( void  )

static

Definition at line 633 of file schema.c.

{
    IXMLDOMDocument2 *schema1, *schema2, *schema3;
    IXMLDOMSchemaCollection *cache1, *cache2, *cache3;
    LONG refcount, length;
    VARIANT_BOOL b;
    HRESULT hr;
 
    schema1 = create_document(&IID_IXMLDOMDocument2);
    ok(schema1 != NULL, "Failed to create a document.\n");
 
    cache1 = create_cache(&IID_IXMLDOMSchemaCollection);
    ok(cache1 != NULL, "Failed to create schema collection.\n");
 
    if (!schema1 || !cache1)
    {
        if (schema1)
            IXMLDOMDocument2_Release(schema1);
        if (cache1)
            IXMLDOMSchemaCollection_Release(cache1);
        return;
    }
 
    schema2 = create_document(&IID_IXMLDOMDocument2);
    schema3 = create_document(&IID_IXMLDOMDocument2);
 
    cache2 = create_cache(&IID_IXMLDOMSchemaCollection);
    cache3 = create_cache(&IID_IXMLDOMSchemaCollection);
 
    hr = IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML\n");
 
    hr = IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML\n");
 
    hr = IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML\n");
 
    hr = IXMLDOMSchemaCollection_add(cache1, _bstr_(xdr_schema1_uri), _variantdoc_(schema1));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IXMLDOMSchemaCollection_add(cache2, _bstr_(xdr_schema2_uri), _variantdoc_(schema2));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IXMLDOMSchemaCollection_add(cache3, _bstr_(xdr_schema3_uri), _variantdoc_(schema3));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    refcount = IXMLDOMDocument2_Release(schema1);
    ok(!refcount, "Unexpected refcount %ld.\n", refcount);
    refcount = IXMLDOMDocument2_Release(schema2);
    ok(!refcount, "Unexpected refcount %ld.\n", refcount);
    refcount = IXMLDOMDocument2_Release(schema3);
    ok(!refcount, "Unexpected refcount %ld.\n", refcount);
    schema1 = NULL;
    schema2 = NULL;
    schema3 = NULL;
 
    /* releasing the original doc does not affect the schema cache */
    hr = IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), (IXMLDOMNode**)&schema1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IXMLDOMSchemaCollection_get(cache2, _bstr_(xdr_schema2_uri), (IXMLDOMNode**)&schema2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IXMLDOMSchemaCollection_get(cache3, _bstr_(xdr_schema3_uri), (IXMLDOMNode**)&schema3);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    /* we get a read-only domdoc interface, created just for us */
    if (schema1)
    {
        refcount = get_refcount(schema1);
        ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
    }
 
    if (schema2)
    {
        refcount = get_refcount(schema2);
        ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
    }
 
    if (schema3)
    {
        refcount = get_refcount(schema3);
        ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
    }
 
    hr = IXMLDOMSchemaCollection_addCollection(cache1, NULL);
    ok(hr == E_POINTER, "Unexpected hr %#lx.\n", hr);
    hr = IXMLDOMSchemaCollection_addCollection(cache2, cache1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IXMLDOMSchemaCollection_addCollection(cache3, cache2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    length = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache1, &length);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(length == 1, "Unexpected length %ld.\n", length);
 
    length = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache2, &length);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(length == 2, "Unexpected length %ld.\n", length);
 
    length = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache3, &length);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(length == 3, "Unexpected length %ld.\n", length);
 
    /* merging collections does not affect the ref count */
    refcount = get_refcount(cache1);
    ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
    refcount = get_refcount(cache2);
    ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
    refcount = get_refcount(cache3);
    ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
 
    /* nor does it affect the domdoc instances */
    if (schema1)
    {
        refcount = IXMLDOMDocument2_Release(schema1);
        ok(!refcount, "Unexpected refcount %ld.\n", refcount);
    }
 
    if (schema2)
    {
        refcount = IXMLDOMDocument2_Release(schema2);
        ok(!refcount, "Unexpected refcount %ld.\n", refcount);
    }
 
    if (schema3)
    {
        refcount = IXMLDOMDocument2_Release(schema3);
        ok(!refcount, "Unexpected refcount %ld.\n", refcount);
    }
 
    schema1 = NULL;
    schema2 = NULL;
    schema3 = NULL;
 
    /* releasing the domdoc instances doesn't change the cache */
    hr = IXMLDOMSchemaCollection_get(cache1, _bstr_(xdr_schema1_uri), (IXMLDOMNode**)&schema1);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IXMLDOMSchemaCollection_get(cache2, _bstr_(xdr_schema2_uri), (IXMLDOMNode**)&schema2);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IXMLDOMSchemaCollection_get(cache3, _bstr_(xdr_schema3_uri), (IXMLDOMNode**)&schema3);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    /* we can just get them again */
    if (schema1)
    {
        refcount = get_refcount(schema1);
        ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
    }
 
    if (schema2)
    {
        refcount = get_refcount(schema2);
        ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
    }
 
    if (schema3)
    {
        refcount = get_refcount(schema3);
        ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
    }
 
    /* releasing the caches does not affect the domdoc instances */
    refcount = IXMLDOMSchemaCollection_Release(cache1);
    ok(!refcount, "Unexpected refcount %ld.\n", refcount);
    refcount = IXMLDOMSchemaCollection_Release(cache2);
    ok(!refcount, "Unexpected refcount %ld.\n", refcount);
    refcount = IXMLDOMSchemaCollection_Release(cache3);
    ok(!refcount, "Unexpected refcount %ld.\n", refcount);
 
    /* they're just for us */
    if (schema1)
    {
        refcount = IXMLDOMDocument2_Release(schema1);
        ok(!refcount, "Unexpected refcount %ld.\n", refcount);
    }
    if (schema2)
    {
        refcount = IXMLDOMDocument2_Release(schema2);
        ok(!refcount, "Unexpected refcount %ld.\n", refcount);
    }
    if (schema3)
    {
        refcount = IXMLDOMDocument2_Release(schema3);
        ok(!refcount, "Unexpected refcount %ld.\n", refcount);
    }
 
    free_bstrs();
}

Referenced by START_TEST().

test_dispex()

static void test_dispex ( void  )

static

Definition at line 1515 of file schema.c.

{
    IXMLDOMSchemaCollection *cache;
    IDispatchEx *dispex;
    IUnknown *unk;
    HRESULT hr;
    DISPPARAMS dispparams;
    VARIANT arg, ret;
 
    cache = create_cache(&IID_IXMLDOMSchemaCollection);
    if (!cache) return;
 
    hr = IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IUnknown, (void**)&unk);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    test_obj_dispex(unk);
    IUnknown_Release(unk);
 
    hr = IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatchEx, (void**)&dispex);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    V_VT(&arg) = VT_I4;
    V_I4(&arg) = 0;
    dispparams.cArgs = 1;
    dispparams.cNamedArgs = 0;
    dispparams.rgdispidNamedArgs = NULL;
    dispparams.rgvarg = &arg;
 
    V_VT(&ret) = VT_EMPTY;
    V_DISPATCH(&ret) = (void*)0x1;
    hr = IDispatchEx_Invoke(dispex, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &ret, NULL, NULL);
    ok(hr == DISP_E_MEMBERNOTFOUND, "Unexpected hr %#lx.\n", hr);
    ok(V_VT(&ret) == VT_EMPTY, "got %d\n", V_VT(&ret));
    ok(V_DISPATCH(&ret) == (void*)0x1, "got %p\n", V_DISPATCH(&ret));
 
    IDispatchEx_Release(dispex);
    IXMLDOMSchemaCollection_Release(cache);
}

Referenced by START_TEST().

test_length()

static void test_length ( void  )

static

Definition at line 826 of file schema.c.

{
    IXMLDOMDocument2 *schema1, *schema2, *schema3;
    IXMLDOMSchemaCollection *cache;
    VARIANT_BOOL b;
    HRESULT hr;
    VARIANT v;
    LONG length;
 
    schema1 = create_document(&IID_IXMLDOMDocument2);
    schema2 = create_document(&IID_IXMLDOMDocument2);
    schema3 = create_document(&IID_IXMLDOMDocument2);
 
    cache = create_cache(&IID_IXMLDOMSchemaCollection);
 
    if (!schema1 || !schema2 || !schema3 || !cache)
    {
        if (schema1) IXMLDOMDocument2_Release(schema1);
        if (schema2) IXMLDOMDocument2_Release(schema2);
        if (schema3) IXMLDOMDocument2_Release(schema3);
 
        if (cache) IXMLDOMSchemaCollection_Release(cache);
 
        return;
    }
 
    VariantInit(&v);
 
    hr = IXMLDOMDocument2_loadXML(schema1, _bstr_(xdr_schema1_xml), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML\n");
 
    hr = IXMLDOMDocument2_loadXML(schema2, _bstr_(xdr_schema2_xml), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML\n");
 
    hr = IXMLDOMDocument2_loadXML(schema3, _bstr_(xdr_schema3_xml), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML\n");
 
    hr = IXMLDOMSchemaCollection_get_length(cache, NULL);
    ok(hr == E_POINTER, "Unexpected hr %#lx.\n", hr);
 
    /* MSDN lies; removing a nonexistent entry produces no error */
    hr = IXMLDOMSchemaCollection_remove(cache, NULL);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    hr = IXMLDOMSchemaCollection_remove(cache, _bstr_(xdr_schema1_uri));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    length = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache, &length);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(length == 0, "Unexpected length %ld.\n", length);
 
    hr = IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema1_uri), _variantdoc_(schema1));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    length = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache, &length);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(length == 1, "Unexpected length %ld.\n", length);
 
    hr = IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema2_uri), _variantdoc_(schema2));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    length = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache, &length);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(length == 2, "Unexpected length %ld.\n", length);
 
    hr = IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema3_uri), _variantdoc_(schema3));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    length = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache, &length);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(length == 3, "Unexpected length %ld.\n", length);
 
    /* adding with VT_NULL is the same as removing */
    V_VT(&v) = VT_NULL;
    hr = IXMLDOMSchemaCollection_add(cache, _bstr_(xdr_schema1_uri), v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    length = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache, &length);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(length == 2, "Unexpected length %ld.\n", length);
 
    hr = IXMLDOMSchemaCollection_remove(cache, _bstr_(xdr_schema2_uri));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    length = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache, &length);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(length == 1, "Unexpected length %ld.\n", length);
 
    hr = IXMLDOMSchemaCollection_remove(cache, _bstr_(xdr_schema3_uri));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    length = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache, &length);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(length == 0, "Unexpected length %ld.\n", length);
 
    IXMLDOMDocument2_Release(schema1);
    IXMLDOMDocument2_Release(schema2);
    IXMLDOMDocument2_Release(schema3);
    IXMLDOMSchemaCollection_Release(cache);
 
    free_bstrs();
}

Referenced by START_TEST().

test_obj_dispex()

static void test_obj_dispex ( IUnknown *  obj )

static

Definition at line 1463 of file schema.c.

{
    DISPID dispid = DISPID_SAX_XMLREADER_GETFEATURE;
    IDispatchEx *dispex;
    IUnknown *unk;
    DWORD props;
    UINT ticnt;
    HRESULT hr;
    BSTR name;
 
    hr = IUnknown_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    if (FAILED(hr)) return;
 
    ticnt = 0;
    hr = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(ticnt == 1, "ticnt=%u\n", ticnt);
 
    name = SysAllocString(L"*");
    hr = IDispatchEx_DeleteMemberByName(dispex, name, fdexNameCaseSensitive);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
    SysFreeString(name);
 
    hr = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
 
    props = 0;
    hr = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &props);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
    ok(props == 0, "expected 0 got %ld\n", props);
 
    hr = IDispatchEx_GetMemberName(dispex, dispid, &name);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
    if (SUCCEEDED(hr)) SysFreeString(name);
 
    hr = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_SCHEMACOLLECTION_ADD, &dispid);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
 
    unk = (IUnknown*)0xdeadbeef;
    hr = IDispatchEx_GetNameSpaceParent(dispex, &unk);
    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
    ok(unk == (IUnknown*)0xdeadbeef, "got %p\n", unk);
 
    name = SysAllocString(L"testprop");
    hr = IDispatchEx_GetDispID(dispex, name, fdexNameEnsure, &dispid);
    ok(hr == DISP_E_UNKNOWNNAME, "Unexpected hr %#lx.\n", hr);
    SysFreeString(name);
 
    IDispatchEx_Release(dispex);
}

Referenced by test_dispex().

test_schema_refs()

static void test_schema_refs ( void  )

static

Definition at line 424 of file schema.c.

{
    static const WCHAR xdr_schema_xml[] =
        L"<Schema xmlns=\"urn:schemas-microsoft-com:xml-data\"\nxmlns:dt=\"urn:schemas-microsoft-com:datatypes\">\n</Schema>\n";
    IXMLDOMDocument2 *doc;
    IXMLDOMNode *node;
    IXMLDOMSchemaCollection *cache;
    LONG len, refcount;
    VARIANT v;
    VARIANT_BOOL b;
    BSTR str;
    HRESULT hr;
 
    doc = create_document(&IID_IXMLDOMDocument2);
    if (!doc)
        return;
 
    cache = create_cache(&IID_IXMLDOMSchemaCollection);
    if(!cache)
    {
        IXMLDOMDocument2_Release(doc);
        return;
    }
 
    VariantInit(&v);
    str = SysAllocString(xdr_schema_xml);
    hr = IXMLDOMDocument2_loadXML(doc, str, &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "b %04x\n", b);
    SysFreeString(str);
 
    node = (void*)0xdeadbeef;
    hr = IXMLDOMSchemaCollection_get(cache, NULL, &node);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(node == NULL, "%p\n", node);
 
    /* NULL uri pointer, still adds a document */
    hr = IXMLDOMSchemaCollection_add(cache, NULL, _variantdoc_(doc));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    len = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(len == 1, "Unexpected length %ld.\n", len);
    /* read back - empty valid BSTR */
    str = NULL;
    hr = IXMLDOMSchemaCollection_get_namespaceURI(cache, 0, &str);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(str && *str == 0, "got %p\n", str);
    SysFreeString(str);
 
    node = NULL;
    hr = IXMLDOMSchemaCollection_get(cache, NULL, &node);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(node != NULL, "%p\n", node);
#ifdef __REACTOS__
    if (node != NULL)
#endif
    IXMLDOMNode_Release(node);
 
    node = NULL;
    str = SysAllocString(L"");
    hr = IXMLDOMSchemaCollection_get(cache, str, &node);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(node != NULL, "%p\n", node);
#ifdef __REACTOS__
    if (node != NULL)
#endif
    IXMLDOMNode_Release(node);
    SysFreeString(str);
 
    /* remove with NULL uri */
    hr = IXMLDOMSchemaCollection_remove(cache, NULL);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    len = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(len == 0, "Unexpected length %ld.\n", len);
 
    /* same, but with VT_UNKNOWN type */
    V_VT(&v) = VT_UNKNOWN;
    V_UNKNOWN(&v) = (IUnknown*)doc;
    hr = IXMLDOMSchemaCollection_add(cache, NULL, v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    len = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(len == 1, "Unexpected length %ld.\n", len);
 
    hr = IXMLDOMSchemaCollection_remove(cache, NULL);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    len = -1;
    hr = IXMLDOMSchemaCollection_get_length(cache, &len);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(len == 0, "Unexpected length %ld.\n", len);
 
    str = SysAllocString(L"x-schema:test.xml");
    hr = IXMLDOMSchemaCollection_add(cache, str, _variantdoc_(doc));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
    /* IXMLDOMSchemaCollection_add doesn't add a ref on doc */
    refcount = get_refcount(doc);
    ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
 
    SysFreeString(str);
 
    V_VT(&v) = VT_INT;
    hr = IXMLDOMDocument2_get_schemas(doc, &v);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
    ok(V_VT(&v) == VT_NULL, "vt %x\n", V_VT(&v));
 
    refcount = IXMLDOMSchemaCollection_AddRef(cache);
    ok(refcount == 2, "Unexpected refcount %ld.\n", refcount);
    V_VT(&v) = VT_DISPATCH;
    V_DISPATCH(&v) = (IDispatch*)cache;
 
    /* check that putref_schemas takes a ref */
    hr = IXMLDOMDocument2_putref_schemas(doc, v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    refcount = get_refcount(cache);
    ok(refcount == 3, "Unexpected refcount %ld.\n", refcount);
 
    VariantClear(&v); /* refs now 2 */
 
    V_VT(&v) = VT_INT;
    /* check that get_schemas adds a ref */
    hr = IXMLDOMDocument2_get_schemas(doc, &v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(V_VT(&v) == VT_DISPATCH, "vt %x\n", V_VT(&v));
    refcount = get_refcount(cache);
    ok(refcount == 3, "Unexpected refcount %ld.\n", refcount);
 
    /* get_schemas doesn't release a ref if passed VT_DISPATCH - ie it doesn't call VariantClear() */
    hr = IXMLDOMDocument2_get_schemas(doc, &v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(V_VT(&v) == VT_DISPATCH, "vt %x\n", V_VT(&v));
    refcount = get_refcount(cache);
    ok(refcount == 4, "Unexpected refcount %ld.\n", refcount);
 
    /* release the two refs returned by get_schemas */
    refcount = IXMLDOMSchemaCollection_Release(cache);
    ok(refcount == 3, "Unexpected refcount %ld.\n", refcount);
    refcount = IXMLDOMSchemaCollection_Release(cache);
    ok(refcount == 2, "Unexpected refcount %ld.\n", refcount);
 
    /* check that taking another ref on the document doesn't change the schema's ref count */
    refcount = IXMLDOMDocument2_AddRef(doc);
    ok(refcount == 2, "Unexpected refcount %ld.\n", refcount);
    refcount = get_refcount(cache);
    ok(refcount == 2, "Unexpected refcount %ld.\n", refcount);
    refcount = IXMLDOMDocument2_Release(doc);
    ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
 
    /* call putref_schema with some odd variants */
    V_VT(&v) = VT_INT;
    hr = IXMLDOMDocument2_putref_schemas(doc, v);
    ok(hr == E_FAIL, "Unexpected hr %#lx.\n", hr);
    refcount = get_refcount(cache);
    ok(refcount == 2, "Unexpected refcount %ld.\n", refcount);
 
    /* calling with VT_EMPTY releases the schema */
    V_VT(&v) = VT_EMPTY;
    hr = IXMLDOMDocument2_putref_schemas(doc, v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    refcount = get_refcount(cache);
    ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
 
    /* try setting with VT_UNKNOWN */
    refcount = IXMLDOMSchemaCollection_AddRef(cache);
    ok(refcount == 2, "Unexpected refcount %ld.\n", refcount);
    V_VT(&v) = VT_UNKNOWN;
    V_UNKNOWN(&v) = (IUnknown*)cache;
    hr = IXMLDOMDocument2_putref_schemas(doc, v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    refcount = get_refcount(cache);
    ok(refcount == 3, "Unexpected refcount %ld.\n", refcount);
 
    VariantClear(&v); /* refs now 2 */
 
    /* calling with VT_NULL releases the schema */
    V_VT(&v) = VT_NULL;
    hr = IXMLDOMDocument2_putref_schemas(doc, v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    refcount = get_refcount(cache);
    ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
 
    /* refs now 1 */
    /* set again */
    refcount = IXMLDOMSchemaCollection_AddRef(cache);
    ok(refcount == 2, "Unexpected refcount %ld.\n", refcount);
    V_VT(&v) = VT_UNKNOWN;
    V_UNKNOWN(&v) = (IUnknown*)cache;
    hr = IXMLDOMDocument2_putref_schemas(doc, v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    refcount = get_refcount(cache);
    ok(refcount == 3, "Unexpected refcount %ld.\n", refcount);
 
    VariantClear(&v); /* refs now 2 */
 
    /* release the final ref on the doc which should release its ref on the schema */
    refcount = IXMLDOMDocument2_Release(doc);
    ok(!refcount, "Unexpected refcount %ld.\n", refcount);
 
    refcount = get_refcount(cache);
    ok(refcount == 1, "Unexpected refcount %ld.\n", refcount);
    refcount = IXMLDOMSchemaCollection_Release(cache);
    ok(!refcount, "Unexpected refcount %ld.\n", refcount);
}

Referenced by START_TEST().

test_XDR_datatypes()

static void test_XDR_datatypes ( void  )

static

Definition at line 1244 of file schema.c.

{
    IXMLDOMDocument2 *doc, *schema, *doc2;
    IXMLDOMSchemaCollection* cache;
    const xdr_datatypes *ptr;
    IXMLDOMParseError* err;
    VARIANT_BOOL b;
    HRESULT hr;
    VARIANT v;
    BSTR bstr;
    LONG l;
 
    VariantInit(&v);
 
    doc = create_document(&IID_IXMLDOMDocument2);
    doc2 = create_document(&IID_IXMLDOMDocument2);
    schema = create_document(&IID_IXMLDOMDocument2);
    cache = create_cache(&IID_IXMLDOMSchemaCollection);
 
    if (!doc || !doc2 || !schema || !cache)
    {
        if (doc)    IXMLDOMDocument2_Release(doc);
        if (doc2)   IXMLDOMDocument2_Release(doc2);
        if (schema) IXMLDOMDocument2_Release(schema);
        if (cache)  IXMLDOMSchemaCollection_Release(cache);
        return;
    }
 
    hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szDatatypeXML), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML string\n");
 
    hr = IXMLDOMDocument2_loadXML(doc2, _bstr_(szDatatypeXML), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML string\n");
 
    hr = IXMLDOMDocument2_loadXML(schema, _bstr_(szDatatypeXDR), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML string\n");
 
    err = NULL;
    hr = IXMLDOMDocument2_validate(doc, &err);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
    ok(err != NULL, "domdoc_validate() should always set err\n");
    hr = IXMLDOMParseError_get_errorCode(err, &l);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(l == E_XML_NODTD, "Unexpected error code %#lx.\n", l);
    IXMLDOMParseError_Release(err);
 
    err = NULL;
    hr = IXMLDOMDocument2_validate(doc2, &err);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
    ok(err != NULL, "domdoc_validate() should always set err\n");
    hr = IXMLDOMParseError_get_errorCode(err, &l);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(l == E_XML_NODTD, "Unexpected error code %#lx.\n", l);
    IXMLDOMParseError_Release(err);
 
    /* now load the schema */
    V_VT(&v) = VT_DISPATCH;
    V_DISPATCH(&v) = NULL;
    hr = IXMLDOMDocument2_QueryInterface(schema, &IID_IDispatch, (void**)&V_DISPATCH(&v));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
    hr = IXMLDOMSchemaCollection_add(cache, _bstr_(L"urn:x-schema:datatype-test-xdr"), v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    VariantClear(&v);
 
    /* associate the cache to the doc */
    V_VT(&v) = VT_DISPATCH;
    V_DISPATCH(&v) = NULL;
    hr = IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
    hr = IXMLDOMDocument2_putref_schemas(doc2, v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    VariantClear(&v);
 
    /* validate the doc */
    err = NULL;
    l = 0;
    bstr = NULL;
    hr = IXMLDOMDocument2_validate(doc2, &err);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(err != NULL, "domdoc_validate() should always set err\n");
    hr = IXMLDOMParseError_get_errorCode(err, &l);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
    hr = IXMLDOMParseError_get_reason(err, &bstr);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
    ok(l == 0, "Unexpected value %lx : %s\n", l, wine_dbgstr_w(bstr));
    SysFreeString(bstr);
    IXMLDOMParseError_Release(err);
 
    ptr = xdr_datatypes_data;
    while (ptr->query)
    {
        IXMLDOMNode* node = NULL;
        VARIANT type;
 
        /* check data types without the schema */
        hr = IXMLDOMDocument2_selectSingleNode(doc, _bstr_(ptr->query), &node);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
        ok(node != NULL, "expected node\n");
 
        V_VT(&type) = VT_EMPTY;
        V_BSTR(&type) = (void*)-1;
        hr = IXMLDOMNode_get_dataType(node, &type);
        ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
        ok(V_VT(&type) == VT_NULL, "got type %i\n", V_VT(&type));
        /* when returning VT_NULL, the pointer is set to NULL */
        ok(V_BSTR(&type) == NULL, "got %p\n", V_BSTR(&type));
 
        VariantClear(&type);
        hr = IXMLDOMNode_get_nodeTypedValue(node, &type);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
        ok(V_VT(&type) == VT_BSTR, "got variant type %i\n", V_VT(&v));
        VariantClear(&type);
        IXMLDOMNode_Release(node);
 
        /* check the data with schema */
        node = NULL;
        hr = IXMLDOMDocument2_selectSingleNode(doc2, _bstr_(ptr->query), &node);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
        ok(node != NULL, "expected node\n");
 
        V_VT(&type) = VT_EMPTY;
        hr = IXMLDOMNode_get_dataType(node, &type);
        if (ptr->typename)
        {
            ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
            ok(V_VT(&type) == VT_BSTR, "got type %i\n", V_VT(&type));
            ok(!lstrcmpW(V_BSTR(&type), _bstr_(ptr->typename)), "got %s\n", wine_dbgstr_w(V_BSTR(&type)));
        }
        else
        {
            ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
            ok(V_VT(&type) == VT_NULL, "%s: got type %i\n", wine_dbgstr_w(ptr->query), V_VT(&type));
        }
        VariantClear(&type);
 
        VariantClear(&v);
        hr = IXMLDOMNode_get_nodeTypedValue(node, &v);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
        todo_wine_if(ptr->todo)
            ok(V_VT(&v) == ptr->type_schema, "%s: got variant type %i\n", wine_dbgstr_w(ptr->query), V_VT(&v));
 
        switch (ptr->type_schema)
        {
        case VT_BOOL:
            ok(V_BOOL(&v) == VARIANT_TRUE, "got %x\n", V_BOOL(&v));
            break;
        case VT_I1:
            ok(V_I1(&v) == 42, "got %i\n", V_I1(&v));
            break;
        case VT_I2:
            ok(V_I2(&v) == 420, "got %i\n", V_I2(&v));
            break;
        case VT_I4:
            if (!wcscmp(ptr->typename, L"int"))
                ok(V_I4(&v) == 42, "got %ld\n", V_I4(&v));
            else if (!wcscmp(ptr->typename, L"char"))
            todo_wine
                ok(V_I4(&v) == 'u', "got %lx\n", V_I4(&v));
            else
                ok(V_I4(&v) == -420000000, "got %ld\n", V_I4(&v));
            break;
        case VT_I8:
            expect_int64(V_I8(&v), -4200000000, 10);
            break;
        case VT_R4:
            ok(V_R4(&v) == (float)3.14159265, "got %f\n", V_R4(&v));
            break;
        case VT_R8:
            if (!wcscmp(ptr->typename, L"float"))
#ifdef __REACTOS__ // crash due to printf bug, will be fixed with import of wine's msvcrt
                ok(V_R8(&v) == 3.14159, "got 0x%llx\n", *(unsigned long long*)&V_R8(&v));
#else
                ok(V_R8(&v) == 3.14159, "got %f\n", V_R8(&v));
#endif
            else
            todo_wine
#ifdef __REACTOS__ // crash due to printf bug, will be fixed with import of wine's msvcrt
                ok(V_R8(&v) == 3.14159265358979323846, "got 0x%llx\n", *(unsigned long long*)&V_R8(&v));
#else
                ok(V_R8(&v) == 3.14159265358979323846, "got %.20f\n", V_R8(&v));
#endif
            break;
        case VT_UI1:
            ok(V_UI1(&v) == 0xFF, "got %02x\n", V_UI1(&v));
            break;
        case VT_UI2:
            ok(V_UI2(&v) == 0xFFFF, "got %04x\n", V_UI2(&v));
            break;
        case VT_UI4:
            ok(V_UI4(&v) == 0xFFFFFFFF, "got %#lx\n", V_UI4(&v));
            break;
        case VT_UI8:
            expect_uint64(V_UI8(&v), 0xFFFFFFFFFFFFFFFF, 16);
            break;
        default:
            ;
        }
 
        VariantClear(&v);
 
        IXMLDOMNode_Release(node);
 
        ptr++;
    }
 
    IXMLDOMDocument2_Release(schema);
    IXMLDOMDocument2_Release(doc);
    IXMLDOMDocument2_Release(doc2);
    IXMLDOMSchemaCollection_Release(cache);
 
    free_bstrs();
}

Referenced by START_TEST().

test_XDR_schemas()

static void test_XDR_schemas ( void  )

static

Definition at line 1044 of file schema.c.

{
    IXMLDOMDocument2 *doc, *schema;
    IXMLDOMSchemaCollection* cache;
    IXMLDOMParseError* err;
    VARIANT_BOOL b;
    HRESULT hr;
    VARIANT v;
    BSTR bstr;
 
    doc = create_document(&IID_IXMLDOMDocument2);
    schema = create_document(&IID_IXMLDOMDocument2);
    cache = create_cache(&IID_IXMLDOMSchemaCollection);
 
    if (!doc || !schema || !cache)
    {
        if (doc)    IXMLDOMDocument2_Release(doc);
        if (schema) IXMLDOMDocument2_Release(schema);
        if (cache)  IXMLDOMSchemaCollection_Release(cache);
 
        return;
    }
 
    VariantInit(&v);
 
    hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML1), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML string\n");
 
    hr = IXMLDOMDocument2_loadXML(schema, _bstr_(szOpenSeqXDR), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML string\n");
 
    /* load the schema */
    V_VT(&v) = VT_DISPATCH;
    V_DISPATCH(&v) = NULL;
    hr = IXMLDOMDocument2_QueryInterface(schema, &IID_IDispatch, (void**)&V_DISPATCH(&v));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
    hr = IXMLDOMSchemaCollection_add(cache, _bstr_(L""), v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    VariantClear(&v);
 
    /* associate the cache to the doc */
    V_VT(&v) = VT_DISPATCH;
    V_DISPATCH(&v) = NULL;
    hr = IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
    hr = IXMLDOMDocument2_putref_schemas(doc, v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    VariantClear(&v);
 
    /* validate the doc
     * only declared elements in the declared order
     * this is fine */
    err = NULL;
    bstr = NULL;
    hr = IXMLDOMDocument2_validate(doc, &err);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(err != NULL, "domdoc_validate() should always set err\n");
    hr = IXMLDOMParseError_get_reason(err, &bstr);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
    ok(IXMLDOMParseError_get_reason(err, &bstr) == S_FALSE, "got error: %s\n", wine_dbgstr_w(bstr));
    SysFreeString(bstr);
    IXMLDOMParseError_Release(err);
 
    /* load the next doc */
    IXMLDOMDocument2_Release(doc);
    doc = create_document(&IID_IXMLDOMDocument2);
    hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML2), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML string\n");
 
    /* associate the cache to the doc */
    V_VT(&v) = VT_DISPATCH;
    V_DISPATCH(&v) = NULL;
    hr = IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
    hr = IXMLDOMDocument2_putref_schemas(doc, v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    VariantClear(&v);
 
    /* validate the doc
     * declared elements in the declared order, with an extra declared element at the end
     * this is fine */
    err = NULL;
    bstr = NULL;
    hr = IXMLDOMDocument2_validate(doc, &err);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(err != NULL, "domdoc_validate() should always set err\n");
    hr = IXMLDOMParseError_get_reason(err, &bstr);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
    ok(IXMLDOMParseError_get_reason(err, &bstr) == S_FALSE, "got error: %s\n", wine_dbgstr_w(bstr));
    SysFreeString(bstr);
    IXMLDOMParseError_Release(err);
 
    /* load the next doc */
    IXMLDOMDocument2_Release(doc);
    doc = create_document(&IID_IXMLDOMDocument2);
    hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML3), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML string\n");
 
    /* associate the cache to the doc */
    V_VT(&v) = VT_DISPATCH;
    V_DISPATCH(&v) = NULL;
    hr = IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
    hr = IXMLDOMDocument2_putref_schemas(doc, v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    VariantClear(&v);
 
    /* validate the doc
     * fails, extra elements are only allowed at the end */
    err = NULL;
    bstr = NULL;
    hr = IXMLDOMDocument2_validate(doc, &err);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
    ok(err != NULL, "domdoc_validate() should always set err\n");
    todo_wine ok(IXMLDOMParseError_get_reason(err, &bstr) == S_OK, "got error: %s\n", wine_dbgstr_w(bstr));
    SysFreeString(bstr);
    IXMLDOMParseError_Release(err);
 
    /* load the next doc */
    IXMLDOMDocument2_Release(doc);
    doc = create_document(&IID_IXMLDOMDocument2);
    hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szOpenSeqXML4), &b);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(b == VARIANT_TRUE, "failed to load XML string\n");
 
    /* associate the cache to the doc */
    V_VT(&v) = VT_DISPATCH;
    V_DISPATCH(&v) = NULL;
    hr = IXMLDOMSchemaCollection_QueryInterface(cache, &IID_IDispatch, (void**)&V_DISPATCH(&v));
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(V_DISPATCH(&v) != NULL, "failed to get IDispatch interface\n");
    hr = IXMLDOMDocument2_putref_schemas(doc, v);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    VariantClear(&v);
 
    /* validate the doc
     * fails, undeclared elements are not allowed */
    err = NULL;
    bstr = NULL;
    hr = IXMLDOMDocument2_validate(doc, &err);
    ok(hr == S_FALSE, "Unexpected hr %#lx.\n", hr);
    ok(err != NULL, "domdoc_validate() should always set err\n");
    todo_wine ok(IXMLDOMParseError_get_reason(err, &bstr) == S_OK, "got error: %s\n", wine_dbgstr_w(bstr));
    SysFreeString(bstr);
    IXMLDOMParseError_Release(err);
 
    IXMLDOMDocument2_Release(doc);
    IXMLDOMDocument2_Release(schema);
    IXMLDOMSchemaCollection_Release(cache);
 
    free_bstrs();
}

Referenced by START_TEST().

Variable Documentation

alloced_bstrs

BSTR alloced_bstrs[256]

static

Definition at line 376 of file schema.c.

Referenced by _bstr_(), and free_bstrs().

alloced_bstrs_count

int alloced_bstrs_count

static

Definition at line 377 of file schema.c.

Referenced by _bstr_(), and free_bstrs().

szDatatypeXDR

const WCHAR szDatatypeXDR[]

static

Definition at line 89 of file schema.c.

Referenced by test_XDR_datatypes().

szDatatypeXML

const WCHAR szDatatypeXML[]

static

Definition at line 165 of file schema.c.

Referenced by test_XDR_datatypes().

szOpenSeqXDR

const WCHAR szOpenSeqXDR[]

static

Initial value:

=
L"<Schema xmlns='urn:schemas-microsoft-com:xml-data'>\n"
"   <ElementType name='w' content='empty' model='closed'/>\n"
"   <ElementType name='x' content='empty' model='closed'/>\n"
"   <ElementType name='y' content='empty' model='closed'/>\n"
"   <ElementType name='z' content='empty' model='closed'/>\n"
"   <ElementType name='test' content='eltOnly' model='open' order='seq'>\n"
"       <element type='x'/>\n"
"       <group order='seq'>\n"
"           <element type='x'/>\n"
"           <element type='y'/>\n"
"           <element type='z'/>\n"
"       </group>\n"
"       <element type='z'/>\n"
"   </ElementType>\n"
"</Schema>"

Definition at line 338 of file schema.c.

Referenced by test_XDR_schemas().

szOpenSeqXML1

const WCHAR szOpenSeqXML1[] = L"<test><x/><x/><y/><z/><z/></test>"

static

Definition at line 355 of file schema.c.

Referenced by test_XDR_schemas().

szOpenSeqXML2

const WCHAR szOpenSeqXML2[] = L"<test><x/><x/><y/><z/><z/><w/></test>"

static

Definition at line 356 of file schema.c.

Referenced by test_XDR_schemas().

szOpenSeqXML3

const WCHAR szOpenSeqXML3[] = L"<test><w/><x/><x/><y/><z/><z/></test>"

static

Definition at line 357 of file schema.c.

Referenced by test_XDR_schemas().

szOpenSeqXML4

const WCHAR szOpenSeqXML4[] = L"<test><x/><x/><y/><z/><z/><v/></test>"

static

Definition at line 358 of file schema.c.

Referenced by test_XDR_schemas().

xdr_datatypes_data

const xdr_datatypes xdr_datatypes_data[]

static

Definition at line 1212 of file schema.c.

Referenced by test_XDR_datatypes().

xdr_schema1_uri

const WCHAR xdr_schema1_uri[] = L"x-schema:test1.xdr"

static

Definition at line 37 of file schema.c.

Referenced by test_collection_content(), test_collection_refs(), and test_length().

xdr_schema1_xml

const WCHAR xdr_schema1_xml[]

static

Initial value:

=
L"<?xml version='1.0'?>"
"<Schema xmlns='urn:schemas-microsoft-com:xml-data'"
"        xmlns:dt='urn:schemas-microsoft-com:datatypes'"
"        name='test1.xdr'>"
"   <ElementType name='x' dt:type='boolean'/>"
"   <ElementType name='y'>"
"       <datatype dt:type='int'/>"
"   </ElementType>"
"   <ElementType name='z'/>"
"   <ElementType name='root' content='eltOnly' model='open' order='seq'>"
"       <element type='x'/>"
"       <element type='y'/>"
"       <element type='z'/>"
"   </ElementType>"
"</Schema>"

Definition at line 38 of file schema.c.

Referenced by test_collection_content(), test_collection_refs(), and test_length().

xdr_schema2_uri

const WCHAR xdr_schema2_uri[] = L"x-schema:test2.xdr"

static

Definition at line 55 of file schema.c.

Referenced by test_collection_content(), test_collection_refs(), and test_length().

xdr_schema2_xml

const WCHAR xdr_schema2_xml[]

static

Initial value:

=
L"<?xml version='1.0'?>"
"<Schema xmlns='urn:schemas-microsoft-com:xml-data'"
"        xmlns:dt='urn:schemas-microsoft-com:datatypes'"
"        name='test2.xdr'>"
"   <ElementType name='x' dt:type='bin.base64'/>"
"   <ElementType name='y' dt:type='uuid'/>"
"   <ElementType name='z'/>"
"   <ElementType name='root' content='eltOnly' model='closed' order='one'>"
"       <element type='x'/>"
"       <element type='y'/>"
"       <element type='z'/>"
"   </ElementType>"
"</Schema>"

Definition at line 56 of file schema.c.

Referenced by test_collection_content(), test_collection_refs(), and test_length().

xdr_schema3_uri

const WCHAR xdr_schema3_uri[] = L"x-schema:test3.xdr"

static

Definition at line 71 of file schema.c.

Referenced by test_collection_content(), test_collection_refs(), and test_length().

xdr_schema3_xml

const WCHAR xdr_schema3_xml[]

static

Initial value:

=
L"<?xml version='1.0'?>"
"<Schema xmlns='urn:schemas-microsoft-com:xml-data'"
"        xmlns:dt='urn:schemas-microsoft-com:datatypes'"
"        name='test3.xdr'>"
"   <ElementType name='root' content='textOnly' model='open'>"
"       <AttributeType name='x' dt:type='int'/>"
"       <AttributeType name='y' dt:type='enumeration' dt:values='a b c'/>"
"       <AttributeType name='z' dt:type='uuid'/>"
"       <attribute type='x'/>"
"       <attribute type='y'/>"
"       <attribute type='z'/>"
"   </ElementType>"
"</Schema>"

Definition at line 72 of file schema.c.

Referenced by test_collection_content(), test_collection_refs(), and test_length().

xsd_schema1_uri

const WCHAR xsd_schema1_uri[] = L"x-schema:test1.xsd"

static

Definition at line 87 of file schema.c.

Referenced by test_collection_content().