comctl32: Add implementation of LVS_EX_ONECLICKACTIVATE.
[wine] / dlls / msxml3 / tests / domdoc.c
1 /*
2  * XML test
3  *
4  * Copyright 2005 Mike McCormack for CodeWeavers
5  * Copyright 2007-2008 Alistair Leslie-Hughes
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22
23 #define COBJMACROS
24
25 #include "windows.h"
26 #include "ole2.h"
27 #include "xmldom.h"
28 #include "msxml2.h"
29 #include "msxml2did.h"
30 #include "dispex.h"
31 #include <stdio.h>
32 #include <assert.h>
33
34 #include "wine/test.h"
35
36 static const WCHAR szEmpty[] = { 0 };
37 static const WCHAR szIncomplete[] = {
38     '<','?','x','m','l',' ',
39     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',0
40 };
41 static const WCHAR szComplete1[] = {
42     '<','?','x','m','l',' ',
43     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
44     '<','o','p','e','n','>','<','/','o','p','e','n','>','\n',0
45 };
46 static const WCHAR szComplete2[] = {
47     '<','?','x','m','l',' ',
48     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
49     '<','o','>','<','/','o','>','\n',0
50 };
51 static const WCHAR szComplete3[] = {
52     '<','?','x','m','l',' ',
53     'v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
54     '<','a','>','<','/','a','>','\n',0
55 };
56 static const WCHAR szComplete4[] = {
57     '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\'','1','.','0','\'','?','>','\n',
58     '<','l','c',' ','d','l','=','\'','s','t','r','1','\'','>','\n',
59         '<','b','s',' ','v','r','=','\'','s','t','r','2','\'',' ','s','z','=','\'','1','2','3','4','\'','>',
60             'f','n','1','.','t','x','t','\n',
61         '<','/','b','s','>','\n',
62         '<','p','r',' ','i','d','=','\'','s','t','r','3','\'',' ','v','r','=','\'','1','.','2','.','3','\'',' ',
63                     'p','n','=','\'','w','i','n','e',' ','2','0','0','5','0','8','0','4','\'','>','\n',
64             'f','n','2','.','t','x','t','\n',
65         '<','/','p','r','>','\n',
66         '<','e','m','p','t','y','>','<','/','e','m','p','t','y','>','\n',
67         '<','f','o','>','\n',
68             '<','b','a','>','\n',
69                 'f','1','\n',
70             '<','/','b','a','>','\n',
71         '<','/','f','o','>','\n',
72     '<','/','l','c','>','\n',0
73 };
74 static const WCHAR szComplete5[] = {
75     '<','S',':','s','e','a','r','c','h',' ','x','m','l','n','s',':','D','=','"','D','A','V',':','"',' ',
76     'x','m','l','n','s',':','C','=','"','u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','o','f','f','i','c','e',':','c','l','i','p','g','a','l','l','e','r','y','"',
77     ' ','x','m','l','n','s',':','S','=','"','u','r','n',':','s','c','h','e','m','a','s','-','m','i','c','r','o','s','o','f','t','-','c','o','m',':','o','f','f','i','c','e',':','c','l','i','p','g','a','l','l','e','r','y',':','s','e','a','r','c','h','"','>',
78         '<','S',':','s','c','o','p','e','>',
79             '<','S',':','d','e','e','p','>','/','<','/','S',':','d','e','e','p','>',
80         '<','/','S',':','s','c','o','p','e','>',
81         '<','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
82             '<','C',':','t','e','x','t','o','r','p','r','o','p','e','r','t','y','/','>',
83             'c','o','m','p','u','t','e','r',
84         '<','/','S',':','c','o','n','t','e','n','t','f','r','e','e','t','e','x','t','>',
85     '<','/','S',':','s','e','a','r','c','h','>',0
86 };
87
88 static const CHAR szExampleXML[] =
89 "<?xml version='1.0' encoding='utf-8'?>\n"
90 "<root xmlns:foo='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
91 "    <elem>\n"
92 "        <a>A1 field</a>\n"
93 "        <b>B1 field</b>\n"
94 "        <c>C1 field</c>\n"
95 "        <description xmlns:foo='http://www.winehq.org' xmlns:bar='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
96 "            <html xmlns='http://www.w3.org/1999/xhtml'>\n"
97 "                This is <strong>a</strong> <i>description</i>. <bar:x/>\n"
98 "            </html>\n"
99 "        </description>\n"
100 "    </elem>\n"
101 "\n"
102 "    <elem>\n"
103 "        <a>A2 field</a>\n"
104 "        <b>B2 field</b>\n"
105 "        <c type=\"old\">C2 field</c>\n"
106 "    </elem>\n"
107 "\n"
108 "    <elem xmlns='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'>\n"
109 "        <a>A3 field</a>\n"
110 "        <b>B3 field</b>\n"
111 "        <c>C3 field</c>\n"
112 "    </elem>\n"
113 "\n"
114 "    <elem>\n"
115 "        <a>A4 field</a>\n"
116 "        <b>B4 field</b>\n"
117 "        <foo:c>C4 field</foo:c>\n"
118 "    </elem>\n"
119 "</root>\n";
120
121 static  const CHAR szTransformXML[] =
122 "<?xml version=\"1.0\"?>\n"
123 "<greeting>\n"
124 "Hello World\n"
125 "</greeting>";
126
127 static  const CHAR szTransformSSXML[] =
128 "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n"
129 "   <xsl:output method=\"html\"/>\n"
130 "   <xsl:template match=\"/\">\n"
131 "       <xsl:apply-templates select=\"greeting\"/>\n"
132 "   </xsl:template>\n"
133 "   <xsl:template match=\"greeting\">\n"
134 "       <html>\n"
135 "           <body>\n"
136 "               <h1>\n"
137 "                   <xsl:value-of select=\".\"/>\n"
138 "               </h1>\n"
139 "           </body>\n"
140 "       </html>\n"
141 "   </xsl:template>\n"
142 "</xsl:stylesheet>";
143
144 static  const CHAR szTransformOutput[] =
145 "<html><body><h1>"
146 "Hello World"
147 "</h1></body></html>";
148
149 static const CHAR szTypeValueXML[] =
150 "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
151 "<string>Wine</string>";
152
153 static const WCHAR szNonExistentFile[] = {
154     'c', ':', '\\', 'N', 'o', 'n', 'e', 'x', 'i', 's', 't', 'e', 'n', 't', '.', 'x', 'm', 'l', 0
155 };
156 static const WCHAR szDocument[] = {
157     '#', 'd', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0
158 };
159
160 static const WCHAR szOpen[] = { 'o','p','e','n',0 };
161 static WCHAR szdl[] = { 'd','l',0 };
162 static const WCHAR szvr[] = { 'v','r',0 };
163 static const WCHAR szlc[] = { 'l','c',0 };
164 static WCHAR szbs[] = { 'b','s',0 };
165 static const WCHAR szstr1[] = { 's','t','r','1',0 };
166 static const WCHAR szstr2[] = { 's','t','r','2',0 };
167 static const WCHAR szstar[] = { '*',0 };
168 static const WCHAR szfn1_txt[] = {'f','n','1','.','t','x','t',0};
169
170 static WCHAR szComment[] = {'A',' ','C','o','m','m','e','n','t',0 };
171 static WCHAR szCommentXML[] = {'<','!','-','-','A',' ','C','o','m','m','e','n','t','-','-','>',0 };
172 static WCHAR szCommentNodeText[] = {'#','c','o','m','m','e','n','t',0 };
173
174 static WCHAR szElement[] = {'E','l','e','T','e','s','t', 0 };
175 static WCHAR szElementXML[]  = {'<','E','l','e','T','e','s','t','/','>',0 };
176 static WCHAR szElementXML2[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','/','>',0 };
177 static WCHAR szElementXML3[] = {'<','E','l','e','T','e','s','t',' ','A','t','t','r','=','"','"','>',
178                                 'T','e','s','t','i','n','g','N','o','d','e','<','/','E','l','e','T','e','s','t','>',0 };
179
180 static WCHAR szAttribute[] = {'A','t','t','r',0 };
181 static WCHAR szAttributeXML[] = {'A','t','t','r','=','"','"',0 };
182
183 static WCHAR szCData[] = {'[','1',']','*','2','=','3',';',' ','&','g','e','e',' ','t','h','a','t','s',
184                           ' ','n','o','t',' ','r','i','g','h','t','!', 0};
185 static WCHAR szCDataXML[] = {'<','!','[','C','D','A','T','A','[','[','1',']','*','2','=','3',';',' ','&',
186                              'g','e','e',' ','t','h','a','t','s',' ','n','o','t',' ','r','i','g','h','t',
187                              '!',']',']','>',0};
188 static WCHAR szCDataNodeText[] = {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0 };
189 static WCHAR szDocFragmentText[] = {'#','d','o','c','u','m','e','n','t','-','f','r','a','g','m','e','n','t',0 };
190
191 static WCHAR szEntityRef[] = {'e','n','t','i','t','y','r','e','f',0 };
192 static WCHAR szEntityRefXML[] = {'&','e','n','t','i','t','y','r','e','f',';',0 };
193
194 #define expect_bstr_eq_and_free(bstr, expect) { \
195     BSTR bstrExp = alloc_str_from_narrow(expect); \
196     ok(lstrcmpW(bstr, bstrExp) == 0, "String differs\n"); \
197     SysFreeString(bstr); \
198     SysFreeString(bstrExp); \
199 }
200
201 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
202
203 #define ole_check(expr) { \
204     HRESULT r = expr; \
205     ok(r == S_OK, #expr " returned %x\n", r); \
206 }
207
208 #define ole_expect(expr, expect) { \
209     HRESULT r = expr; \
210     ok(r == (expect), #expr " returned %x, expected %x\n", r, expect); \
211 }
212
213 static BSTR alloc_str_from_narrow(const char *str)
214 {
215     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
216     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
217     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
218     return ret;
219 }
220
221 BSTR alloced_bstrs[256];
222 int alloced_bstrs_count = 0;
223
224 static BSTR _bstr_(const char *str)
225 {
226     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
227     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
228     return alloced_bstrs[alloced_bstrs_count++];
229 }
230
231 static void free_bstrs(void)
232 {
233     int i;
234     for (i = 0; i < alloced_bstrs_count; i++)
235         SysFreeString(alloced_bstrs[i]);
236     alloced_bstrs_count = 0;
237 }
238
239 static VARIANT _variantbstr_(const char *str)
240 {
241     VARIANT v;
242     V_VT(&v) = VT_BSTR;
243     V_BSTR(&v) = _bstr_(str);
244     return v;
245 }
246
247 static BOOL compareIgnoreReturns(BSTR sLeft, BSTR sRight)
248 {
249     for (;;)
250     {
251         while (*sLeft == '\r' || *sLeft == '\n') sLeft++;
252         while (*sRight == '\r' || *sRight == '\n') sRight++;
253         if (*sLeft != *sRight) return FALSE;
254         if (!*sLeft) return TRUE;
255         sLeft++;
256         sRight++;
257     }
258 }
259
260 static void get_str_for_type(DOMNodeType type, char *buf)
261 {
262     switch (type)
263     {
264         case NODE_ATTRIBUTE:
265             strcpy(buf, "A");
266             break;
267         case NODE_ELEMENT:
268             strcpy(buf, "E");
269             break;
270         case NODE_DOCUMENT:
271             strcpy(buf, "D");
272             break;
273         default:
274             wsprintfA(buf, "[%d]", type);
275     }
276 }
277
278 static int get_node_position(IXMLDOMNode *node)
279 {
280     HRESULT r;
281     int pos = 0;
282
283     IXMLDOMNode_AddRef(node);
284     do
285     {
286         IXMLDOMNode *new_node;
287
288         pos++;
289         r = IXMLDOMNode_get_previousSibling(node, &new_node);
290         ok(SUCCEEDED(r), "get_previousSibling failed\n");
291         IXMLDOMNode_Release(node);
292         node = new_node;
293     } while (r == S_OK);
294     return pos;
295 }
296
297 static void node_to_string(IXMLDOMNode *node, char *buf)
298 {
299     HRESULT r = S_OK;
300     DOMNodeType type;
301
302     if (node == NULL)
303     {
304         lstrcpyA(buf, "(null)");
305         return;
306     }
307
308     IXMLDOMNode_AddRef(node);
309     while (r == S_OK)
310     {
311         IXMLDOMNode *new_node;
312
313         ole_check(IXMLDOMNode_get_nodeType(node, &type));
314         get_str_for_type(type, buf);
315         buf+=strlen(buf);
316
317         if (type == NODE_ATTRIBUTE)
318         {
319             BSTR bstr;
320             ole_check(IXMLDOMNode_get_nodeName(node, &bstr));
321             *(buf++) = '\'';
322             wsprintfA(buf, "%ws", bstr);
323             buf += strlen(buf);
324             *(buf++) = '\'';
325             SysFreeString(bstr);
326
327             r = IXMLDOMNode_selectSingleNode(node, _bstr_(".."), &new_node);
328         }
329         else
330         {
331             int pos = get_node_position(node);
332             DOMNodeType parent_type = NODE_INVALID;
333             r = IXMLDOMNode_get_parentNode(node, &new_node);
334
335             /* currently wine doesn't create a node for the <?xml ... ?>. To be able to test query
336              * results we "fix" it */
337             if (r == S_OK)
338                 ole_check(IXMLDOMNode_get_nodeType(new_node, &parent_type));
339             if ((parent_type == NODE_DOCUMENT) && type != NODE_PROCESSING_INSTRUCTION && pos==1)
340             {
341                 todo_wine ok(FALSE, "The first child of the document node in MSXML is the <?xml ... ?> processing instruction\n");
342                 pos++;
343             }
344             wsprintf(buf, "%d", pos);
345             buf += strlen(buf);
346         }
347
348         ok(SUCCEEDED(r), "get_parentNode failed (%08x)\n", r);
349         IXMLDOMNode_Release(node);
350         node = new_node;
351         if (r == S_OK)
352             *(buf++) = '.';
353     }
354
355     *buf = 0;
356 }
357
358 static char *list_to_string(IXMLDOMNodeList *list)
359 {
360     static char buf[4096];
361     char *pos = buf;
362     long len = 0;
363     int i;
364
365     if (list == NULL)
366     {
367         lstrcpyA(buf, "(null)");
368         return buf;
369     }
370     ole_check(IXMLDOMNodeList_get_length(list, &len));
371     for (i = 0; i < len; i++)
372     {
373         IXMLDOMNode *node;
374         if (i > 0)
375             *(pos++) = ' ';
376         ole_check(IXMLDOMNodeList_nextNode(list, &node));
377         node_to_string(node, pos);
378         pos += strlen(pos);
379         IXMLDOMNode_Release(node);
380     }
381     *pos = 0;
382     return buf;
383 }
384
385 #define expect_node(node, expstr) { char str[4096]; node_to_string(node, str); ok(strcmp(str, expstr)==0, "Invalid node: %s, exptected %s\n", str, expstr); }
386 #define expect_list_and_release(list, expstr) { char *str = list_to_string(list); ok(strcmp(str, expstr)==0, "Invalid node list: %s, exptected %s\n", str, expstr); if (list) IXMLDOMNodeList_Release(list); }
387
388 static void test_domdoc( void )
389 {
390     HRESULT r;
391     IXMLDOMDocument *doc = NULL;
392     IXMLDOMParseError *error;
393     IXMLDOMElement *element = NULL;
394     IXMLDOMNode *node;
395     IXMLDOMText *nodetext = NULL;
396     IXMLDOMComment *node_comment = NULL;
397     IXMLDOMAttribute *node_attr = NULL;
398     IXMLDOMNode *nodeChild = NULL;
399     IXMLDOMProcessingInstruction *nodePI = NULL;
400     VARIANT_BOOL b;
401     VARIANT var;
402     BSTR str;
403     long code;
404     long nLength = 0;
405
406     r = CoCreateInstance( &CLSID_DOMDocument, NULL, 
407         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
408     if( r != S_OK )
409         return;
410
411     /* try some stupid things */
412     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
413     ok( r == S_FALSE, "loadXML failed\n");
414
415     b = VARIANT_TRUE;
416     r = IXMLDOMDocument_loadXML( doc, NULL, &b );
417     ok( r == S_FALSE, "loadXML failed\n");
418     ok( b == VARIANT_FALSE, "failed to load XML string\n");
419
420     /* try to load a document from a nonexistent file */
421     b = VARIANT_TRUE;
422     str = SysAllocString( szNonExistentFile );
423     VariantInit(&var);
424     V_VT(&var) = VT_BSTR;
425     V_BSTR(&var) = str;
426
427     r = IXMLDOMDocument_load( doc, var, &b);
428     ok( r == S_FALSE, "load (from file) failed\n");
429     ok( b == VARIANT_FALSE, "failed to load XML file\n");
430     SysFreeString( str );
431
432     /* try load an empty document */
433     b = VARIANT_TRUE;
434     str = SysAllocString( szEmpty );
435     r = IXMLDOMDocument_loadXML( doc, str, &b );
436     ok( r == S_FALSE, "loadXML failed\n");
437     ok( b == VARIANT_FALSE, "failed to load XML string\n");
438     SysFreeString( str );
439
440     /* check that there's no document element */
441     element = NULL;
442     r = IXMLDOMDocument_get_documentElement( doc, &element );
443     ok( r == S_FALSE, "should be no document element\n");
444
445     /* try finding a node */
446     node = NULL;
447     str = SysAllocString( szstr1 );
448     r = IXMLDOMDocument_selectSingleNode( doc, str, &node );
449     ok( r == S_FALSE, "ret %08x\n", r );
450     SysFreeString( str );
451
452     b = VARIANT_TRUE;
453     str = SysAllocString( szIncomplete );
454     r = IXMLDOMDocument_loadXML( doc, str, &b );
455     ok( r == S_FALSE, "loadXML failed\n");
456     ok( b == VARIANT_FALSE, "failed to load XML string\n");
457     SysFreeString( str );
458
459     /* check that there's no document element */
460     element = (IXMLDOMElement*)1;
461     r = IXMLDOMDocument_get_documentElement( doc, &element );
462     ok( r == S_FALSE, "should be no document element\n");
463     ok( element == NULL, "Element should be NULL\n");
464
465     /* try to load something valid */
466     b = VARIANT_FALSE;
467     str = SysAllocString( szComplete1 );
468     r = IXMLDOMDocument_loadXML( doc, str, &b );
469     ok( r == S_OK, "loadXML failed\n");
470     ok( b == VARIANT_TRUE, "failed to load XML string\n");
471     SysFreeString( str );
472
473     /* check if nodename is correct */
474     r = IXMLDOMDocument_get_nodeName( doc, NULL );
475     ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
476
477     /* content doesn't matter here */
478     str = NULL;
479     r = IXMLDOMDocument_get_nodeName( doc, &str );
480     ok ( r == S_OK, "get_nodeName wrong code\n");
481     ok ( str != NULL, "str is null\n");
482     ok( !lstrcmpW( str, szDocument ), "incorrect nodeName\n");
483     SysFreeString( str );
484
485     /* test put_text */
486     r = IXMLDOMDocument_put_text( doc, _bstr_("Should Fail") );
487     ok( r == E_FAIL, "ret %08x\n", r );
488
489     /* check that there's a document element */
490     element = NULL;
491     r = IXMLDOMDocument_get_documentElement( doc, &element );
492     ok( r == S_OK, "should be a document element\n");
493     if( element )
494     {
495         BSTR tag = NULL;
496
497         /* check if the tag is correct */
498         r = IXMLDOMElement_get_tagName( element, &tag );
499         ok( r == S_OK, "couldn't get tag name\n");
500         ok( tag != NULL, "tag was null\n");
501         ok( !lstrcmpW( tag, szOpen ), "incorrect tag name\n");
502         SysFreeString( tag );
503
504         /* figure out what happens if we try to reload the document */
505         str = SysAllocString( szComplete2 );
506         r = IXMLDOMDocument_loadXML( doc, str, &b );
507         ok( r == S_OK, "loadXML failed\n");
508         ok( b == VARIANT_TRUE, "failed to load XML string\n");
509         SysFreeString( str );
510
511         /* check if the tag is still correct */
512         tag = NULL;
513         r = IXMLDOMElement_get_tagName( element, &tag );
514         ok( r == S_OK, "couldn't get tag name\n");
515         ok( tag != NULL, "tag was null\n");
516         ok( !lstrcmpW( tag, szOpen ), "incorrect tag name\n");
517         SysFreeString( tag );
518
519         IXMLDOMElement_Release( element );
520         element = NULL;
521     }
522
523     /* as soon as we call loadXML again, the document element will disappear */
524     b = 2;
525     r = IXMLDOMDocument_loadXML( doc, NULL, NULL );
526     ok( r == S_FALSE, "loadXML failed\n");
527     ok( b == 2, "variant modified\n");
528     r = IXMLDOMDocument_get_documentElement( doc, &element );
529     ok( r == S_FALSE, "should be no document element\n");
530
531     /* try to load something else simple and valid */
532     b = VARIANT_FALSE;
533     str = SysAllocString( szComplete3 );
534     r = IXMLDOMDocument_loadXML( doc, str, &b );
535     ok( r == S_OK, "loadXML failed\n");
536     ok( b == VARIANT_TRUE, "failed to load XML string\n");
537     SysFreeString( str );
538
539     /* try something a little more complicated */
540     b = FALSE;
541     str = SysAllocString( szComplete4 );
542     r = IXMLDOMDocument_loadXML( doc, str, &b );
543     ok( r == S_OK, "loadXML failed\n");
544     ok( b == VARIANT_TRUE, "failed to load XML string\n");
545     SysFreeString( str );
546
547     r = IXMLDOMDocument_get_parseError( doc, &error );
548     ok( r == S_OK, "returns %08x\n", r );
549
550     r = IXMLDOMParseError_get_errorCode( error, &code );
551     ok( r == S_FALSE, "returns %08x\n", r );
552     ok( code == 0, "code %ld\n", code );
553     IXMLDOMParseError_Release( error );
554
555      /* test createTextNode */
556     str = SysAllocString( szOpen );
557     r = IXMLDOMDocument_createTextNode(doc, str, NULL);
558     ok( r == E_INVALIDARG, "returns %08x\n", r );
559     r = IXMLDOMDocument_createTextNode(doc, str, &nodetext);
560     ok( r == S_OK, "returns %08x\n", r );
561     SysFreeString( str );
562     if(nodetext)
563     {
564         IXMLDOMNamedNodeMap *pAttribs;
565
566         r = IXMLDOMText_QueryInterface(nodetext, &IID_IXMLDOMElement, (LPVOID*)&element);
567         ok(r == E_NOINTERFACE, "ret %08x\n", r );
568
569         /* Text Last Child Checks */
570         r = IXMLDOMText_get_lastChild(nodetext, NULL);
571         ok(r == E_INVALIDARG, "ret %08x\n", r );
572
573         nodeChild = (IXMLDOMNode*)0x1;
574         r = IXMLDOMText_get_lastChild(nodetext, &nodeChild);
575         ok(r == S_FALSE, "ret %08x\n", r );
576         ok(nodeChild == NULL, "nodeChild not NULL\n");
577
578         /* test get_attributes */
579         r = IXMLDOMText_get_attributes( nodetext, NULL );
580         ok( r == E_INVALIDARG, "get_attributes returned wrong code\n");
581
582         pAttribs = (IXMLDOMNamedNodeMap*)0x1;
583         r = IXMLDOMText_get_attributes( nodetext, &pAttribs);
584         ok(r == S_FALSE, "ret %08x\n", r );
585         ok( pAttribs == NULL, "pAttribs not NULL\n");
586
587         /* test get_dataType */
588         r = IXMLDOMText_get_dataType(nodetext, &var);
589         ok(r == S_FALSE, "ret %08x\n", r );
590         ok( V_VT(&var) == VT_NULL, "incorrect dataType type\n");
591         VariantClear(&var);
592
593         /* test length property */
594         r = IXMLDOMText_get_length(nodetext, NULL);
595         ok(r == E_INVALIDARG, "ret %08x\n", r );
596
597         r = IXMLDOMText_get_length(nodetext, &nLength);
598         ok(r == S_OK, "ret %08x\n", r );
599         ok(nLength == 4, "expected 4 got %ld\n", nLength);
600
601         /* test nodeTypeString */
602         r = IXMLDOMText_get_nodeTypeString(nodetext, &str);
603         ok(r == S_OK, "ret %08x\n", r );
604         ok( !lstrcmpW( str, _bstr_("text") ), "incorrect nodeTypeString string\n");
605         SysFreeString(str);
606
607         /* put data Tests */
608         r = IXMLDOMText_put_data(nodetext, _bstr_("This &is a ; test <>\\"));
609         ok(r == S_OK, "ret %08x\n", r );
610
611         /* get data Tests */
612         r = IXMLDOMText_get_data(nodetext, &str);
613         ok(r == S_OK, "ret %08x\n", r );
614         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect put_data string\n");
615         SysFreeString(str);
616
617         /* Confirm XML text is good */
618         r = IXMLDOMText_get_xml(nodetext, &str);
619         ok(r == S_OK, "ret %08x\n", r );
620         ok( !lstrcmpW( str, _bstr_("This &amp;is a ; test &lt;&gt;\\") ), "incorrect xml string\n");
621         SysFreeString(str);
622
623         /* Confirm we get the put_data Text back */
624         r = IXMLDOMText_get_text(nodetext, &str);
625         ok(r == S_OK, "ret %08x\n", r );
626         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
627         SysFreeString(str);
628
629         /* test substringData */
630         r = IXMLDOMText_substringData(nodetext, 0, 4, NULL);
631         ok(r == E_INVALIDARG, "ret %08x\n", r );
632
633         /* test substringData - Invalid offset */
634         str = (BSTR)&szElement;
635         r = IXMLDOMText_substringData(nodetext, -1, 4, &str);
636         ok(r == E_INVALIDARG, "ret %08x\n", r );
637         ok( str == NULL, "incorrect string\n");
638
639         /* test substringData - Invalid offset */
640         str = (BSTR)&szElement;
641         r = IXMLDOMText_substringData(nodetext, 30, 0, &str);
642         ok(r == S_FALSE, "ret %08x\n", r );
643         ok( str == NULL, "incorrect string\n");
644
645         /* test substringData - Invalid size */
646         str = (BSTR)&szElement;
647         r = IXMLDOMText_substringData(nodetext, 0, -1, &str);
648         ok(r == E_INVALIDARG, "ret %08x\n", r );
649         ok( str == NULL, "incorrect string\n");
650
651         /* test substringData - Invalid size */
652         str = (BSTR)&szElement;
653         r = IXMLDOMText_substringData(nodetext, 2, 0, &str);
654         ok(r == S_FALSE, "ret %08x\n", r );
655         ok( str == NULL, "incorrect string\n");
656
657         /* test substringData - Start of string */
658         r = IXMLDOMText_substringData(nodetext, 0, 4, &str);
659         ok(r == S_OK, "ret %08x\n", r );
660         ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
661         SysFreeString(str);
662
663         /* test substringData - Middle of string */
664         r = IXMLDOMText_substringData(nodetext, 13, 4, &str);
665         ok(r == S_OK, "ret %08x\n", r );
666         ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
667         SysFreeString(str);
668
669         /* test substringData - End of string */
670         r = IXMLDOMText_substringData(nodetext, 20, 4, &str);
671         ok(r == S_OK, "ret %08x\n", r );
672         ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
673         SysFreeString(str);
674
675         /* test appendData */
676         r = IXMLDOMText_appendData(nodetext, NULL);
677         ok(r == S_OK, "ret %08x\n", r );
678
679         r = IXMLDOMText_appendData(nodetext, _bstr_(""));
680         ok(r == S_OK, "ret %08x\n", r );
681
682         r = IXMLDOMText_appendData(nodetext, _bstr_("Append"));
683         ok(r == S_OK, "ret %08x\n", r );
684
685         r = IXMLDOMText_get_text(nodetext, &str);
686         ok(r == S_OK, "ret %08x\n", r );
687         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string\n");
688         SysFreeString(str);
689
690         /* test insertData */
691         str = SysAllocStringLen(NULL, 0);
692         r = IXMLDOMText_insertData(nodetext, -1, str);
693         ok(r == S_OK, "ret %08x\n", r );
694
695         r = IXMLDOMText_insertData(nodetext, -1, NULL);
696         ok(r == S_OK, "ret %08x\n", r );
697
698         r = IXMLDOMText_insertData(nodetext, 1000, str);
699         ok(r == S_OK, "ret %08x\n", r );
700
701         r = IXMLDOMText_insertData(nodetext, 1000, NULL);
702         ok(r == S_OK, "ret %08x\n", r );
703
704         r = IXMLDOMText_insertData(nodetext, 0, NULL);
705         ok(r == S_OK, "ret %08x\n", r );
706
707         r = IXMLDOMText_insertData(nodetext, 0, str);
708         ok(r == S_OK, "ret %08x\n", r );
709         SysFreeString(str);
710
711         r = IXMLDOMText_insertData(nodetext, -1, _bstr_("Inserting"));
712         ok(r == E_INVALIDARG, "ret %08x\n", r );
713
714         r = IXMLDOMText_insertData(nodetext, 1000, _bstr_("Inserting"));
715         ok(r == E_INVALIDARG, "ret %08x\n", r );
716
717         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("Begin "));
718         ok(r == S_OK, "ret %08x\n", r );
719
720         r = IXMLDOMText_insertData(nodetext, 17, _bstr_("Middle"));
721         ok(r == S_OK, "ret %08x\n", r );
722
723         r = IXMLDOMText_insertData(nodetext, 39, _bstr_(" End"));
724         ok(r == S_OK, "ret %08x\n", r );
725
726         r = IXMLDOMText_get_text(nodetext, &str);
727         ok(r == S_OK, "ret %08x\n", r );
728         ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string\n");
729         SysFreeString(str);
730
731         /* test put_data */
732         V_VT(&var) = VT_BSTR;
733         V_BSTR(&var) = SysAllocString(szstr1);
734         r = IXMLDOMText_put_nodeValue(nodetext, var);
735         ok(r == S_OK, "ret %08x\n", r );
736         VariantClear(&var);
737
738         r = IXMLDOMText_get_text(nodetext, &str);
739         ok(r == S_OK, "ret %08x\n", r );
740         ok( !lstrcmpW( str, szstr1 ), "incorrect get_text string\n");
741         SysFreeString(str);
742
743         /* test put_data */
744         V_VT(&var) = VT_I4;
745         V_I4(&var) = 99;
746         r = IXMLDOMText_put_nodeValue(nodetext, var);
747         ok(r == S_OK, "ret %08x\n", r );
748         VariantClear(&var);
749
750         r = IXMLDOMText_get_text(nodetext, &str);
751         ok(r == S_OK, "ret %08x\n", r );
752         ok( !lstrcmpW( str, _bstr_("99") ), "incorrect get_text string\n");
753         SysFreeString(str);
754
755         IXMLDOMText_Release( nodetext );
756     }
757
758     /* test Create Comment */
759     r = IXMLDOMDocument_createComment(doc, NULL, NULL);
760     ok( r == E_INVALIDARG, "returns %08x\n", r );
761     r = IXMLDOMDocument_createComment(doc, szComment, &node_comment);
762     ok( r == S_OK, "returns %08x\n", r );
763     if(node_comment)
764     {
765         /* Last Child Checks */
766         r = IXMLDOMComment_get_lastChild(node_comment, NULL);
767         ok(r == E_INVALIDARG, "ret %08x\n", r );
768
769         nodeChild = (IXMLDOMNode*)0x1;
770         r = IXMLDOMComment_get_lastChild(node_comment, &nodeChild);
771         ok(r == S_FALSE, "ret %08x\n", r );
772         ok(nodeChild == NULL, "pLastChild not NULL\n");
773
774         IXMLDOMComment_Release( node_comment );
775     }
776
777     /* test Create Attribute */
778     r = IXMLDOMDocument_createAttribute(doc, NULL, NULL);
779     ok( r == E_INVALIDARG, "returns %08x\n", r );
780     r = IXMLDOMDocument_createAttribute(doc, szAttribute, &node_attr);
781     ok( r == S_OK, "returns %08x\n", r );
782     IXMLDOMText_Release( node_attr);
783
784     /* test Processing Instruction */
785     str = SysAllocStringLen(NULL, 0);
786     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, NULL);
787     ok( r == E_INVALIDARG, "returns %08x\n", r );
788     r = IXMLDOMDocument_createProcessingInstruction(doc, NULL, str, &nodePI);
789     ok( r == E_FAIL, "returns %08x\n", r );
790     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, &nodePI);
791     ok( r == E_FAIL, "returns %08x\n", r );
792     SysFreeString(str);
793
794     r = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\""), &nodePI);
795     ok( r == S_OK, "returns %08x\n", r );
796     if(nodePI)
797     {
798         /* Last Child Checks */
799         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, NULL);
800         ok(r == E_INVALIDARG, "ret %08x\n", r );
801
802         nodeChild = (IXMLDOMNode*)0x1;
803         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, &nodeChild);
804         ok(r == S_FALSE, "ret %08x\n", r );
805         ok(nodeChild == NULL, "nodeChild not NULL\n");
806
807         r = IXMLDOMProcessingInstruction_get_dataType(nodePI, &var);
808         ok(r == S_FALSE, "ret %08x\n", r );
809         ok( V_VT(&var) == VT_NULL, "incorrect dataType type\n");
810         VariantClear(&var);
811
812         /* test nodeName */
813         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
814         ok(r == S_OK, "ret %08x\n", r );
815         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
816         SysFreeString(str);
817
818         /* test Target */
819         r = IXMLDOMProcessingInstruction_get_target(nodePI, &str);
820         ok(r == S_OK, "ret %08x\n", r );
821         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect target string\n");
822         SysFreeString(str);
823
824         /* test nodeTypeString */
825         r = IXMLDOMProcessingInstruction_get_nodeTypeString(nodePI, &str);
826         ok(r == S_OK, "ret %08x\n", r );
827         ok( !lstrcmpW( str, _bstr_("processinginstruction") ), "incorrect nodeTypeString string\n");
828         SysFreeString(str);
829
830         /* test get_nodeValue */
831         r = IXMLDOMProcessingInstruction_get_nodeValue(nodePI, &var);
832         ok(r == S_OK, "ret %08x\n", r );
833         ok( !lstrcmpW( V_BSTR(&var), _bstr_("version=\"1.0\"") ), "incorrect data string\n");
834         VariantClear(&var);
835
836         /* test get_data */
837         r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
838         ok(r == S_OK, "ret %08x\n", r );
839         ok( !lstrcmpW( str, _bstr_("version=\"1.0\"") ), "incorrect data string\n");
840         SysFreeString(str);
841
842         /* test put_data */
843         r = IXMLDOMProcessingInstruction_put_data(nodePI, _bstr_("version=\"1.0\" encoding=\"UTF-8\""));
844         ok(r == E_FAIL, "ret %08x\n", r );
845
846         /* test put_data */
847         V_VT(&var) = VT_BSTR;
848         V_BSTR(&var) = SysAllocString(szOpen);  /* Doesn't matter what the string is, cannot set an xml node. */
849         r = IXMLDOMProcessingInstruction_put_nodeValue(nodePI, var);
850         ok(r == E_FAIL, "ret %08x\n", r );
851         VariantClear(&var);
852
853         /* test get nodeName */
854         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
855         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
856         ok(r == S_OK, "ret %08x\n", r );
857         SysFreeString(str);
858
859         IXMLDOMProcessingInstruction_Release(nodePI);
860     }
861
862     r = IXMLDOMDocument_Release( doc );
863     ok( r == 0, "document ref count incorrect\n");
864
865     free_bstrs();
866 }
867
868 static void test_domnode( void )
869 {
870     HRESULT r;
871     IXMLDOMDocument *doc = NULL, *owner = NULL;
872     IXMLDOMElement *element = NULL;
873     IXMLDOMNamedNodeMap *map = NULL;
874     IXMLDOMNode *node = NULL, *next = NULL;
875     IXMLDOMNodeList *list = NULL;
876     IXMLDOMAttribute *attr = NULL;
877     DOMNodeType type = NODE_INVALID;
878     VARIANT_BOOL b;
879     BSTR str;
880     VARIANT var;
881     long count;
882
883     r = CoCreateInstance( &CLSID_DOMDocument, NULL, 
884         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
885     if( r != S_OK )
886         return;
887
888     b = FALSE;
889     str = SysAllocString( szComplete4 );
890     r = IXMLDOMDocument_loadXML( doc, str, &b );
891     ok( r == S_OK, "loadXML failed\n");
892     ok( b == VARIANT_TRUE, "failed to load XML string\n");
893     SysFreeString( str );
894
895     if (doc)
896     {
897         b = 1;
898         r = IXMLDOMNode_hasChildNodes( doc, &b );
899         ok( r == S_OK, "hasChildNoes bad return\n");
900         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
901
902         r = IXMLDOMDocument_get_documentElement( doc, &element );
903         ok( r == S_OK, "should be a document element\n");
904         ok( element != NULL, "should be an element\n");
905     }
906     else
907         ok( FALSE, "no document\n");
908
909     VariantInit(&var);
910     ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
911
912     r = IXMLDOMNode_get_nodeValue( doc, NULL );
913     ok(r == E_INVALIDARG, "get_nodeValue ret %08x\n", r );
914
915     r = IXMLDOMNode_get_nodeValue( doc, &var );
916     ok( r == S_FALSE, "nextNode returned wrong code\n");
917     ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
918     ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
919
920     if (element)
921     {
922         owner = NULL;
923         r = IXMLDOMNode_get_ownerDocument( element, &owner );
924         ok( r == S_OK, "get_ownerDocument return code\n");
925         ok( owner != doc, "get_ownerDocument return\n");
926
927         type = NODE_INVALID;
928         r = IXMLDOMNode_get_nodeType( element, &type);
929         ok( r == S_OK, "getNamedItem returned wrong code\n");
930         ok( type == NODE_ELEMENT, "node not an element\n");
931
932         str = NULL;
933         r = IXMLDOMNode_get_baseName( element, &str );
934         ok( r == S_OK, "get_baseName returned wrong code\n");
935         ok( lstrcmpW(str,szlc) == 0, "basename was wrong\n");
936         SysFreeString(str);
937
938         /* check if nodename is correct */
939         r = IXMLDOMElement_get_nodeName( element, NULL );
940         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
941     
942         /* content doesn't matter here */
943         str = NULL;
944         r = IXMLDOMElement_get_nodeName( element, &str );
945         ok ( r == S_OK, "get_nodeName wrong code\n");
946         ok ( str != NULL, "str is null\n");
947         ok( !lstrcmpW( str, szlc ), "incorrect nodeName\n");
948         SysFreeString( str );
949
950         str = SysAllocString( szNonExistentFile );      
951         V_VT(&var) = VT_I4;
952         V_I4(&var) = 0x1234;
953         r = IXMLDOMElement_getAttribute( element, str, &var );
954         ok( r == E_FAIL, "getAttribute ret %08x\n", r );
955         ok( V_VT(&var) == VT_NULL || V_VT(&var) == VT_EMPTY, "vt = %x\n", V_VT(&var));
956         VariantClear(&var);
957
958         attr = (IXMLDOMAttribute*)0xdeadbeef;
959         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
960         ok( r == E_FAIL, "getAttributeNode ret %08x\n", r );
961         ok( attr == NULL, "getAttributeNode ret %p, expected NULL\n", attr );
962         SysFreeString( str );
963
964         str = SysAllocString( szdl );   
965         V_VT(&var) = VT_I4;
966         V_I4(&var) = 0x1234;
967         r = IXMLDOMElement_getAttribute( element, str, &var );
968         ok( r == S_OK, "getAttribute ret %08x\n", r );
969         ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
970         ok( !lstrcmpW(V_BSTR(&var), szstr1), "wrong attr value\n");
971         VariantClear( &var );
972
973         r = IXMLDOMElement_getAttribute( element, NULL, &var );
974         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
975
976         r = IXMLDOMElement_getAttribute( element, str, NULL );
977         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
978
979         attr = NULL;
980         r = IXMLDOMElement_getAttributeNode( element, str, &attr);
981         ok( r == S_OK, "GetAttributeNode ret %08x\n", r );
982         ok( attr != NULL, "getAttributeNode returned NULL\n" );
983         if(attr)
984             IXMLDOMAttribute_Release(attr);
985
986         SysFreeString( str );
987
988         r = IXMLDOMElement_get_attributes( element, &map );
989         ok( r == S_OK, "get_attributes returned wrong code\n");
990         ok( map != NULL, "should be attributes\n");
991
992         b = 1;
993         r = IXMLDOMNode_hasChildNodes( element, &b );
994         ok( r == S_OK, "hasChildNoes bad return\n");
995         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
996     }
997     else
998         ok( FALSE, "no element\n");
999
1000     if (map)
1001     {
1002         ISupportErrorInfo *support_error;
1003         r = IXMLDOMNamedNodeMap_QueryInterface( map, &IID_ISupportErrorInfo, (LPVOID*)&support_error );
1004         ok( r == S_OK, "ret %08x\n", r );
1005
1006         r = ISupportErrorInfo_InterfaceSupportsErrorInfo( support_error, &IID_IXMLDOMNamedNodeMap );
1007 todo_wine
1008 {
1009         ok( r == S_OK, "ret %08x\n", r );
1010 }
1011         ISupportErrorInfo_Release( support_error );
1012
1013         str = SysAllocString( szdl );
1014         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
1015         ok( r == S_OK, "getNamedItem returned wrong code\n");
1016         ok( node != NULL, "should be attributes\n");
1017         IXMLDOMNode_Release(node);
1018         SysFreeString( str );
1019
1020         str = SysAllocString( szdl );
1021         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, NULL );
1022         ok( r == E_INVALIDARG, "getNamedItem should return E_INVALIDARG\n");
1023         SysFreeString( str );
1024
1025         /* something that isn't in szComplete4 */
1026         str = SysAllocString( szOpen );
1027         node = (IXMLDOMNode *) 1;
1028         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
1029         ok( r == S_FALSE, "getNamedItem found a node that wasn't there\n");
1030         ok( node == NULL, "getNamedItem should have returned NULL\n");
1031         SysFreeString( str );
1032
1033         /* test indexed access of attributes */
1034         r = IXMLDOMNamedNodeMap_get_length( map, NULL );
1035         ok ( r == E_INVALIDARG, "get_length should return E_INVALIDARG\n");
1036
1037         r = IXMLDOMNamedNodeMap_get_length( map, &count );
1038         ok ( r == S_OK, "get_length wrong code\n");
1039         ok ( count == 1, "get_length != 1\n");
1040
1041         node = NULL;
1042         r = IXMLDOMNamedNodeMap_get_item( map, -1, &node);
1043         ok ( r == S_FALSE, "get_item (-1) wrong code\n");
1044         ok ( node == NULL, "there is no node\n");
1045
1046         node = NULL;
1047         r = IXMLDOMNamedNodeMap_get_item( map, 1, &node);
1048         ok ( r == S_FALSE, "get_item (1) wrong code\n");
1049         ok ( node == NULL, "there is no attribute\n");
1050
1051         node = NULL;
1052         r = IXMLDOMNamedNodeMap_get_item( map, 0, &node);
1053         ok ( r == S_OK, "get_item (0) wrong code\n");
1054         ok ( node != NULL, "should be attribute\n");
1055
1056         r = IXMLDOMNode_get_nodeName( node, NULL );
1057         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
1058
1059         /* content doesn't matter here */
1060         str = NULL;
1061         r = IXMLDOMNode_get_nodeName( node, &str );
1062         ok ( r == S_OK, "get_nodeName wrong code\n");
1063         ok ( str != NULL, "str is null\n");
1064         ok( !lstrcmpW( str, szdl ), "incorrect node name\n");
1065         SysFreeString( str );
1066
1067         /* test sequential access of attributes */
1068         node = NULL;
1069         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
1070         ok ( r == S_OK, "nextNode (first time) wrong code\n");
1071         ok ( node != NULL, "nextNode, should be attribute\n");
1072
1073         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
1074         ok ( r != S_OK, "nextNode (second time) wrong code\n");
1075         ok ( node == NULL, "nextNode, there is no attribute\n");
1076
1077         r = IXMLDOMNamedNodeMap_reset( map );
1078         ok ( r == S_OK, "reset should return S_OK\n");
1079
1080         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
1081         ok ( r == S_OK, "nextNode (third time) wrong code\n");
1082         ok ( node != NULL, "nextNode, should be attribute\n");
1083     }
1084     else
1085         ok( FALSE, "no map\n");
1086
1087     if (node)
1088     {
1089         type = NODE_INVALID;
1090         r = IXMLDOMNode_get_nodeType( node, &type);
1091         ok( r == S_OK, "getNamedItem returned wrong code\n");
1092         ok( type == NODE_ATTRIBUTE, "node not an attribute\n");
1093
1094         str = NULL;
1095         r = IXMLDOMNode_get_baseName( node, NULL );
1096         ok( r == E_INVALIDARG, "get_baseName returned wrong code\n");
1097
1098         str = NULL;
1099         r = IXMLDOMNode_get_baseName( node, &str );
1100         ok( r == S_OK, "get_baseName returned wrong code\n");
1101         ok( lstrcmpW(str,szdl) == 0, "basename was wrong\n");
1102         SysFreeString( str );
1103
1104         r = IXMLDOMNode_get_nodeValue( node, &var );
1105         ok( r == S_OK, "returns %08x\n", r );
1106         ok( V_VT(&var) == VT_BSTR, "vt %x\n", V_VT(&var));
1107         ok( !lstrcmpW(V_BSTR(&var), szstr1), "nodeValue incorrect\n");
1108         VariantClear(&var);
1109
1110         r = IXMLDOMNode_get_childNodes( node, NULL );
1111         ok( r == E_INVALIDARG, "get_childNodes returned wrong code\n");
1112
1113         r = IXMLDOMNode_get_childNodes( node, &list );
1114         ok( r == S_OK, "get_childNodes returned wrong code\n");
1115
1116         if (list)
1117         {
1118             r = IXMLDOMNodeList_nextNode( list, &next );
1119             ok( r == S_OK, "nextNode returned wrong code\n");
1120         }
1121         else
1122             ok( FALSE, "no childlist\n");
1123
1124         if (next)
1125         {
1126             b = 1;
1127             r = IXMLDOMNode_hasChildNodes( next, &b );
1128             ok( r == S_FALSE, "hasChildNoes bad return\n");
1129             ok( b == VARIANT_FALSE, "hasChildNoes wrong result\n");
1130
1131             type = NODE_INVALID;
1132             r = IXMLDOMNode_get_nodeType( next, &type);
1133             ok( r == S_OK, "getNamedItem returned wrong code\n");
1134             ok( type == NODE_TEXT, "node not text\n");
1135
1136             str = (BSTR) 1;
1137             r = IXMLDOMNode_get_baseName( next, &str );
1138             ok( r == S_FALSE, "get_baseName returned wrong code\n");
1139             ok( str == NULL, "basename was wrong\n");
1140             SysFreeString(str);
1141         }
1142         else
1143             ok( FALSE, "no next\n");
1144
1145         if (next)
1146             IXMLDOMNode_Release( next );
1147         next = NULL;
1148         if (list)
1149             IXMLDOMNodeList_Release( list );
1150         list = NULL;
1151         if (node)
1152             IXMLDOMNode_Release( node );
1153     }
1154     else
1155         ok( FALSE, "no node\n");
1156     node = NULL;
1157
1158     if (map)
1159         IXMLDOMNamedNodeMap_Release( map );
1160
1161     /* now traverse the tree from the root element */
1162     if (element)
1163     {
1164         IXMLDOMNode *node;
1165         r = IXMLDOMNode_get_childNodes( element, &list );
1166         ok( r == S_OK, "get_childNodes returned wrong code\n");
1167
1168         /* using get_item for child list doesn't advance the position */
1169         ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
1170         expect_node(node, "E2.E2.D1");
1171         IXMLDOMNode_Release(node);
1172         ole_check(IXMLDOMNodeList_nextNode(list, &node));
1173         expect_node(node, "E1.E2.D1");
1174         IXMLDOMNode_Release(node);
1175         ole_check(IXMLDOMNodeList_reset(list));
1176
1177         IXMLDOMNodeList_AddRef(list);
1178         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1");
1179         ole_check(IXMLDOMNodeList_reset(list));
1180     }
1181     else
1182         ok( FALSE, "no element\n");
1183
1184     node = (void*)0xdeadbeef;
1185     r = IXMLDOMNode_selectSingleNode( element, szdl, &node );
1186     ok( r == S_FALSE, "ret %08x\n", r );
1187     ok( node == NULL, "node %p\n", node );
1188     r = IXMLDOMNode_selectSingleNode( element, szbs, &node );
1189     ok( r == S_OK, "ret %08x\n", r );
1190     r = IXMLDOMNode_Release( node );
1191     ok( r == 0, "ret %08x\n", r );
1192
1193     if (list)
1194     {
1195         r = IXMLDOMNodeList_QueryInterface(list, &IID_IDispatch, NULL);
1196         ok( r == E_INVALIDARG || r == E_POINTER, "ret %08x\n", r );
1197
1198         r = IXMLDOMNodeList_get_item(list, 0, NULL);
1199         ok(r == E_INVALIDARG, "Exected E_INVALIDARG got %08x\n", r);
1200
1201         r = IXMLDOMNodeList_get_length(list, NULL);
1202         ok(r == E_INVALIDARG, "Exected E_INVALIDARG got %08x\n", r);
1203
1204         r = IXMLDOMNodeList_get_length( list, &count );
1205         ok( r == S_OK, "get_length returns %08x\n", r );
1206         ok( count == 4, "get_length got %ld\n", count );
1207
1208         r = IXMLDOMNodeList_nextNode(list, NULL);
1209         ok(r == E_INVALIDARG, "Exected E_INVALIDARG got %08x\n", r);
1210
1211         r = IXMLDOMNodeList_nextNode( list, &node );
1212         ok( r == S_OK, "nextNode returned wrong code\n");
1213     }
1214     else
1215         ok( FALSE, "no list\n");
1216
1217     if (node)
1218     {
1219         type = NODE_INVALID;
1220         r = IXMLDOMNode_get_nodeType( node, &type);
1221         ok( r == S_OK, "getNamedItem returned wrong code\n");
1222         ok( type == NODE_ELEMENT, "node not text\n");
1223
1224         VariantInit(&var);
1225         ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
1226         r = IXMLDOMNode_get_nodeValue( node, &var );
1227         ok( r == S_FALSE, "nextNode returned wrong code\n");
1228         ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
1229         ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
1230
1231         r = IXMLDOMNode_hasChildNodes( node, NULL );
1232         ok( r == E_INVALIDARG, "hasChildNoes bad return\n");
1233
1234         b = 1;
1235         r = IXMLDOMNode_hasChildNodes( node, &b );
1236         ok( r == S_OK, "hasChildNoes bad return\n");
1237         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
1238
1239         str = NULL;
1240         r = IXMLDOMNode_get_baseName( node, &str );
1241         ok( r == S_OK, "get_baseName returned wrong code\n");
1242         ok( lstrcmpW(str,szbs) == 0, "basename was wrong\n");
1243         SysFreeString(str);
1244     }
1245     else
1246         ok( FALSE, "no node\n");
1247
1248     if (node)
1249         IXMLDOMNode_Release( node );
1250     if (list)
1251         IXMLDOMNodeList_Release( list );
1252     if (element)
1253         IXMLDOMElement_Release( element );
1254
1255     b = FALSE;
1256     str = SysAllocString( szComplete5 );
1257     r = IXMLDOMDocument_loadXML( doc, str, &b );
1258     ok( r == S_OK, "loadXML failed\n");
1259     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1260     SysFreeString( str );
1261
1262     b = 1;
1263     r = IXMLDOMNode_hasChildNodes( doc, &b );
1264     ok( r == S_OK, "hasChildNoes bad return\n");
1265     ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
1266
1267     r = IXMLDOMDocument_get_documentElement( doc, &element );
1268     ok( r == S_OK, "should be a document element\n");
1269     ok( element != NULL, "should be an element\n");
1270
1271     if (element)
1272     {
1273         static const WCHAR szSSearch[] = {'S',':','s','e','a','r','c','h',0};
1274         BSTR tag = NULL;
1275
1276         /* check if the tag is correct */
1277         r = IXMLDOMElement_get_tagName( element, &tag );
1278         ok( r == S_OK, "couldn't get tag name\n");
1279         ok( tag != NULL, "tag was null\n");
1280         ok( !lstrcmpW( tag, szSSearch ), "incorrect tag name\n");
1281         SysFreeString( tag );
1282     }
1283
1284     if (element)
1285         IXMLDOMElement_Release( element );
1286     if (doc)
1287         ok(IXMLDOMDocument_Release( doc ) == 0, "document is not destroyed\n");
1288 }
1289
1290 static void test_refs(void)
1291 {
1292     HRESULT r;
1293     BSTR str;
1294     VARIANT_BOOL b;
1295     IXMLDOMDocument *doc = NULL;
1296     IXMLDOMElement *element = NULL;
1297     IXMLDOMNode *node = NULL, *node2;
1298     IXMLDOMNodeList *node_list = NULL;
1299     LONG ref;
1300     IUnknown *unk, *unk2;
1301
1302     r = CoCreateInstance( &CLSID_DOMDocument, NULL, 
1303         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1304     if( r != S_OK )
1305         return;
1306     ref = IXMLDOMDocument_Release(doc);
1307     ok( ref == 0, "ref %d\n", ref);
1308
1309     r = CoCreateInstance( &CLSID_DOMDocument, NULL, 
1310         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1311     if( r != S_OK )
1312         return;
1313
1314     str = SysAllocString( szComplete4 );
1315     r = IXMLDOMDocument_loadXML( doc, str, &b );
1316     ok( r == S_OK, "loadXML failed\n");
1317     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1318     SysFreeString( str );
1319
1320     ref = IXMLDOMDocument_AddRef( doc );
1321     ok( ref == 2, "ref %d\n", ref );
1322     ref = IXMLDOMDocument_AddRef( doc );
1323     ok( ref == 3, "ref %d\n", ref );
1324     IXMLDOMDocument_Release( doc );
1325     IXMLDOMDocument_Release( doc );
1326
1327     r = IXMLDOMDocument_get_documentElement( doc, &element );
1328     ok( r == S_OK, "should be a document element\n");
1329     ok( element != NULL, "should be an element\n");
1330
1331     ref = IXMLDOMDocument_AddRef( doc );
1332     ok( ref == 2, "ref %d\n", ref );
1333     IXMLDOMDocument_Release( doc );
1334
1335     r = IXMLDOMElement_get_childNodes( element, &node_list );
1336     ok( r == S_OK, "rets %08x\n", r);
1337
1338     ref = IXMLDOMNodeList_AddRef( node_list );
1339     ok( ref == 2, "ref %d\n", ref );
1340     IXMLDOMNodeList_Release( node_list );
1341
1342     IXMLDOMNodeList_get_item( node_list, 0, &node );
1343     ok( r == S_OK, "rets %08x\n", r);
1344
1345     IXMLDOMNodeList_get_item( node_list, 0, &node2 );
1346     ok( r == S_OK, "rets %08x\n", r);
1347
1348     ref = IXMLDOMNode_AddRef( node );
1349     ok( ref == 2, "ref %d\n", ref );
1350     IXMLDOMNode_Release( node );
1351
1352     ref = IXMLDOMNode_Release( node );
1353     ok( ref == 0, "ref %d\n", ref );
1354     ref = IXMLDOMNode_Release( node2 );
1355     ok( ref == 0, "ref %d\n", ref );
1356
1357     ref = IXMLDOMNodeList_Release( node_list );
1358     ok( ref == 0, "ref %d\n", ref );
1359
1360     ok( node != node2, "node %p node2 %p\n", node, node2 );
1361
1362     ref = IXMLDOMDocument_Release( doc );
1363     ok( ref == 0, "ref %d\n", ref );
1364
1365     ref = IXMLDOMElement_AddRef( element );
1366     todo_wine {
1367     ok( ref == 3, "ref %d\n", ref );
1368     }
1369     IXMLDOMElement_Release( element );
1370
1371     /* IUnknown must be unique however we obtain it */
1372     r = IXMLDOMElement_QueryInterface( element, &IID_IUnknown, (LPVOID*)&unk );
1373     ok( r == S_OK, "rets %08x\n", r );
1374     r = IXMLDOMElement_QueryInterface( element, &IID_IXMLDOMNode, (LPVOID*)&node );
1375     ok( r == S_OK, "rets %08x\n", r );
1376     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (LPVOID*)&unk2 );
1377     ok( r == S_OK, "rets %08x\n", r );
1378     ok( unk == unk2, "unk %p unk2 %p\n", unk, unk2 );
1379
1380     IUnknown_Release( unk2 );
1381     IUnknown_Release( unk );
1382     IXMLDOMNode_Release( node );
1383
1384     IXMLDOMElement_Release( element );
1385
1386 }
1387
1388 static void test_create(void)
1389 {
1390     static const WCHAR szOne[] = {'1',0};
1391     static const WCHAR szOneGarbage[] = {'1','G','a','r','b','a','g','e',0};
1392     HRESULT r;
1393     VARIANT var;
1394     BSTR str, name;
1395     IXMLDOMDocument *doc;
1396     IXMLDOMElement *element;
1397     IXMLDOMNode *root, *node, *child;
1398     IXMLDOMNamedNodeMap *attr_map;
1399     IUnknown *unk;
1400     LONG ref;
1401     long num;
1402
1403     r = CoCreateInstance( &CLSID_DOMDocument, NULL, 
1404         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1405     if( r != S_OK )
1406         return;
1407
1408     V_VT(&var) = VT_I1;
1409     V_I1(&var) = NODE_ELEMENT;
1410     str = SysAllocString( szlc );
1411     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1412     ok( r == S_OK, "returns %08x\n", r );
1413     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
1414
1415     V_VT(&var) = VT_R4;
1416     V_R4(&var) = NODE_ELEMENT;
1417     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1418     ok( r == S_OK, "returns %08x\n", r );
1419     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
1420
1421     V_VT(&var) = VT_BSTR;
1422     V_BSTR(&var) = SysAllocString( szOne );
1423     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1424     ok( r == S_OK, "returns %08x\n", r );
1425     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
1426     VariantClear(&var);
1427
1428     V_VT(&var) = VT_BSTR;
1429     V_BSTR(&var) = SysAllocString( szOneGarbage );
1430     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1431     ok( r == E_INVALIDARG, "returns %08x\n", r );
1432     if( SUCCEEDED(r) ) IXMLDOMNode_Release( node );
1433     VariantClear(&var);
1434
1435     V_VT(&var) = VT_I4;
1436     V_I4(&var) = NODE_ELEMENT;
1437     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1438     ok( r == S_OK, "returns %08x\n", r );
1439     r = IXMLDOMDocument_appendChild( doc, node, &root );
1440     ok( r == S_OK, "returns %08x\n", r );
1441     ok( node == root, "%p %p\n", node, root );
1442
1443     ref = IXMLDOMNode_AddRef( node );
1444     ok(ref == 3, "ref %d\n", ref);
1445     IXMLDOMNode_Release( node );
1446
1447     ref = IXMLDOMNode_Release( node );
1448     ok(ref == 1, "ref %d\n", ref);
1449     SysFreeString( str );
1450
1451     V_VT(&var) = VT_I4;
1452     V_I4(&var) = NODE_ELEMENT;
1453     str = SysAllocString( szbs );
1454     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1455     ok( r == S_OK, "returns %08x\n", r );
1456     SysFreeString( str );
1457
1458     ref = IXMLDOMNode_AddRef( node );
1459     ok(ref == 2, "ref = %d\n", ref);
1460     IXMLDOMNode_Release( node );
1461
1462     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (LPVOID*)&unk );
1463     ok( r == S_OK, "returns %08x\n", r );
1464
1465     ref = IXMLDOMNode_AddRef( unk );
1466     ok(ref == 3, "ref = %d\n", ref);
1467     IXMLDOMNode_Release( unk );
1468
1469     V_VT(&var) = VT_EMPTY;
1470     r = IXMLDOMNode_insertBefore( root, (IXMLDOMNode*)unk, var, &child );
1471     ok( r == S_OK, "returns %08x\n", r );
1472     ok( unk == (IUnknown*)child, "%p %p\n", unk, child );
1473     IXMLDOMNode_Release( child );
1474     IUnknown_Release( unk );
1475
1476
1477     V_VT(&var) = VT_NULL;
1478     V_DISPATCH(&var) = (IDispatch*)node;
1479     r = IXMLDOMNode_insertBefore( root, node, var, &child );
1480     ok( r == S_OK, "returns %08x\n", r );
1481     ok( node == child, "%p %p\n", node, child );
1482     IXMLDOMNode_Release( child );
1483
1484
1485     V_VT(&var) = VT_NULL;
1486     V_DISPATCH(&var) = (IDispatch*)node;
1487     r = IXMLDOMNode_insertBefore( root, node, var, NULL );
1488     ok( r == S_OK, "returns %08x\n", r );
1489     IXMLDOMNode_Release( node );
1490
1491     r = IXMLDOMNode_QueryInterface( root, &IID_IXMLDOMElement, (LPVOID*)&element );
1492     ok( r == S_OK, "returns %08x\n", r );
1493
1494     r = IXMLDOMElement_get_attributes( element, &attr_map );
1495     ok( r == S_OK, "returns %08x\n", r );
1496     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1497     ok( r == S_OK, "returns %08x\n", r );
1498     ok( num == 0, "num %ld\n", num );
1499     IXMLDOMNamedNodeMap_Release( attr_map );
1500
1501     V_VT(&var) = VT_BSTR;
1502     V_BSTR(&var) = SysAllocString( szstr1 );
1503     name = SysAllocString( szdl );
1504     r = IXMLDOMElement_setAttribute( element, name, var );
1505     ok( r == S_OK, "returns %08x\n", r );
1506     r = IXMLDOMElement_get_attributes( element, &attr_map );
1507     ok( r == S_OK, "returns %08x\n", r );
1508     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1509     ok( r == S_OK, "returns %08x\n", r );
1510     ok( num == 1, "num %ld\n", num );
1511     IXMLDOMNamedNodeMap_Release( attr_map );
1512     VariantClear(&var);
1513
1514     V_VT(&var) = VT_BSTR;
1515     V_BSTR(&var) = SysAllocString( szstr2 );
1516     r = IXMLDOMElement_setAttribute( element, name, var );
1517     ok( r == S_OK, "returns %08x\n", r );
1518     r = IXMLDOMElement_get_attributes( element, &attr_map );
1519     ok( r == S_OK, "returns %08x\n", r );
1520     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1521     ok( r == S_OK, "returns %08x\n", r );
1522     ok( num == 1, "num %ld\n", num );
1523     IXMLDOMNamedNodeMap_Release( attr_map );
1524     VariantClear(&var);
1525     r = IXMLDOMElement_getAttribute( element, name, &var );
1526     ok( r == S_OK, "returns %08x\n", r );
1527     ok( !lstrcmpW(V_BSTR(&var), szstr2), "wrong attr value\n");
1528     VariantClear(&var);
1529     SysFreeString(name);
1530
1531     V_VT(&var) = VT_BSTR;
1532     V_BSTR(&var) = SysAllocString( szstr1 );
1533     name = SysAllocString( szlc );
1534     r = IXMLDOMElement_setAttribute( element, name, var );
1535     ok( r == S_OK, "returns %08x\n", r );
1536     r = IXMLDOMElement_get_attributes( element, &attr_map );
1537     ok( r == S_OK, "returns %08x\n", r );
1538     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1539     ok( r == S_OK, "returns %08x\n", r );
1540     ok( num == 2, "num %ld\n", num );
1541     IXMLDOMNamedNodeMap_Release( attr_map );
1542     VariantClear(&var);
1543     SysFreeString(name);
1544
1545     V_VT(&var) = VT_I4;
1546     V_I4(&var) = 10;
1547     name = SysAllocString( szbs );
1548     r = IXMLDOMElement_setAttribute( element, name, var );
1549     ok( r == S_OK, "returns %08x\n", r );
1550     VariantClear(&var);
1551     r = IXMLDOMElement_getAttribute( element, name, &var );
1552     ok( r == S_OK, "returns %08x\n", r );
1553     ok( V_VT(&var) == VT_BSTR, "variant type %x\n", V_VT(&var));
1554     VariantClear(&var);
1555     SysFreeString(name);
1556
1557     /* Create an Attribute */
1558     V_VT(&var) = VT_I4;
1559     V_I4(&var) = NODE_ATTRIBUTE;
1560     str = SysAllocString( szAttribute );
1561     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1562     ok( r == S_OK, "returns %08x\n", r );
1563     ok( node != NULL, "node was null\n");
1564     SysFreeString(str);
1565
1566     if(r == S_OK)
1567     {
1568         r = IXMLDOMNode_get_nodeTypeString(node, &str);
1569         ok( r == S_OK, "returns %08x\n", r );
1570         ok( !lstrcmpW( str, _bstr_("attribute") ), "incorrect nodeTypeString string\n");
1571         SysFreeString(str);
1572         IXMLDOMNode_Release( node );
1573     }
1574
1575     IXMLDOMElement_Release( element );
1576     IXMLDOMNode_Release( root );
1577     IXMLDOMDocument_Release( doc );
1578 }
1579
1580 static void test_getElementsByTagName(void)
1581 {
1582     HRESULT r;
1583     BSTR str;
1584     VARIANT_BOOL b;
1585     IXMLDOMDocument *doc;
1586     IXMLDOMNodeList *node_list;
1587     IDispatchEx *dispex;
1588     long len;
1589
1590     r = CoCreateInstance( &CLSID_DOMDocument, NULL, 
1591         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1592     if( r != S_OK )
1593         return;
1594
1595     str = SysAllocString( szComplete4 );
1596     r = IXMLDOMDocument_loadXML( doc, str, &b );
1597     ok( r == S_OK, "loadXML failed\n");
1598     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1599     SysFreeString( str );
1600
1601     str = SysAllocString( szstar );
1602     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1603     ok( r == S_OK, "ret %08x\n", r );
1604     r = IXMLDOMNodeList_get_length( node_list, &len );
1605     ok( r == S_OK, "ret %08x\n", r );
1606     ok( len == 6, "len %ld\n", len );
1607
1608     r = IXMLDOMNodeList_QueryInterface( node_list, &IID_IDispatchEx, (void**)&dispex );
1609     ok( r == S_OK, "rets %08x\n", r);
1610     if( r == S_OK )
1611     {
1612         DISPID dispid = DISPID_XMLDOM_NODELIST_RESET;
1613         DWORD dwProps = 0;
1614         BSTR sName;
1615         IUnknown *pUnk;
1616
1617         sName = SysAllocString( szstar );
1618         r = IDispatchEx_DeleteMemberByName(dispex, sName, fdexNameCaseSensitive);
1619         ok(r == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", r);
1620         SysFreeString( sName );
1621
1622         r = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
1623         ok(r == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", r);
1624
1625         r = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &dwProps);
1626         ok(r == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", r);
1627         ok(dwProps == 0, "expected 0 got %d\n", dwProps);
1628
1629         r = IDispatchEx_GetMemberName(dispex, dispid, &sName);
1630         ok(r == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", r);
1631         if( SUCCEEDED(r) )
1632             SysFreeString(sName);
1633
1634         r = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_XMLDOM_NODELIST_RESET, &dispid);
1635         ok(r == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", r);
1636
1637         r = IDispatchEx_GetNameSpaceParent(dispex, &pUnk);
1638         ok(r == E_NOTIMPL, "expected E_NOTIMPL got %08x\n", r);
1639         if(r == S_OK)
1640             IUnknown_Release(pUnk);
1641
1642         IDispatchEx_Release( dispex );
1643     }
1644
1645
1646     IXMLDOMNodeList_Release( node_list );
1647     SysFreeString( str );
1648
1649     str = SysAllocString( szbs );
1650     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1651     ok( r == S_OK, "ret %08x\n", r );
1652     r = IXMLDOMNodeList_get_length( node_list, &len );
1653     ok( r == S_OK, "ret %08x\n", r );
1654     ok( len == 1, "len %ld\n", len );
1655     IXMLDOMNodeList_Release( node_list );
1656     SysFreeString( str );
1657
1658     str = SysAllocString( szdl );
1659     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1660     ok( r == S_OK, "ret %08x\n", r );
1661     r = IXMLDOMNodeList_get_length( node_list, &len );
1662     ok( r == S_OK, "ret %08x\n", r );
1663     ok( len == 0, "len %ld\n", len );
1664     IXMLDOMNodeList_Release( node_list );
1665     SysFreeString( str );
1666
1667     str = SysAllocString( szstr1 );
1668     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1669     ok( r == S_OK, "ret %08x\n", r );
1670     r = IXMLDOMNodeList_get_length( node_list, &len );
1671     ok( r == S_OK, "ret %08x\n", r );
1672     ok( len == 0, "len %ld\n", len );
1673     IXMLDOMNodeList_Release( node_list );
1674     SysFreeString( str );
1675
1676     IXMLDOMDocument_Release( doc );
1677 }
1678
1679 static void test_get_text(void)
1680 {
1681     HRESULT r;
1682     BSTR str;
1683     VARIANT_BOOL b;
1684     IXMLDOMDocument *doc;
1685     IXMLDOMNode *node, *node2, *node3;
1686     IXMLDOMNodeList *node_list;
1687     IXMLDOMNamedNodeMap *node_map;
1688     long len;
1689
1690     r = CoCreateInstance( &CLSID_DOMDocument, NULL, 
1691         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1692     if( r != S_OK )
1693         return;
1694
1695     str = SysAllocString( szComplete4 );
1696     r = IXMLDOMDocument_loadXML( doc, str, &b );
1697     ok( r == S_OK, "loadXML failed\n");
1698     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1699     SysFreeString( str );
1700
1701     str = SysAllocString( szbs );
1702     r = IXMLDOMDocument_getElementsByTagName( doc, str, &node_list );
1703     ok( r == S_OK, "ret %08x\n", r );
1704     SysFreeString(str);
1705
1706     if (0) {
1707     /* this test crashes on win9x */
1708     r = IXMLDOMNodeList_QueryInterface(node_list, &IID_IDispatch, NULL);
1709     ok( r == E_INVALIDARG, "ret %08x\n", r );
1710     }
1711
1712     r = IXMLDOMNodeList_get_length( node_list, NULL );
1713     ok( r == E_INVALIDARG, "ret %08x\n", r );
1714
1715     r = IXMLDOMNodeList_get_length( node_list, &len );
1716     ok( r == S_OK, "ret %08x\n", r );
1717     ok( len == 1, "expect 1 got %ld\n", len );
1718
1719     r = IXMLDOMNodeList_get_item( node_list, 0, NULL );
1720     ok( r == E_INVALIDARG, "ret %08x\n", r );
1721
1722     r = IXMLDOMNodeList_nextNode( node_list, NULL );
1723     ok( r == E_INVALIDARG, "ret %08x\n", r );
1724
1725     r = IXMLDOMNodeList_get_item( node_list, 0, &node );
1726     ok( r == S_OK, "ret %08x\n", r ); 
1727     IXMLDOMNodeList_Release( node_list );
1728
1729     /* Invalid output parameter*/
1730     r = IXMLDOMNode_get_text( node, NULL );
1731     ok( r == E_INVALIDARG, "ret %08x\n", r );
1732
1733     r = IXMLDOMNode_get_text( node, &str );
1734     ok( r == S_OK, "ret %08x\n", r );
1735     ok( !memcmp(str, szfn1_txt, lstrlenW(szfn1_txt) ), "wrong string\n" );
1736     SysFreeString(str);
1737
1738     r = IXMLDOMNode_get_attributes( node, &node_map );
1739     ok( r == S_OK, "ret %08x\n", r );
1740     
1741     str = SysAllocString( szvr );
1742     r = IXMLDOMNamedNodeMap_getNamedItem( node_map, str, &node2 );
1743     ok( r == S_OK, "ret %08x\n", r );
1744     SysFreeString(str);
1745
1746     r = IXMLDOMNode_get_text( node2, &str );
1747     ok( r == S_OK, "ret %08x\n", r );
1748     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
1749     SysFreeString(str);
1750
1751     r = IXMLDOMNode_get_firstChild( node2, &node3 );
1752     ok( r == S_OK, "ret %08x\n", r );
1753
1754     r = IXMLDOMNode_get_text( node3, &str );
1755     ok( r == S_OK, "ret %08x\n", r );
1756     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
1757     SysFreeString(str);
1758
1759
1760     IXMLDOMNode_Release( node3 );
1761     IXMLDOMNode_Release( node2 );
1762     IXMLDOMNamedNodeMap_Release( node_map );
1763     IXMLDOMNode_Release( node );
1764     IXMLDOMDocument_Release( doc );
1765 }
1766
1767 static void test_get_childNodes(void)
1768 {
1769     HRESULT r;
1770     BSTR str;
1771     VARIANT_BOOL b;
1772     IXMLDOMDocument *doc;
1773     IXMLDOMElement *element;
1774     IXMLDOMNode *node, *node2;
1775     IXMLDOMNodeList *node_list, *node_list2;
1776     long len;
1777
1778     r = CoCreateInstance( &CLSID_DOMDocument, NULL, 
1779         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1780     if( r != S_OK )
1781         return;
1782
1783     str = SysAllocString( szComplete4 );
1784     r = IXMLDOMDocument_loadXML( doc, str, &b );
1785     ok( r == S_OK, "loadXML failed\n");
1786     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1787     SysFreeString( str );
1788
1789     r = IXMLDOMDocument_get_documentElement( doc, &element );
1790     ok( r == S_OK, "ret %08x\n", r);
1791
1792     r = IXMLDOMElement_get_childNodes( element, &node_list );
1793     ok( r == S_OK, "ret %08x\n", r);
1794
1795     r = IXMLDOMNodeList_get_length( node_list, &len );
1796     ok( r == S_OK, "ret %08x\n", r);
1797     ok( len == 4, "len %ld\n", len);
1798
1799     r = IXMLDOMNodeList_get_item( node_list, 2, &node );
1800     ok( r == S_OK, "ret %08x\n", r);
1801
1802     r = IXMLDOMNode_get_childNodes( node, &node_list2 );
1803     ok( r == S_OK, "ret %08x\n", r);
1804
1805     r = IXMLDOMNodeList_get_length( node_list2, &len );
1806     ok( r == S_OK, "ret %08x\n", r);
1807     ok( len == 0, "len %ld\n", len);
1808
1809     r = IXMLDOMNodeList_get_item( node_list2, 0, &node2);
1810     ok( r == S_FALSE, "ret %08x\n", r);
1811
1812     IXMLDOMNodeList_Release( node_list2 );
1813     IXMLDOMNode_Release( node );
1814     IXMLDOMNodeList_Release( node_list );
1815     IXMLDOMElement_Release( element );
1816     IXMLDOMDocument_Release( doc );
1817 }
1818
1819 static void test_removeChild(void)
1820 {
1821     HRESULT r;
1822     BSTR str;
1823     VARIANT_BOOL b;
1824     IXMLDOMDocument *doc;
1825     IXMLDOMElement *element, *lc_element;
1826     IXMLDOMNode *fo_node, *ba_node, *removed_node, *temp_node, *lc_node;
1827     IXMLDOMNodeList *root_list, *fo_list;
1828
1829     r = CoCreateInstance( &CLSID_DOMDocument, NULL, 
1830         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1831     if( r != S_OK )
1832         return;
1833
1834     str = SysAllocString( szComplete4 );
1835     r = IXMLDOMDocument_loadXML( doc, str, &b );
1836     ok( r == S_OK, "loadXML failed\n");
1837     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1838     SysFreeString( str );
1839
1840     r = IXMLDOMDocument_get_documentElement( doc, &element );
1841     ok( r == S_OK, "ret %08x\n", r);
1842
1843     r = IXMLDOMElement_get_childNodes( element, &root_list );
1844     ok( r == S_OK, "ret %08x\n", r);
1845
1846     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
1847     ok( r == S_OK, "ret %08x\n", r);
1848  
1849     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
1850     ok( r == S_OK, "ret %08x\n", r);
1851  
1852     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
1853     ok( r == S_OK, "ret %08x\n", r);
1854
1855     /* invalid parameter: NULL ptr */
1856     removed_node = (void*)0xdeadbeef;
1857     r = IXMLDOMElement_removeChild( element, NULL, &removed_node );
1858     ok( r == E_INVALIDARG, "ret %08x\n", r );
1859     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
1860
1861     /* ba_node is a descendant of element, but not a direct child. */
1862     removed_node = (void*)0xdeadbeef;
1863     r = IXMLDOMElement_removeChild( element, ba_node, &removed_node );
1864     ok( r == E_INVALIDARG, "ret %08x\n", r );
1865     ok( removed_node == NULL, "%p\n", removed_node );
1866
1867     r = IXMLDOMElement_removeChild( element, fo_node, &removed_node );
1868     ok( r == S_OK, "ret %08x\n", r);
1869     ok( fo_node == removed_node, "node %p node2 %p\n", fo_node, removed_node );
1870
1871     /* try removing already removed child */
1872     temp_node = (void*)0xdeadbeef;
1873     r = IXMLDOMElement_removeChild( element, fo_node, &temp_node );
1874     ok( r == E_INVALIDARG, "ret %08x\n", r);
1875     ok( temp_node == NULL, "%p\n", temp_node );
1876
1877     /* the removed node has no parent anymore */
1878     r = IXMLDOMNode_get_parentNode( removed_node, &temp_node );
1879     ok( r == S_FALSE, "ret %08x\n", r);
1880     ok( temp_node == NULL, "%p\n", temp_node );
1881
1882     IXMLDOMNode_Release( removed_node );
1883     IXMLDOMNode_Release( ba_node );
1884     IXMLDOMNodeList_Release( fo_list );
1885
1886     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
1887     ok( r == S_OK, "ret %08x\n", r);
1888
1889     r = IXMLDOMElement_QueryInterface( lc_node, &IID_IXMLDOMElement, (LPVOID*)&lc_element );
1890     ok( r == S_OK, "ret %08x\n", r);
1891
1892     /* MS quirk: passing wrong interface pointer works, too */
1893     r = IXMLDOMElement_removeChild( element, (IXMLDOMNode*)lc_element, NULL );
1894     ok( r == S_OK, "ret %08x\n", r);
1895
1896     r = IXMLDOMNode_get_parentNode( lc_node, &temp_node );
1897     ok( r == S_FALSE, "ret %08x\n", r);
1898     ok( temp_node == NULL, "%p\n", temp_node );
1899
1900     IXMLDOMNode_Release( lc_node );
1901     IXMLDOMNodeList_Release( root_list );
1902     IXMLDOMElement_Release( element );
1903     IXMLDOMDocument_Release( doc );
1904 }
1905
1906 static void test_replaceChild(void)
1907 {
1908     HRESULT r;
1909     BSTR str;
1910     VARIANT_BOOL b;
1911     IXMLDOMDocument *doc;
1912     IXMLDOMElement *element, *ba_element;
1913     IXMLDOMNode *fo_node, *ba_node, *lc_node, *removed_node, *temp_node;
1914     IXMLDOMNodeList *root_list, *fo_list;
1915     IUnknown * unk1, *unk2;
1916     long len;
1917
1918     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1919         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1920     if( r != S_OK )
1921         return;
1922
1923     str = SysAllocString( szComplete4 );
1924     r = IXMLDOMDocument_loadXML( doc, str, &b );
1925     ok( r == S_OK, "loadXML failed\n");
1926     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1927     SysFreeString( str );
1928
1929     r = IXMLDOMDocument_get_documentElement( doc, &element );
1930     ok( r == S_OK, "ret %08x\n", r);
1931
1932     r = IXMLDOMElement_get_childNodes( element, &root_list );
1933     ok( r == S_OK, "ret %08x\n", r);
1934
1935     r = IXMLDOMNodeList_get_item( root_list, 0, &lc_node );
1936     ok( r == S_OK, "ret %08x\n", r);
1937
1938     r = IXMLDOMNodeList_get_item( root_list, 3, &fo_node );
1939     ok( r == S_OK, "ret %08x\n", r);
1940
1941     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
1942     ok( r == S_OK, "ret %08x\n", r);
1943
1944     r = IXMLDOMNodeList_get_item( fo_list, 0, &ba_node );
1945     ok( r == S_OK, "ret %08x\n", r);
1946
1947     IXMLDOMNodeList_Release( fo_list );
1948
1949     /* invalid parameter: NULL ptr for element to remove */
1950     removed_node = (void*)0xdeadbeef;
1951     r = IXMLDOMElement_replaceChild( element, ba_node, NULL, &removed_node );
1952     ok( r == E_INVALIDARG, "ret %08x\n", r );
1953     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
1954
1955     /* invalid parameter: NULL for replacement element. (Sic!) */
1956     removed_node = (void*)0xdeadbeef;
1957     r = IXMLDOMElement_replaceChild( element, NULL, fo_node, &removed_node );
1958     ok( r == E_INVALIDARG, "ret %08x\n", r );
1959     ok( removed_node == (void*)0xdeadbeef, "%p\n", removed_node );
1960
1961     /* invalid parameter: OldNode is not a child */
1962     removed_node = (void*)0xdeadbeef;
1963     r = IXMLDOMElement_replaceChild( element, lc_node, ba_node, &removed_node );
1964     ok( r == E_INVALIDARG, "ret %08x\n", r );
1965     ok( removed_node == NULL, "%p\n", removed_node );
1966
1967     /* invalid parameter: would create loop */
1968     removed_node = (void*)0xdeadbeef;
1969     r = IXMLDOMNode_replaceChild( fo_node, fo_node, ba_node, &removed_node );
1970     ok( r == E_FAIL, "ret %08x\n", r );
1971     ok( removed_node == NULL, "%p\n", removed_node );
1972
1973     r = IXMLDOMElement_replaceChild( element, ba_node, fo_node, NULL );
1974     ok( r == S_OK, "ret %08x\n", r );
1975
1976     r = IXMLDOMNodeList_get_item( root_list, 3, &temp_node );
1977     ok( r == S_OK, "ret %08x\n", r );
1978
1979     /* ba_node and temp_node refer to the same node, yet they
1980        are different interface pointers */
1981     ok( ba_node != temp_node, "ba_node %p temp_node %p\n", ba_node, temp_node);
1982     r = IXMLDOMNode_QueryInterface( temp_node, &IID_IUnknown, (void**)&unk1);
1983     ok( r == S_OK, "ret %08x\n", r );
1984     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IUnknown, (void**)&unk2);
1985     ok( r == S_OK, "ret %08x\n", r );
1986     todo_wine ok( unk1 == unk2, "unk1 %p unk2 %p\n", unk1, unk2);
1987
1988     IUnknown_Release( unk1 );
1989     IUnknown_Release( unk2 );
1990
1991     /* ba_node should have been removed from below fo_node */
1992     r = IXMLDOMNode_get_childNodes( fo_node, &fo_list );
1993     ok( r == S_OK, "ret %08x\n", r );
1994
1995     /* MS quirk: replaceChild also accepts elements instead of nodes */
1996     r = IXMLDOMNode_QueryInterface( ba_node, &IID_IXMLDOMElement, (void**)&ba_element);
1997     ok( r == S_OK, "ret %08x\n", r );
1998
1999     r = IXMLDOMElement_replaceChild( element, ba_node, (IXMLDOMNode*)ba_element, &removed_node );
2000     ok( r == S_OK, "ret %08x\n", r );
2001
2002     r = IXMLDOMNodeList_get_length( fo_list, &len);
2003     ok( r == S_OK, "ret %08x\n", r );
2004     ok( len == 0, "len %ld\n", len);
2005
2006     IXMLDOMNodeList_Release( fo_list );
2007
2008     IXMLDOMNode_Release(ba_node);
2009     IXMLDOMNode_Release(fo_node);
2010     IXMLDOMNode_Release(temp_node);
2011     IXMLDOMNodeList_Release( root_list );
2012     IXMLDOMElement_Release( element );
2013     IXMLDOMDocument_Release( doc );
2014 }
2015
2016 static void test_removeNamedItem(void)
2017 {
2018     IXMLDOMDocument *doc;
2019     IXMLDOMElement *element;
2020     IXMLDOMNode *pr_node, *removed_node, *removed_node2;
2021     IXMLDOMNodeList *root_list;
2022     IXMLDOMNamedNodeMap * pr_attrs;
2023     VARIANT_BOOL b;
2024     BSTR str;
2025     long len;
2026     HRESULT r;
2027
2028     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
2029         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
2030     if( r != S_OK )
2031         return;
2032
2033     str = SysAllocString( szComplete4 );
2034     r = IXMLDOMDocument_loadXML( doc, str, &b );
2035     ok( r == S_OK, "loadXML failed\n");
2036     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2037     SysFreeString( str );
2038
2039     r = IXMLDOMDocument_get_documentElement( doc, &element );
2040     ok( r == S_OK, "ret %08x\n", r);
2041
2042     r = IXMLDOMElement_get_childNodes( element, &root_list );
2043     ok( r == S_OK, "ret %08x\n", r);
2044
2045     r = IXMLDOMNodeList_get_item( root_list, 1, &pr_node );
2046     ok( r == S_OK, "ret %08x\n", r);
2047
2048     r = IXMLDOMNode_get_attributes( pr_node, &pr_attrs );
2049     ok( r == S_OK, "ret %08x\n", r);
2050
2051     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
2052     ok( r == S_OK, "ret %08x\n", r);
2053     ok( len == 3, "length %ld\n", len);
2054
2055     removed_node = (void*)0xdeadbeef;
2056     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, NULL, &removed_node);
2057     ok ( r == E_INVALIDARG, "ret %08x\n", r);
2058     ok ( removed_node == (void*)0xdeadbeef, "removed_node == %p\n", removed_node);
2059
2060     removed_node = (void*)0xdeadbeef;
2061     str = SysAllocString(szvr);
2062     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node);
2063     ok ( r == S_OK, "ret %08x\n", r);
2064
2065     removed_node2 = (void*)0xdeadbeef;
2066     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, &removed_node2);
2067     ok ( r == S_FALSE, "ret %08x\n", r);
2068     ok ( removed_node2 == NULL, "removed_node == %p\n", removed_node2 );
2069
2070     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
2071     ok( r == S_OK, "ret %08x\n", r);
2072     ok( len == 2, "length %ld\n", len);
2073
2074     r = IXMLDOMNamedNodeMap_setNamedItem( pr_attrs, removed_node, NULL);
2075     ok ( r == S_OK, "ret %08x\n", r);
2076     IXMLDOMNode_Release(removed_node);
2077
2078     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
2079     ok( r == S_OK, "ret %08x\n", r);
2080     ok( len == 3, "length %ld\n", len);
2081
2082     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
2083     ok ( r == S_OK, "ret %08x\n", r);
2084
2085     r = IXMLDOMNamedNodeMap_get_length( pr_attrs, &len );
2086     ok( r == S_OK, "ret %08x\n", r);
2087     ok( len == 2, "length %ld\n", len);
2088
2089     r = IXMLDOMNamedNodeMap_removeNamedItem( pr_attrs, str, NULL);
2090     ok ( r == S_FALSE, "ret %08x\n", r);
2091
2092     SysFreeString(str);
2093
2094     IXMLDOMNamedNodeMap_Release( pr_attrs );
2095     IXMLDOMNode_Release( pr_node );
2096     IXMLDOMNodeList_Release( root_list );
2097     IXMLDOMElement_Release( element );
2098     IXMLDOMDocument_Release( doc );
2099 }
2100
2101 static void test_XMLHTTP(void)
2102 {
2103     static const WCHAR wszBody[] = {'m','o','d','e','=','T','e','s','t',0};
2104     static WCHAR wszPOST[] = {'P','O','S','T',0};
2105     static WCHAR wszUrl[] = {'h','t','t','p',':','/','/',
2106         'c','r','o','s','s','o','v','e','r','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m','/',
2107         'p','o','s','t','t','e','s','t','.','p','h','p',0};
2108     static const WCHAR wszExpectedResponse[] = {'F','A','I','L','E','D',0};
2109     IXMLHttpRequest *pXMLHttpRequest;
2110     BSTR bstrResponse;
2111     VARIANT dummy;
2112     VARIANT varfalse;
2113     VARIANT varbody;
2114     HRESULT hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL,
2115                                   CLSCTX_INPROC_SERVER, &IID_IXMLHttpRequest,
2116                                   (void **)&pXMLHttpRequest);
2117     ok(hr == S_OK, "CoCreateInstance(CLSID_XMLHTTPRequest) should have succeeded instead of failing with 0x%08x\n", hr);
2118     if (hr != S_OK)
2119         return;
2120
2121     VariantInit(&dummy);
2122     V_VT(&dummy) = VT_ERROR;
2123     V_ERROR(&dummy) = DISP_E_MEMBERNOTFOUND;
2124     VariantInit(&varfalse);
2125     V_VT(&varfalse) = VT_BOOL;
2126     V_BOOL(&varfalse) = VARIANT_FALSE;
2127     V_VT(&varbody) = VT_BSTR;
2128     V_BSTR(&varbody) = SysAllocString(wszBody);
2129
2130     hr = IXMLHttpRequest_open(pXMLHttpRequest, wszPOST, wszUrl, varfalse, dummy, dummy);
2131     todo_wine ok(hr == S_OK, "IXMLHttpRequest_open should have succeeded instead of failing with 0x%08x\n", hr);
2132
2133     hr = IXMLHttpRequest_send(pXMLHttpRequest, varbody);
2134     todo_wine ok(hr == S_OK, "IXMLHttpRequest_send should have succeeded instead of failing with 0x%08x\n", hr);
2135     VariantClear(&varbody);
2136
2137     hr = IXMLHttpRequest_get_responseText(pXMLHttpRequest, &bstrResponse);
2138     todo_wine ok(hr == S_OK, "IXMLHttpRequest_get_responseText should have succeeded instead of failing with 0x%08x\n", hr);
2139     /* the server currently returns "FAILED" because the Content-Type header is
2140      * not what the server expects */
2141     if(hr == S_OK)
2142     {
2143         ok(!memcmp(bstrResponse, wszExpectedResponse, sizeof(wszExpectedResponse)), "bstrResponse differs from what was expected\n");
2144         SysFreeString(bstrResponse);
2145     }
2146
2147     IXMLHttpRequest_Release(pXMLHttpRequest);
2148 }
2149
2150 static void test_IXMLDOMDocument2(void)
2151 {
2152     HRESULT r;
2153     VARIANT_BOOL b;
2154     BSTR str;
2155     IXMLDOMDocument *doc;
2156     IXMLDOMDocument2 *doc2;
2157     IDispatchEx *dispex;
2158     VARIANT var;
2159     int ref;
2160
2161     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
2162         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
2163     if( r != S_OK )
2164         return;
2165
2166     str = SysAllocString( szComplete4 );
2167     r = IXMLDOMDocument_loadXML( doc, str, &b );
2168     ok( r == S_OK, "loadXML failed\n");
2169     ok( b == VARIANT_TRUE, "failed to load XML string\n");
2170     SysFreeString( str );
2171
2172     r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
2173     ok( r == S_OK, "ret %08x\n", r );
2174     ok( doc == (IXMLDOMDocument*)doc2, "interfaces differ\n");
2175
2176     r = IXMLDOMDocument_QueryInterface( doc, &IID_IDispatchEx, (void**)&dispex );
2177     ok( r == S_OK, "ret %08x\n", r );
2178     if(r == S_OK)
2179     {
2180         IDispatchEx_Release(dispex);
2181     }
2182
2183     /* we will check if the variant got cleared */
2184     ref = IXMLDOMDocument2_AddRef(doc2);
2185     expect_eq(ref, 3, int, "%d");  /* doc, doc2, AddRef*/
2186     V_VT(&var) = VT_UNKNOWN;
2187     V_UNKNOWN(&var) = (IUnknown *)doc2;
2188
2189     /* invalid calls */
2190     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("askldhfaklsdf"), &var), E_FAIL);
2191     expect_eq(V_VT(&var), VT_UNKNOWN, int, "%x");
2192     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), NULL), E_INVALIDARG);
2193
2194     /* valid call */
2195     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
2196     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
2197     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
2198     V_VT(&var) = VT_R4;
2199
2200     /* the variant didn't get cleared*/
2201     expect_eq(IXMLDOMDocument2_Release(doc2), 2, int, "%d");
2202
2203     /* setProperty tests */
2204     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("askldhfaklsdf"), var), E_FAIL);
2205     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), var), E_FAIL);
2206     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("alskjdh faklsjd hfk")), E_FAIL);
2207     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
2208     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
2209     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
2210
2211     /* contrary to what MSDN claims you can switch back from XPath to XSLPattern */
2212     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
2213     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
2214     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
2215
2216     IXMLDOMDocument2_Release( doc2 );
2217     IXMLDOMDocument_Release( doc );
2218     free_bstrs();
2219 }
2220
2221 static void test_XPath(void)
2222 {
2223     HRESULT r;
2224     VARIANT var;
2225     VARIANT_BOOL b;
2226     IXMLDOMDocument2 *doc;
2227     IXMLDOMNode *rootNode;
2228     IXMLDOMNode *elem1Node;
2229     IXMLDOMNode *node;
2230     IXMLDOMNodeList *list;
2231
2232     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
2233         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
2234     if( r != S_OK )
2235         return;
2236
2237     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b));
2238     ok(b == VARIANT_TRUE, "failed to load XML string\n");
2239
2240     /* switch to XPath */
2241     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
2242
2243     /* some simple queries*/
2244     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root"), &list));
2245     ole_check(IXMLDOMNodeList_get_item(list, 0, &rootNode));
2246     ole_check(IXMLDOMNodeList_reset(list));
2247     expect_list_and_release(list, "E2.D1");
2248     if (rootNode == NULL)
2249         return;
2250
2251     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//c"), &list));
2252     expect_list_and_release(list, "E3.E1.E2.D1 E3.E2.E2.D1");
2253
2254     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("//c[@type]"), &list));
2255     expect_list_and_release(list, "E3.E2.E2.D1");
2256
2257     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem"), &list));
2258     /* using get_item for query results advances the position */
2259     ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
2260     expect_node(node, "E2.E2.D1");
2261     IXMLDOMNode_Release(node);
2262     ole_check(IXMLDOMNodeList_nextNode(list, &node));
2263     expect_node(node, "E4.E2.D1");
2264     IXMLDOMNode_Release(node);
2265     ole_check(IXMLDOMNodeList_reset(list));
2266     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E4.E2.D1");
2267
2268     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("."), &list));
2269     expect_list_and_release(list, "E2.D1");
2270
2271     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem[3]/preceding-sibling::*"), &list));
2272     ole_check(IXMLDOMNodeList_get_item(list, 0, &elem1Node));
2273     ole_check(IXMLDOMNodeList_reset(list));
2274     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
2275
2276     /* select an attribute */
2277     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//@type"), &list));
2278     expect_list_and_release(list, "A'type'.E3.E2.E2.D1");
2279
2280     /* would evaluate to a number */
2281     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("count(*)"), &list), E_FAIL);
2282     /* would evaluate to a boolean */
2283     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("position()>0"), &list), E_FAIL);
2284     /* would evaluate to a string */
2285     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("name()"), &list), E_FAIL);
2286
2287     /* no results */
2288     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("c"), &list));
2289     expect_list_and_release(list, "");
2290     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("elem//c"), &list));
2291     expect_list_and_release(list, "");
2292     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("//elem[4]"), &list));
2293     expect_list_and_release(list, "");
2294
2295     /* foo undeclared in document node */
2296     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
2297     /* undeclared in <root> node */
2298     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//foo:c"), &list), E_FAIL);
2299     /* undeclared in <elem> node */
2300     ole_expect(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//foo:c"), &list), E_FAIL);
2301     /* but this trick can be used */
2302     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//*[name()='foo:c']"), &list));
2303     expect_list_and_release(list, "E3.E4.E2.D1");
2304
2305     /* it has to be declared in SelectionNamespaces */
2306     todo_wine ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
2307         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
2308
2309     /* now the namespace can be used */
2310     todo_wine ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//test:c"), &list));
2311     todo_wine expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
2312     todo_wine ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//test:c"), &list));
2313     todo_wine expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
2314     todo_wine ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//test:c"), &list));
2315     todo_wine expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
2316     todo_wine ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_(".//test:x"), &list));
2317     todo_wine expect_list_and_release(list, "E5.E1.E4.E1.E2.D1");
2318
2319     /* SelectionNamespaces syntax error - the namespaces doesn't work anymore but the value is stored */
2320     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
2321         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###")), E_FAIL);
2322
2323     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
2324
2325     VariantInit(&var);
2326     todo_wine ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
2327     todo_wine expect_eq(V_VT(&var), VT_BSTR, int, "%x");
2328     if (V_VT(&var) == VT_BSTR)
2329         expect_bstr_eq_and_free(V_BSTR(&var), "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###");
2330
2331     /* extra attributes - same thing*/
2332     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
2333         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' param='test'")), E_FAIL);
2334     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
2335
2336     IXMLDOMNode_Release(rootNode);
2337     IXMLDOMNode_Release(elem1Node);
2338     IXMLDOMDocument_Release(doc);
2339     free_bstrs();
2340 }
2341
2342 static void test_cloneNode(void )
2343 {
2344     IXMLDOMDocument *doc = NULL;
2345     VARIANT_BOOL b;
2346     IXMLDOMNodeList *pList;
2347     IXMLDOMNamedNodeMap *mapAttr;
2348     long nLength = 0, nLength1 = 0;
2349     long nAttrCnt = 0, nAttrCnt1 = 0;
2350     IXMLDOMNode *node;
2351     IXMLDOMNode *node_clone;
2352     HRESULT r;
2353     BSTR str;
2354     static const WCHAR szSearch[] = { 'l', 'c', '/', 'p', 'r', 0 };
2355
2356     r = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
2357     if( r != S_OK )
2358         return;
2359
2360     str = SysAllocString( szComplete4 );
2361     ole_check(IXMLDOMDocument_loadXML(doc, str, &b));
2362     ok(b == VARIANT_TRUE, "failed to load XML string\n");
2363     SysFreeString(str);
2364
2365     if(!b)
2366         return;
2367
2368     str = SysAllocString( szSearch);
2369     r = IXMLDOMNode_selectSingleNode(doc, str, &node);
2370     ok( r == S_OK, "ret %08x\n", r );
2371     ok( node != NULL, "node %p\n", node );
2372     SysFreeString(str);
2373
2374     if(!node)
2375     {
2376         IXMLDOMDocument_Release(doc);
2377         return;
2378     }
2379
2380     /* Check invalid parameter */
2381     r = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, NULL);
2382     ok( r == E_INVALIDARG, "ret %08x\n", r );
2383
2384     /* All Children */
2385     r = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, &node_clone);
2386     ok( r == S_OK, "ret %08x\n", r );
2387     ok( node_clone != NULL, "node %p\n", node );
2388
2389     if(!node_clone)
2390     {
2391         IXMLDOMDocument_Release(doc);
2392         IXMLDOMNode_Release(node);
2393         return;
2394     }
2395
2396     r = IXMLDOMNode_get_childNodes(node, &pList);
2397     ok( r == S_OK, "ret %08x\n", r );
2398     if (pList)
2399         {
2400                 IXMLDOMNodeList_get_length(pList, &nLength);
2401                 IXMLDOMNodeList_Release(pList);
2402         }
2403
2404     r = IXMLDOMNode_get_attributes(node, &mapAttr);
2405     ok( r == S_OK, "ret %08x\n", r );
2406     if(mapAttr)
2407     {
2408         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt);
2409         IXMLDOMNamedNodeMap_Release(mapAttr);
2410     }
2411
2412     r = IXMLDOMNode_get_childNodes(node_clone, &pList);
2413     ok( r == S_OK, "ret %08x\n", r );
2414     if (pList)
2415         {
2416                 IXMLDOMNodeList_get_length(pList, &nLength1);
2417                 IXMLDOMNodeList_Release(pList);
2418         }
2419
2420     r = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
2421     ok( r == S_OK, "ret %08x\n", r );
2422     if(mapAttr)
2423     {
2424         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt1);
2425         IXMLDOMNamedNodeMap_Release(mapAttr);
2426     }
2427
2428     ok(nLength == nLength1, "wrong Child count (%ld, %ld)\n", nLength, nLength1);
2429     ok(nAttrCnt == nAttrCnt1, "wrong Attribute count (%ld, %ld)\n", nAttrCnt, nAttrCnt1);
2430     IXMLDOMNode_Release(node_clone);
2431
2432     /* No Children */
2433     r = IXMLDOMNode_cloneNode(node, VARIANT_FALSE, &node_clone);
2434     ok( r == S_OK, "ret %08x\n", r );
2435     ok( node_clone != NULL, "node %p\n", node );
2436
2437     if(!node_clone)
2438     {
2439         IXMLDOMDocument_Release(doc);
2440         IXMLDOMNode_Release(node);
2441         return;
2442     }
2443
2444     r = IXMLDOMNode_get_childNodes(node_clone, &pList);
2445     ok( r == S_OK, "ret %08x\n", r );
2446     if (pList)
2447         {
2448                 IXMLDOMNodeList_get_length(pList, &nLength1);
2449         ok( nLength1 == 0, "Length should be 0 (%ld)\n", nLength1);
2450                 IXMLDOMNodeList_Release(pList);
2451         }
2452
2453     r = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
2454     ok( r == S_OK, "ret %08x\n", r );
2455     if(mapAttr)
2456     {
2457         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt1);
2458         ok( nAttrCnt1 == 3, "Attribute count should be 3 (%ld)\n", nAttrCnt1);
2459         IXMLDOMNamedNodeMap_Release(mapAttr);
2460     }
2461
2462     ok(nLength != nLength1, "wrong Child count (%ld, %ld)\n", nLength, nLength1);
2463     ok(nAttrCnt == nAttrCnt1, "wrong Attribute count (%ld, %ld)\n", nAttrCnt, nAttrCnt1);
2464     IXMLDOMNode_Release(node_clone);
2465
2466
2467     IXMLDOMNode_Release(node);
2468     IXMLDOMDocument_Release(doc);
2469 }
2470
2471 static void test_xmlTypes(void)
2472 {
2473     IXMLDOMDocument *doc = NULL;
2474     IXMLDOMElement *pRoot;
2475     HRESULT hr;
2476     IXMLDOMComment *pComment;
2477     IXMLDOMElement *pElement;
2478     IXMLDOMAttribute *pAttrubute;
2479     IXMLDOMNamedNodeMap *pAttribs;
2480     IXMLDOMCDATASection *pCDataSec;
2481     IXMLDOMImplementation *pIXMLDOMImplementation = NULL;
2482     IXMLDOMDocumentFragment *pDocFrag = NULL;
2483     IXMLDOMEntityReference *pEntityRef = NULL;
2484     BSTR str;
2485     IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;   /* Used for testing Siblings */
2486     VARIANT v;
2487     long len = 0;
2488
2489     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
2490     if( hr != S_OK )
2491         return;
2492
2493     hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
2494     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2495
2496     hr = IXMLDOMDocument_get_nextSibling(doc, &pNextChild);
2497     ok(hr == S_FALSE, "ret %08x\n", hr );
2498     ok(pNextChild == NULL, "pDocChild not NULL\n");
2499
2500     /* test previous Sibling */
2501     hr = IXMLDOMDocument_get_previousSibling(doc, NULL);
2502     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2503
2504     pNextChild = (IXMLDOMNode *)0x1;
2505     hr = IXMLDOMDocument_get_previousSibling(doc, &pNextChild);
2506     ok(hr == S_FALSE, "ret %08x\n", hr );
2507     ok(pNextChild == NULL, "pNextChild not NULL\n");
2508
2509     /* test get_attributes */
2510     hr = IXMLDOMDocument_get_attributes( doc, NULL );
2511     ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
2512
2513     pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2514     hr = IXMLDOMDocument_get_attributes( doc, &pAttribs);
2515     ok(hr == S_FALSE, "ret %08x\n", hr );
2516     ok( pAttribs == NULL, "pAttribs not NULL\n");
2517
2518     /* test get_dataType */
2519     hr = IXMLDOMDocument_get_dataType(doc, &v);
2520     ok(hr == S_FALSE, "ret %08x\n", hr );
2521     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2522     VariantClear(&v);
2523
2524     /* test nodeTypeString */
2525     hr = IXMLDOMDocument_get_nodeTypeString(doc, &str);
2526     ok(hr == S_OK, "ret %08x\n", hr );
2527     ok( !lstrcmpW( str, _bstr_("document") ), "incorrect nodeTypeString string\n");
2528     SysFreeString(str);
2529
2530     /* test implementation */
2531     hr = IXMLDOMDocument_get_implementation(doc, NULL);
2532     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2533
2534     hr = IXMLDOMDocument_get_implementation(doc, &pIXMLDOMImplementation);
2535     ok(hr == S_OK, "ret %08x\n", hr );
2536     if(hr == S_OK)
2537     {
2538         VARIANT_BOOL hasFeature = VARIANT_TRUE;
2539         BSTR sEmpty = SysAllocStringLen(NULL, 0);
2540
2541         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, NULL, sEmpty, &hasFeature);
2542         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2543
2544         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, NULL);
2545         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2546
2547         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
2548         ok(hr == S_OK, "ret %08x\n", hr );
2549         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
2550
2551         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, &hasFeature);
2552         ok(hr == S_OK, "ret %08x\n", hr );
2553         ok(hasFeature == VARIANT_FALSE, "hasFeature returned true\n");
2554
2555         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), NULL, &hasFeature);
2556         ok(hr == S_OK, "ret %08x\n", hr );
2557         ok(hasFeature == VARIANT_TRUE, "hasFeature returned false\n");
2558
2559         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
2560         ok(hr == S_OK, "ret %08x\n", hr );
2561         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
2562
2563         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), _bstr_("1.0"), &hasFeature);
2564         ok(hr == S_OK, "ret %08x\n", hr );
2565         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
2566
2567         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("XML"), _bstr_("1.0"), &hasFeature);
2568         ok(hr == S_OK, "ret %08x\n", hr );
2569         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
2570
2571         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("MS-DOM"), _bstr_("1.0"), &hasFeature);
2572         ok(hr == S_OK, "ret %08x\n", hr );
2573         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
2574
2575         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("SSS"), NULL, &hasFeature);
2576         ok(hr == S_OK, "ret %08x\n", hr );
2577         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
2578
2579         SysFreeString(sEmpty);
2580         IXMLDOMImplementation_Release(pIXMLDOMImplementation);
2581     }
2582
2583
2584
2585     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
2586     ok(hr == S_OK, "ret %08x\n", hr );
2587     if(hr == S_OK)
2588     {
2589         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
2590         ok(hr == S_OK, "ret %08x\n", hr );
2591         if(hr == S_OK)
2592         {
2593             /* Comment */
2594             hr = IXMLDOMDocument_createComment(doc, szComment, &pComment);
2595             ok(hr == S_OK, "ret %08x\n", hr );
2596             if(hr == S_OK)
2597             {
2598                 /* test get_attributes */
2599                 hr = IXMLDOMComment_get_attributes( pComment, NULL );
2600                 ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
2601
2602                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2603                 hr = IXMLDOMComment_get_attributes( pComment, &pAttribs);
2604                 ok(hr == S_FALSE, "ret %08x\n", hr );
2605                 ok( pAttribs == NULL, "pAttribs not NULL\n");
2606
2607                 /* test nodeTypeString */
2608                 hr = IXMLDOMComment_get_nodeTypeString(pComment, &str);
2609                 ok(hr == S_OK, "ret %08x\n", hr );
2610                 ok( !lstrcmpW( str, _bstr_("comment") ), "incorrect nodeTypeString string\n");
2611                 SysFreeString(str);
2612
2613                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pComment, NULL);
2614                 ok(hr == S_OK, "ret %08x\n", hr );
2615
2616                 hr = IXMLDOMComment_get_nodeName(pComment, &str);
2617                 ok(hr == S_OK, "ret %08x\n", hr );
2618                 ok( !lstrcmpW( str, szCommentNodeText ), "incorrect comment node Name\n");
2619                 SysFreeString(str);
2620
2621                 hr = IXMLDOMComment_get_xml(pComment, &str);
2622                 ok(hr == S_OK, "ret %08x\n", hr );
2623                 ok( !lstrcmpW( str, szCommentXML ), "incorrect comment xml\n");
2624                 SysFreeString(str);
2625
2626                 hr = IXMLDOMComment_get_dataType(pComment, &v);
2627                 ok(hr == S_FALSE, "ret %08x\n", hr );
2628                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2629                 VariantClear(&v);
2630
2631                 /* put data Tests */
2632                 hr = IXMLDOMComment_put_data(pComment, _bstr_("This &is a ; test <>\\"));
2633                 ok(hr == S_OK, "ret %08x\n", hr );
2634
2635                 /* get data Tests */
2636                 hr = IXMLDOMComment_get_data(pComment, &str);
2637                 ok(hr == S_OK, "ret %08x\n", hr );
2638                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect get_data string\n");
2639                 SysFreeString(str);
2640
2641                 /* get data Tests */
2642                 hr = IXMLDOMComment_get_nodeValue(pComment, &v);
2643                 ok(hr == S_OK, "ret %08x\n", hr );
2644                 ok( V_VT(&v) == VT_BSTR, "incorrect dataType type\n");
2645                 ok( !lstrcmpW( V_BSTR(&v), _bstr_("This &is a ; test <>\\") ), "incorrect get_nodeValue string\n");
2646                 VariantClear(&v);
2647
2648                 /* Confirm XML text is good */
2649                 hr = IXMLDOMComment_get_xml(pComment, &str);
2650                 ok(hr == S_OK, "ret %08x\n", hr );
2651                 ok( !lstrcmpW( str, _bstr_("<!--This &is a ; test <>\\-->") ), "incorrect xml string\n");
2652                 SysFreeString(str);
2653
2654                 /* Confirm we get the put_data Text back */
2655                 hr = IXMLDOMComment_get_text(pComment, &str);
2656                 ok(hr == S_OK, "ret %08x\n", hr );
2657                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
2658                 SysFreeString(str);
2659
2660                 /* test length property */
2661                 hr = IXMLDOMComment_get_length(pComment, &len);
2662                 ok(hr == S_OK, "ret %08x\n", hr );
2663                 ok(len == 21, "expected 21 got %ld\n", len);
2664
2665                 /* test substringData */
2666                 hr = IXMLDOMComment_substringData(pComment, 0, 4, NULL);
2667                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2668
2669                 /* test substringData - Invalid offset */
2670                 str = (BSTR)&szElement;
2671                 hr = IXMLDOMComment_substringData(pComment, -1, 4, &str);
2672                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2673                 ok( str == NULL, "incorrect string\n");
2674
2675                 /* test substringData - Invalid offset */
2676                 str = (BSTR)&szElement;
2677                 hr = IXMLDOMComment_substringData(pComment, 30, 0, &str);
2678                 ok(hr == S_FALSE, "ret %08x\n", hr );
2679                 ok( str == NULL, "incorrect string\n");
2680
2681                 /* test substringData - Invalid size */
2682                 str = (BSTR)&szElement;
2683                 hr = IXMLDOMComment_substringData(pComment, 0, -1, &str);
2684                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2685                 ok( str == NULL, "incorrect string\n");
2686
2687                 /* test substringData - Invalid size */
2688                 str = (BSTR)&szElement;
2689                 hr = IXMLDOMComment_substringData(pComment, 2, 0, &str);
2690                 ok(hr == S_FALSE, "ret %08x\n", hr );
2691                 ok( str == NULL, "incorrect string\n");
2692
2693                 /* test substringData - Start of string */
2694                 hr = IXMLDOMComment_substringData(pComment, 0, 4, &str);
2695                 ok(hr == S_OK, "ret %08x\n", hr );
2696                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
2697                 SysFreeString(str);
2698
2699                 /* test substringData - Middle of string */
2700                 hr = IXMLDOMComment_substringData(pComment, 13, 4, &str);
2701                 ok(hr == S_OK, "ret %08x\n", hr );
2702                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
2703                 SysFreeString(str);
2704
2705                 /* test substringData - End of string */
2706                 hr = IXMLDOMComment_substringData(pComment, 20, 4, &str);
2707                 ok(hr == S_OK, "ret %08x\n", hr );
2708                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
2709                 SysFreeString(str);
2710
2711                 /* test appendData */
2712                 hr = IXMLDOMComment_appendData(pComment, NULL);
2713                 ok(hr == S_OK, "ret %08x\n", hr );
2714
2715                 hr = IXMLDOMComment_appendData(pComment, _bstr_(""));
2716                 ok(hr == S_OK, "ret %08x\n", hr );
2717
2718                 hr = IXMLDOMComment_appendData(pComment, _bstr_("Append"));
2719                 ok(hr == S_OK, "ret %08x\n", hr );
2720
2721                 hr = IXMLDOMComment_get_text(pComment, &str);
2722                 ok(hr == S_OK, "ret %08x\n", hr );
2723                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string\n");
2724                 SysFreeString(str);
2725
2726                 /* test insertData */
2727                 str = SysAllocStringLen(NULL, 0);
2728                 hr = IXMLDOMComment_insertData(pComment, -1, str);
2729                 ok(hr == S_OK, "ret %08x\n", hr );
2730
2731                 hr = IXMLDOMComment_insertData(pComment, -1, NULL);
2732                 ok(hr == S_OK, "ret %08x\n", hr );
2733
2734                 hr = IXMLDOMComment_insertData(pComment, 1000, str);
2735                 ok(hr == S_OK, "ret %08x\n", hr );
2736
2737                 hr = IXMLDOMComment_insertData(pComment, 1000, NULL);
2738                 ok(hr == S_OK, "ret %08x\n", hr );
2739
2740                 hr = IXMLDOMComment_insertData(pComment, 0, NULL);
2741                 ok(hr == S_OK, "ret %08x\n", hr );
2742
2743                 hr = IXMLDOMComment_insertData(pComment, 0, str);
2744                 ok(hr == S_OK, "ret %08x\n", hr );
2745                 SysFreeString(str);
2746
2747                 hr = IXMLDOMComment_insertData(pComment, -1, _bstr_("Inserting"));
2748                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2749
2750                 hr = IXMLDOMComment_insertData(pComment, 1000, _bstr_("Inserting"));
2751                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2752
2753                 hr = IXMLDOMComment_insertData(pComment, 0, _bstr_("Begin "));
2754                 ok(hr == S_OK, "ret %08x\n", hr );
2755
2756                 hr = IXMLDOMComment_insertData(pComment, 17, _bstr_("Middle"));
2757                 ok(hr == S_OK, "ret %08x\n", hr );
2758
2759                 hr = IXMLDOMComment_insertData(pComment, 39, _bstr_(" End"));
2760                 ok(hr == S_OK, "ret %08x\n", hr );
2761
2762                 hr = IXMLDOMComment_get_text(pComment, &str);
2763                 ok(hr == S_OK, "ret %08x\n", hr );
2764                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string\n");
2765                 SysFreeString(str);
2766
2767                 IXMLDOMComment_Release(pComment);
2768             }
2769
2770             /* Element */
2771             hr = IXMLDOMDocument_createElement(doc, szElement, &pElement);
2772             ok(hr == S_OK, "ret %08x\n", hr );
2773             if(hr == S_OK)
2774             {
2775                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2776                 ok(hr == S_OK, "ret %08x\n", hr );
2777
2778                 /* test nodeTypeString */
2779                 hr = IXMLDOMDocument_get_nodeTypeString(pElement, &str);
2780                 ok(hr == S_OK, "ret %08x\n", hr );
2781                 ok( !lstrcmpW( str, _bstr_("element") ), "incorrect nodeTypeString string\n");
2782                 SysFreeString(str);
2783
2784                 hr = IXMLDOMElement_get_nodeName(pElement, &str);
2785                 ok(hr == S_OK, "ret %08x\n", hr );
2786                 ok( !lstrcmpW( str, szElement ), "incorrect element node Name\n");
2787                 SysFreeString(str);
2788
2789                 hr = IXMLDOMElement_get_xml(pElement, &str);
2790                 ok(hr == S_OK, "ret %08x\n", hr );
2791                 ok( !lstrcmpW( str, szElementXML ), "incorrect element xml\n");
2792                 SysFreeString(str);
2793
2794                 hr = IXMLDOMElement_get_dataType(pElement, &v);
2795                 ok(hr == S_FALSE, "ret %08x\n", hr );
2796                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2797                 VariantClear(&v);
2798
2799                  /* Attribute */
2800                 hr = IXMLDOMDocument_createAttribute(doc, szAttribute, &pAttrubute);
2801                 ok(hr == S_OK, "ret %08x\n", hr );
2802                 if(hr == S_OK)
2803                 {
2804                     IXMLDOMNode *pNewChild = (IXMLDOMNode *)0x1;
2805
2806                     hr = IXMLDOMAttribute_get_nextSibling(pAttrubute, NULL);
2807                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2808
2809                     pNextChild = (IXMLDOMNode *)0x1;
2810                     hr = IXMLDOMAttribute_get_nextSibling(pAttrubute, &pNextChild);
2811                     ok(hr == S_FALSE, "ret %08x\n", hr );
2812                     ok(pNextChild == NULL, "pNextChild not NULL\n");
2813
2814                     /* test Previous Sibling*/
2815                     hr = IXMLDOMAttribute_get_previousSibling(pAttrubute, NULL);
2816                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2817
2818                     pNextChild = (IXMLDOMNode *)0x1;
2819                     hr = IXMLDOMAttribute_get_previousSibling(pAttrubute, &pNextChild);
2820                     ok(hr == S_FALSE, "ret %08x\n", hr );
2821                     ok(pNextChild == NULL, "pNextChild not NULL\n");
2822
2823                     /* test get_attributes */
2824                     hr = IXMLDOMAttribute_get_attributes( pAttrubute, NULL );
2825                     ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
2826
2827                     pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2828                     hr = IXMLDOMAttribute_get_attributes( pAttrubute, &pAttribs);
2829                     ok(hr == S_FALSE, "ret %08x\n", hr );
2830                     ok( pAttribs == NULL, "pAttribs not NULL\n");
2831
2832                     hr = IXMLDOMElement_appendChild(pElement, (IXMLDOMNode*)pAttrubute, &pNewChild);
2833                     ok(hr == E_FAIL, "ret %08x\n", hr );
2834                     ok(pNewChild == NULL, "pNewChild not NULL\n");
2835
2836                     hr = IXMLDOMElement_get_attributes(pElement, &pAttribs);
2837                     ok(hr == S_OK, "ret %08x\n", hr );
2838                     if ( hr == S_OK )
2839                     {
2840                         hr = IXMLDOMNamedNodeMap_setNamedItem(pAttribs, (IXMLDOMNode*)pAttrubute, NULL );
2841                         ok(hr == S_OK, "ret %08x\n", hr );
2842
2843                         IXMLDOMNamedNodeMap_Release(pAttribs);
2844                     }
2845
2846                     hr = IXMLDOMAttribute_get_nodeName(pAttrubute, &str);
2847                     ok(hr == S_OK, "ret %08x\n", hr );
2848                     ok( !lstrcmpW( str, szAttribute ), "incorrect attribute node Name\n");
2849                     SysFreeString(str);
2850
2851                     /* test nodeTypeString */
2852                     hr = IXMLDOMAttribute_get_nodeTypeString(pAttrubute, &str);
2853                     ok(hr == S_OK, "ret %08x\n", hr );
2854                     ok( !lstrcmpW( str, _bstr_("attribute") ), "incorrect nodeTypeString string\n");
2855                     SysFreeString(str);
2856
2857                     /* test nodeName */
2858                     hr = IXMLDOMAttribute_get_nodeName(pAttrubute, &str);
2859                     ok(hr == S_OK, "ret %08x\n", hr );
2860                     ok( !lstrcmpW( str, szAttribute ), "incorrect nodeName string\n");
2861                     SysFreeString(str);
2862
2863                     /* test name property */
2864                     hr = IXMLDOMAttribute_get_name(pAttrubute, &str);
2865                     ok(hr == S_OK, "ret %08x\n", hr );
2866                     ok( !lstrcmpW( str, szAttribute ), "incorrect name string\n");
2867                     SysFreeString(str);
2868
2869                     hr = IXMLDOMAttribute_get_xml(pAttrubute, &str);
2870                     ok(hr == S_OK, "ret %08x\n", hr );
2871                     ok( !lstrcmpW( str, szAttributeXML ), "incorrect attribute xml\n");
2872                     SysFreeString(str);
2873
2874                     hr = IXMLDOMAttribute_get_dataType(pAttrubute, &v);
2875                     ok(hr == S_FALSE, "ret %08x\n", hr );
2876                     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2877                     VariantClear(&v);
2878
2879                     IXMLDOMAttribute_Release(pAttrubute);
2880
2881                     /* Check Element again with the Add Attribute*/
2882                     hr = IXMLDOMElement_get_xml(pElement, &str);
2883                     ok(hr == S_OK, "ret %08x\n", hr );
2884                     ok( !lstrcmpW( str, szElementXML2 ), "incorrect element xml\n");
2885                     SysFreeString(str);
2886                 }
2887
2888                 hr = IXMLDOMElement_put_text(pElement, _bstr_("TestingNode"));
2889                 ok(hr == S_OK, "ret %08x\n", hr );
2890
2891                 hr = IXMLDOMElement_get_xml(pElement, &str);
2892                 ok(hr == S_OK, "ret %08x\n", hr );
2893                 ok( !lstrcmpW( str, szElementXML3 ), "incorrect element xml\n");
2894                 SysFreeString(str);
2895
2896                 IXMLDOMElement_Release(pElement);
2897             }
2898
2899             /* CData Section */
2900             hr = IXMLDOMDocument_createCDATASection(doc, szCData, NULL);
2901             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2902
2903             hr = IXMLDOMDocument_createCDATASection(doc, szCData, &pCDataSec);
2904             ok(hr == S_OK, "ret %08x\n", hr );
2905             if(hr == S_OK)
2906             {
2907                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
2908                 VARIANT var;
2909
2910                 hr = IXMLDOMCDATASection_QueryInterface(pCDataSec, &IID_IXMLDOMElement, (LPVOID*)&pElement);
2911                 ok(hr == E_NOINTERFACE, "ret %08x\n", hr);
2912
2913                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pCDataSec, NULL);
2914                 ok(hr == S_OK, "ret %08x\n", hr );
2915
2916                 /* get Attribute Tests */
2917                 hr = IXMLDOMCDATASection_get_attributes(pCDataSec, NULL);
2918                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2919
2920                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2921                 hr = IXMLDOMCDATASection_get_attributes(pCDataSec, &pAttribs);
2922                 ok(hr == S_FALSE, "ret %08x\n", hr );
2923                 ok(pAttribs == NULL, "pAttribs != NULL\n");
2924
2925                 hr = IXMLDOMCDATASection_get_nodeName(pCDataSec, &str);
2926                 ok(hr == S_OK, "ret %08x\n", hr );
2927                 ok( !lstrcmpW( str, szCDataNodeText ), "incorrect cdata node Name\n");
2928                 SysFreeString(str);
2929
2930                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
2931                 ok(hr == S_OK, "ret %08x\n", hr );
2932                 ok( !lstrcmpW( str, szCDataXML ), "incorrect cdata xml\n");
2933                 SysFreeString(str);
2934
2935                 /* test lastChild */
2936                 pNextChild = (IXMLDOMNode*)0x1;
2937                 hr = IXMLDOMCDATASection_get_lastChild(pCDataSec, &pNextChild);
2938                 ok(hr == S_FALSE, "ret %08x\n", hr );
2939                 ok(pNextChild == NULL, "pNextChild not NULL\n");
2940
2941                 /* test get_dataType */
2942                 hr = IXMLDOMCDATASection_get_dataType(pCDataSec, NULL);
2943                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2944
2945                 hr = IXMLDOMCDATASection_get_dataType(pCDataSec, &v);
2946                 ok(hr == S_FALSE, "ret %08x\n", hr );
2947                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2948                 VariantClear(&v);
2949
2950                 /* test nodeTypeString */
2951                 hr = IXMLDOMCDATASection_get_nodeTypeString(pCDataSec, &str);
2952                 ok(hr == S_OK, "ret %08x\n", hr );
2953                 ok( !lstrcmpW( str, _bstr_("cdatasection") ), "incorrect nodeTypeString string\n");
2954                 SysFreeString(str);
2955
2956                 /* put data Tests */
2957                 hr = IXMLDOMCDATASection_put_data(pCDataSec, _bstr_("This &is a ; test <>\\"));
2958                 ok(hr == S_OK, "ret %08x\n", hr );
2959
2960                 /* Confirm XML text is good */
2961                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
2962                 ok(hr == S_OK, "ret %08x\n", hr );
2963                 ok( !lstrcmpW( str, _bstr_("<![CDATA[This &is a ; test <>\\]]>") ), "incorrect xml string\n");
2964                 SysFreeString(str);
2965
2966                 /* Confirm we get the put_data Text back */
2967                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
2968                 ok(hr == S_OK, "ret %08x\n", hr );
2969                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
2970                 SysFreeString(str);
2971
2972                 /* test length property */
2973                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
2974                 ok(hr == S_OK, "ret %08x\n", hr );
2975                 ok(len == 21, "expected 21 got %ld\n", len);
2976
2977                 /* test get nodeValue */
2978                 hr = IXMLDOMCDATASection_get_nodeValue(pCDataSec, &var);
2979                 ok(hr == S_OK, "ret %08x\n", hr );
2980                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
2981                 VariantClear(&var);
2982
2983                 /* test get data */
2984                 hr = IXMLDOMCDATASection_get_data(pCDataSec, &str);
2985                 ok(hr == S_OK, "ret %08x\n", hr );
2986                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
2987                 SysFreeString(str);
2988
2989                 /* test substringData */
2990                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, NULL);
2991                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2992
2993                 /* test substringData - Invalid offset */
2994                 str = (BSTR)&szElement;
2995                 hr = IXMLDOMCDATASection_substringData(pCDataSec, -1, 4, &str);
2996                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2997                 ok( str == NULL, "incorrect string\n");
2998
2999                 /* test substringData - Invalid offset */
3000                 str = (BSTR)&szElement;
3001                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 30, 0, &str);
3002                 ok(hr == S_FALSE, "ret %08x\n", hr );
3003                 ok( str == NULL, "incorrect string\n");
3004
3005                 /* test substringData - Invalid size */
3006                 str = (BSTR)&szElement;
3007                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, -1, &str);
3008                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3009                 ok( str == NULL, "incorrect string\n");
3010
3011                 /* test substringData - Invalid size */
3012                 str = (BSTR)&szElement;
3013                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 2, 0, &str);
3014                 ok(hr == S_FALSE, "ret %08x\n", hr );
3015                 ok( str == NULL, "incorrect string\n");
3016
3017                 /* test substringData - Start of string */
3018                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, &str);
3019                 ok(hr == S_OK, "ret %08x\n", hr );
3020                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
3021                 SysFreeString(str);
3022
3023                 /* test substringData - Middle of string */
3024                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 13, 4, &str);
3025                 ok(hr == S_OK, "ret %08x\n", hr );
3026                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
3027                 SysFreeString(str);
3028
3029                 /* test substringData - End of string */
3030                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 20, 4, &str);
3031                 ok(hr == S_OK, "ret %08x\n", hr );
3032                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
3033                 SysFreeString(str);
3034
3035                 /* test appendData */
3036                 hr = IXMLDOMCDATASection_appendData(pCDataSec, NULL);
3037                 ok(hr == S_OK, "ret %08x\n", hr );
3038
3039                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_(""));
3040                 ok(hr == S_OK, "ret %08x\n", hr );
3041
3042                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_("Append"));
3043                 ok(hr == S_OK, "ret %08x\n", hr );
3044
3045                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
3046                 ok(hr == S_OK, "ret %08x\n", hr );
3047                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string\n");
3048                 SysFreeString(str);
3049
3050                 /* test insertData */
3051                 str = SysAllocStringLen(NULL, 0);
3052                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, str);
3053                 ok(hr == S_OK, "ret %08x\n", hr );
3054
3055                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, NULL);
3056                 ok(hr == S_OK, "ret %08x\n", hr );
3057
3058                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, str);
3059                 ok(hr == S_OK, "ret %08x\n", hr );
3060
3061                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, NULL);
3062                 ok(hr == S_OK, "ret %08x\n", hr );
3063
3064                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, NULL);
3065                 ok(hr == S_OK, "ret %08x\n", hr );
3066
3067                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, str);
3068                 ok(hr == S_OK, "ret %08x\n", hr );
3069                 SysFreeString(str);
3070
3071                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, _bstr_("Inserting"));
3072                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3073
3074                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, _bstr_("Inserting"));
3075                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3076
3077                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("Begin "));
3078                 ok(hr == S_OK, "ret %08x\n", hr );
3079
3080                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 17, _bstr_("Middle"));
3081                 ok(hr == S_OK, "ret %08x\n", hr );
3082
3083                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 39, _bstr_(" End"));
3084                 ok(hr == S_OK, "ret %08x\n", hr );
3085
3086                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
3087                 ok(hr == S_OK, "ret %08x\n", hr );
3088                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string\n");
3089                 SysFreeString(str);
3090
3091                 IXMLDOMCDATASection_Release(pCDataSec);
3092             }
3093
3094             /* Document Fragments */
3095             hr = IXMLDOMDocument_createDocumentFragment(doc, NULL);
3096             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3097
3098             hr = IXMLDOMDocument_createDocumentFragment(doc, &pDocFrag);
3099             ok(hr == S_OK, "ret %08x\n", hr );
3100             if(hr == S_OK)
3101             {
3102                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
3103
3104                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pDocFrag, NULL);
3105                 ok(hr == S_OK, "ret %08x\n", hr );
3106
3107                 /* get Attribute Tests */
3108                 hr = IXMLDOMDocumentFragment_get_attributes(pDocFrag, NULL);
3109                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3110
3111                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
3112                 hr = IXMLDOMDocumentFragment_get_attributes(pDocFrag, &pAttribs);
3113                 ok(hr == S_FALSE, "ret %08x\n", hr );
3114                 ok(pAttribs == NULL, "pAttribs != NULL\n");
3115
3116                 hr = IXMLDOMDocumentFragment_get_nodeName(pDocFrag, &str);
3117                 ok(hr == S_OK, "ret %08x\n", hr );
3118                 ok( !lstrcmpW( str, szDocFragmentText ), "incorrect docfragment node Name\n");
3119                 SysFreeString(str);
3120
3121                 /* test next Sibling*/
3122                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, NULL);
3123                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3124
3125                 pNextChild = (IXMLDOMNode *)0x1;
3126                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, &pNextChild);
3127                 ok(hr == S_FALSE, "ret %08x\n", hr );
3128                 ok(pNextChild == NULL, "pNextChild not NULL\n");
3129
3130                 /* test Previous Sibling*/
3131                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, NULL);
3132                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3133
3134                 pNextChild = (IXMLDOMNode *)0x1;
3135                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, &pNextChild);
3136                 ok(hr == S_FALSE, "ret %08x\n", hr );
3137                 ok(pNextChild == NULL, "pNextChild not NULL\n");
3138
3139                 /* test get_dataType */
3140                 hr = IXMLDOMDocumentFragment_get_dataType(pDocFrag, NULL);
3141                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3142
3143                 hr = IXMLDOMDocumentFragment_get_dataType(pDocFrag, &v);
3144                 ok(hr == S_FALSE, "ret %08x\n", hr );
3145                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
3146                 VariantClear(&v);
3147
3148                 /* test nodeTypeString */
3149                 hr = IXMLDOMDocumentFragment_get_nodeTypeString(pDocFrag, &str);
3150                 ok(hr == S_OK, "ret %08x\n", hr );
3151                 ok( !lstrcmpW( str, _bstr_("documentfragment") ), "incorrect nodeTypeString string\n");
3152                 SysFreeString(str);
3153
3154                 IXMLDOMDocumentFragment_Release(pDocFrag);
3155             }
3156
3157             /* Entity References */
3158             hr = IXMLDOMDocument_createEntityReference(doc, szEntityRef, NULL);
3159             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3160
3161             hr = IXMLDOMDocument_createEntityReference(doc, szEntityRef, &pEntityRef);
3162             ok(hr == S_OK, "ret %08x\n", hr );
3163             if(hr == S_OK)
3164             {
3165                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pEntityRef, NULL);
3166                 ok(hr == S_OK, "ret %08x\n", hr );
3167
3168                 /* get Attribute Tests */
3169                 hr = IXMLDOMEntityReference_get_attributes(pEntityRef, NULL);
3170                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3171
3172                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
3173                 hr = IXMLDOMEntityReference_get_attributes(pEntityRef, &pAttribs);
3174                 ok(hr == S_FALSE, "ret %08x\n", hr );
3175                 ok(pAttribs == NULL, "pAttribs != NULL\n");
3176
3177                 /* test dataType */
3178                 hr = IXMLDOMEntityReference_get_dataType(pEntityRef, &v);
3179                 ok(hr == S_FALSE, "ret %08x\n", hr );
3180                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
3181                 VariantClear(&v);
3182
3183                 /* test nodeTypeString */
3184                 hr = IXMLDOMEntityReference_get_nodeTypeString(pEntityRef, &str);
3185                 ok(hr == S_OK, "ret %08x\n", hr );
3186                 ok( !lstrcmpW( str, _bstr_("entityreference") ), "incorrect nodeTypeString string\n");
3187                 SysFreeString(str);
3188
3189                 /* test get_xml*/
3190                 hr = IXMLDOMEntityReference_get_xml(pEntityRef, &str);
3191                 ok(hr == S_OK, "ret %08x\n", hr );
3192                 ok( !lstrcmpW( str, szEntityRefXML ), "incorrect xml string\n");
3193                 SysFreeString(str);
3194
3195                 IXMLDOMEntityReference_Release(pEntityRef);
3196             }
3197
3198             IXMLDOMElement_Release( pRoot );
3199         }
3200     }
3201
3202     IXMLDOMDocument_Release(doc);
3203
3204     free_bstrs();
3205 }
3206
3207 static void test_nodeTypeTests( void )
3208 {
3209     IXMLDOMDocument *doc = NULL;
3210     IXMLDOMElement *pRoot;
3211     IXMLDOMElement *pElement;
3212     HRESULT hr;
3213
3214     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3215     if( hr != S_OK )
3216         return;
3217
3218     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
3219     ok(hr == S_OK, "ret %08x\n", hr );
3220     if(hr == S_OK)
3221     {
3222         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
3223         ok(hr == S_OK, "ret %08x\n", hr );
3224         if(hr == S_OK)
3225         {
3226             hr = IXMLDOMElement_put_dataType(pRoot, NULL);
3227             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3228
3229             /* Invalid Value */
3230             hr = IXMLDOMElement_put_dataType(pRoot, _bstr_("abcdefg") );
3231             ok(hr == E_FAIL, "ret %08x\n", hr );
3232
3233             /* NOTE:
3234              *   The name passed into put_dataType is case-insensitive. So many of the names
3235              *     have been changed to reflect this.
3236              */
3237             /* Boolean */
3238             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Boolean"), &pElement);
3239             ok(hr == S_OK, "ret %08x\n", hr );
3240             if(hr == S_OK)
3241             {
3242                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3243
3244                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Boolean") );
3245                 ok(hr == S_OK, "ret %08x\n", hr );
3246
3247                 IXMLDOMElement_Release(pElement);
3248             }
3249
3250             /* String */
3251             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_String"), &pElement);
3252             ok(hr == S_OK, "ret %08x\n", hr );
3253             if(hr == S_OK)
3254             {
3255                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3256
3257                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("String") );
3258                 ok(hr == S_OK, "ret %08x\n", hr );
3259
3260                 IXMLDOMElement_Release(pElement);
3261             }
3262
3263             /* Number */
3264             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Number"), &pElement);
3265             ok(hr == S_OK, "ret %08x\n", hr );
3266             if(hr == S_OK)
3267             {
3268                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3269
3270                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("number") );
3271                 ok(hr == S_OK, "ret %08x\n", hr );
3272
3273                 IXMLDOMElement_Release(pElement);
3274             }
3275
3276             /* Int */
3277             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Int"), &pElement);
3278             ok(hr == S_OK, "ret %08x\n", hr );
3279             if(hr == S_OK)
3280             {
3281                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3282
3283                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("InT") );
3284                 ok(hr == S_OK, "ret %08x\n", hr );
3285
3286                 IXMLDOMElement_Release(pElement);
3287             }
3288
3289             /* Fixed */
3290             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Fixed"), &pElement);
3291             ok(hr == S_OK, "ret %08x\n", hr );
3292             if(hr == S_OK)
3293             {
3294                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3295
3296                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("fixed.14.4") );
3297                 ok(hr == S_OK, "ret %08x\n", hr );
3298
3299                 IXMLDOMElement_Release(pElement);
3300             }
3301
3302             /* DateTime */
3303             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_DateTime"), &pElement);
3304             ok(hr == S_OK, "ret %08x\n", hr );
3305             if(hr == S_OK)
3306             {
3307                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3308
3309                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime") );
3310                 ok(hr == S_OK, "ret %08x\n", hr );
3311
3312                 IXMLDOMElement_Release(pElement);
3313             }
3314
3315             /* DateTime TZ */
3316             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_DateTime_tz"), &pElement);
3317             ok(hr == S_OK, "ret %08x\n", hr );
3318             if(hr == S_OK)
3319             {
3320                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3321
3322                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime.tz") );
3323                 ok(hr == S_OK, "ret %08x\n", hr );
3324
3325                 IXMLDOMElement_Release(pElement);
3326             }
3327
3328             /* Date */
3329             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Date"), &pElement);
3330             ok(hr == S_OK, "ret %08x\n", hr );
3331             if(hr == S_OK)
3332             {
3333                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3334
3335                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Date") );
3336                 ok(hr == S_OK, "ret %08x\n", hr );
3337
3338                 IXMLDOMElement_Release(pElement);
3339             }
3340
3341             /* Time */
3342             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Time"), &pElement);
3343             ok(hr == S_OK, "ret %08x\n", hr );
3344             if(hr == S_OK)
3345             {
3346                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3347
3348                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Time") );
3349                 ok(hr == S_OK, "ret %08x\n", hr );
3350
3351                 IXMLDOMElement_Release(pElement);
3352             }
3353
3354             /* Time.tz */
3355             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Time_TZ"), &pElement);
3356             ok(hr == S_OK, "ret %08x\n", hr );
3357             if(hr == S_OK)
3358             {
3359                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3360
3361                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Time.tz") );
3362                 ok(hr == S_OK, "ret %08x\n", hr );
3363
3364                 IXMLDOMElement_Release(pElement);
3365             }
3366
3367             /* I1 */
3368             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I1"), &pElement);
3369             ok(hr == S_OK, "ret %08x\n", hr );
3370             if(hr == S_OK)
3371             {
3372                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3373
3374                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I1") );
3375                 ok(hr == S_OK, "ret %08x\n", hr );
3376
3377                 IXMLDOMElement_Release(pElement);
3378             }
3379
3380             /* I2 */
3381             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I2"), &pElement);
3382             ok(hr == S_OK, "ret %08x\n", hr );
3383             if(hr == S_OK)
3384             {
3385                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3386
3387                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I2") );
3388                 ok(hr == S_OK, "ret %08x\n", hr );
3389
3390                 IXMLDOMElement_Release(pElement);
3391             }
3392
3393             /* I4 */
3394             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I4"), &pElement);
3395             ok(hr == S_OK, "ret %08x\n", hr );
3396             if(hr == S_OK)
3397             {
3398                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3399
3400                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I4") );
3401                 ok(hr == S_OK, "ret %08x\n", hr );
3402
3403                 IXMLDOMElement_Release(pElement);
3404             }
3405
3406             /* UI1 */
3407             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI1"), &pElement);
3408             ok(hr == S_OK, "ret %08x\n", hr );
3409             if(hr == S_OK)
3410             {
3411                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3412
3413                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI1") );
3414                 ok(hr == S_OK, "ret %08x\n", hr );
3415
3416                 IXMLDOMElement_Release(pElement);
3417             }
3418
3419             /* UI2 */
3420             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI2"), &pElement);
3421             ok(hr == S_OK, "ret %08x\n", hr );
3422             if(hr == S_OK)
3423             {
3424                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3425
3426                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI2") );
3427                 ok(hr == S_OK, "ret %08x\n", hr );
3428
3429                 IXMLDOMElement_Release(pElement);
3430             }
3431
3432             /* UI4 */
3433             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI4"), &pElement);
3434             ok(hr == S_OK, "ret %08x\n", hr );
3435             if(hr == S_OK)
3436             {
3437                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3438
3439                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI4") );
3440                 ok(hr == S_OK, "ret %08x\n", hr );
3441
3442                 IXMLDOMElement_Release(pElement);
3443             }
3444
3445             /* r4 */
3446             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_r4"), &pElement);
3447             ok(hr == S_OK, "ret %08x\n", hr );
3448             if(hr == S_OK)
3449             {
3450                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3451
3452                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("r4") );
3453                 ok(hr == S_OK, "ret %08x\n", hr );
3454
3455                 IXMLDOMElement_Release(pElement);
3456             }
3457
3458             /* r8 */
3459             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_r8"), &pElement);
3460             ok(hr == S_OK, "ret %08x\n", hr );
3461             if(hr == S_OK)
3462             {
3463                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3464
3465                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("r8") );
3466                 ok(hr == S_OK, "ret %08x\n", hr );
3467
3468                 IXMLDOMElement_Release(pElement);
3469             }
3470
3471             /* float */
3472             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_float"), &pElement);
3473             ok(hr == S_OK, "ret %08x\n", hr );
3474             if(hr == S_OK)
3475             {
3476                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3477
3478                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("float") );
3479                 ok(hr == S_OK, "ret %08x\n", hr );
3480
3481                 IXMLDOMElement_Release(pElement);
3482             }
3483
3484             /* uuid */
3485             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_uuid"), &pElement);
3486             ok(hr == S_OK, "ret %08x\n", hr );
3487             if(hr == S_OK)
3488             {
3489                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3490
3491                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UuId") );
3492                 ok(hr == S_OK, "ret %08x\n", hr );
3493
3494                 IXMLDOMElement_Release(pElement);
3495             }
3496
3497             /* bin.hex */
3498             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_bin_hex"), &pElement);
3499             ok(hr == S_OK, "ret %08x\n", hr );
3500             if(hr == S_OK)
3501             {
3502                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3503
3504                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("bin.hex") );
3505                 ok(hr == S_OK, "ret %08x\n", hr );
3506
3507                 IXMLDOMElement_Release(pElement);
3508             }
3509
3510             /* bin.base64 */
3511             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_bin_base64"), &pElement);
3512             ok(hr == S_OK, "ret %08x\n", hr );
3513             if(hr == S_OK)
3514             {
3515                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3516
3517                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("bin.base64") );
3518                 ok(hr == S_OK, "ret %08x\n", hr );
3519
3520                 IXMLDOMElement_Release(pElement);
3521             }
3522
3523             /* Check changing types */
3524             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Change"), &pElement);
3525             ok(hr == S_OK, "ret %08x\n", hr );
3526             if(hr == S_OK)
3527             {
3528                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3529
3530                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime.tz") );
3531                 ok(hr == S_OK, "ret %08x\n", hr );
3532
3533                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("string") );
3534                 ok(hr == S_OK, "ret %08x\n", hr );
3535
3536                 IXMLDOMElement_Release(pElement);
3537             }
3538
3539             IXMLDOMElement_Release(pRoot);
3540         }
3541     }
3542
3543     IXMLDOMDocument_Release(doc);
3544
3545     free_bstrs();
3546 }
3547
3548 static void test_DocumentSaveToDocument(void)
3549 {
3550     IXMLDOMDocument *doc = NULL;
3551     IXMLDOMDocument *doc2 = NULL;
3552     IXMLDOMElement *pRoot;
3553
3554     HRESULT hr;
3555
3556     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3557     if( hr != S_OK )
3558         return;
3559
3560     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc2 );
3561     if( hr != S_OK )
3562     {
3563         IXMLDOMDocument_Release(doc);
3564         return;
3565     }
3566
3567     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
3568     ok(hr == S_OK, "ret %08x\n", hr );
3569     if(hr == S_OK)
3570     {
3571         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
3572         ok(hr == S_OK, "ret %08x\n", hr );
3573         if(hr == S_OK)
3574         {
3575             VARIANT vDoc;
3576             BSTR sOrig;
3577             BSTR sNew;
3578
3579             V_VT(&vDoc) = VT_UNKNOWN;
3580             V_UNKNOWN(&vDoc) = (IUnknown*)doc2;
3581
3582             hr = IXMLDOMDocument_save(doc, vDoc);
3583             ok(hr == S_OK, "ret %08x\n", hr );
3584
3585             hr = IXMLDOMDocument_get_xml(doc, &sOrig);
3586             ok(hr == S_OK, "ret %08x\n", hr );
3587
3588             hr = IXMLDOMDocument_get_xml(doc2, &sNew);
3589             ok(hr == S_OK, "ret %08x\n", hr );
3590
3591             ok( !lstrcmpW( sOrig, sNew ), "New document is not the same as origial\n");
3592
3593             SysFreeString(sOrig);
3594             SysFreeString(sNew);
3595         }
3596     }
3597
3598     IXMLDOMDocument_Release(doc2);
3599     IXMLDOMDocument_Release(doc);
3600 }
3601
3602 static void test_DocumentSaveToFile(void)
3603 {
3604     IXMLDOMDocument *doc = NULL;
3605     IXMLDOMElement *pRoot;
3606     HANDLE file;
3607     char buffer[100];
3608     DWORD read = 0;
3609     HRESULT hr;
3610
3611     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3612     if( hr != S_OK )
3613         return;
3614
3615     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
3616     ok(hr == S_OK, "ret %08x\n", hr );
3617     if(hr == S_OK)
3618     {
3619         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
3620         ok(hr == S_OK, "ret %08x\n", hr );
3621         if(hr == S_OK)
3622         {
3623             VARIANT vFile;
3624
3625             V_VT(&vFile) = VT_BSTR;
3626             V_BSTR(&vFile) = _bstr_("test.xml");
3627
3628             hr = IXMLDOMDocument_save(doc, vFile);
3629             ok(hr == S_OK, "ret %08x\n", hr );
3630         }
3631     }
3632
3633     IXMLDOMElement_Release(pRoot);
3634     IXMLDOMDocument_Release(doc);
3635
3636     file = CreateFile("test.xml", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
3637     ok(file != INVALID_HANDLE_VALUE, "Could not open file: %u\n", GetLastError());
3638     if(file == INVALID_HANDLE_VALUE)
3639         return;
3640
3641     ReadFile(file, buffer, sizeof(buffer), &read, NULL);
3642     ok(read != 0, "could not read file\n");
3643     ok(buffer[0] != '<' || buffer[1] != '?', "File contains processing instruction\n");
3644
3645     CloseHandle(file);
3646     DeleteFile("test.xml");
3647 }
3648
3649 static void test_testTransforms(void)
3650 {
3651     IXMLDOMDocument *doc = NULL;
3652     IXMLDOMDocument *docSS = NULL;
3653     IXMLDOMNode *pNode;
3654     VARIANT_BOOL bSucc;
3655
3656     HRESULT hr;
3657
3658     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3659     if( hr != S_OK )
3660         return;
3661
3662     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&docSS );
3663     if( hr != S_OK )
3664     {
3665         IXMLDOMDocument_Release(doc);
3666         return;
3667     }
3668
3669     hr = IXMLDOMDocument_loadXML(doc, _bstr_(szTransformXML), &bSucc);
3670     ok(hr == S_OK, "ret %08x\n", hr );
3671
3672     hr = IXMLDOMDocument_loadXML(docSS, _bstr_(szTransformSSXML), &bSucc);
3673     ok(hr == S_OK, "ret %08x\n", hr );
3674
3675     hr = IXMLDOMDocument_QueryInterface(docSS, &IID_IXMLDOMNode, (LPVOID*)&pNode );
3676     ok(hr == S_OK, "ret %08x\n", hr );
3677     if(hr == S_OK)
3678     {
3679         BSTR bOut;
3680
3681         hr = IXMLDOMDocument_transformNode(doc, pNode, &bOut);
3682         ok(hr == S_OK, "ret %08x\n", hr );
3683         ok( compareIgnoreReturns( bOut, _bstr_(szTransformOutput)), "Stylesheet output not correct\n");
3684         SysFreeString(bOut);
3685
3686         IXMLDOMNode_Release(pNode);
3687     }
3688
3689     IXMLDOMDocument_Release(docSS);
3690     IXMLDOMDocument_Release(doc);
3691
3692     free_bstrs();
3693 }
3694
3695 static void test_Namespaces(void)
3696 {
3697     IXMLDOMDocument2 *doc = NULL;
3698     IXMLDOMNode *pNode;
3699     IXMLDOMNode *pNode2 = NULL;
3700     VARIANT_BOOL bSucc;
3701     HRESULT hr;
3702     BSTR str;
3703     static  const CHAR szNamespacesXML[] =
3704 "<?xml version=\"1.0\"?>\n"
3705 "<root xmlns:WEB='http://www.winehq.org'>\n"
3706 "<WEB:Site version=\"1.0\" />\n"
3707 "</root>";
3708
3709     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3710     if( hr != S_OK )
3711         return;
3712
3713     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szNamespacesXML), &bSucc);
3714     ok(hr == S_OK, "ret %08x\n", hr );
3715     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
3716
3717     hr = IXMLDOMDocument_selectSingleNode(doc, _bstr_("root"), &pNode );
3718     ok(hr == S_OK, "ret %08x\n", hr );
3719     if(hr == S_OK)
3720     {
3721         hr = IXMLDOMNode_get_firstChild( pNode, &pNode2 );
3722         ok( hr == S_OK, "ret %08x\n", hr );
3723         ok( pNode2 != NULL, "pNode2 == NULL\n");
3724
3725         /* Test get_prefix */
3726         hr = IXMLDOMNode_get_prefix(pNode2, NULL);
3727         ok( hr == E_INVALIDARG, "ret %08x\n", hr );
3728         /* NOTE: Need to test that arg2 gets cleared on Error. */
3729
3730         hr = IXMLDOMNode_get_prefix(pNode2, &str);
3731         ok( hr == S_OK, "ret %08x\n", hr );
3732         ok( !lstrcmpW( str, _bstr_("WEB")), "incorrect prefix string\n");
3733         SysFreeString(str);
3734
3735         /* Test get_namespaceURI */
3736         hr = IXMLDOMNode_get_namespaceURI(pNode2, NULL);
3737         ok( hr == E_INVALIDARG, "ret %08x\n", hr );
3738         /* NOTE: Need to test that arg2 gets cleared on Error. */
3739
3740         hr = IXMLDOMNode_get_namespaceURI(pNode2, &str);
3741         ok( hr == S_OK, "ret %08x\n", hr );
3742         ok( !lstrcmpW( str, _bstr_("http://www.winehq.org")), "incorrect namespaceURI string\n");
3743         SysFreeString(str);
3744
3745         IXMLDOMNode_Release(pNode2);
3746         IXMLDOMNode_Release(pNode);
3747     }
3748
3749     IXMLDOMDocument2_Release(doc);
3750
3751     free_bstrs();
3752 }
3753
3754 static void test_FormattingXML(void)
3755 {
3756     IXMLDOMDocument2 *doc = NULL;
3757     IXMLDOMElement *pElement;
3758     VARIANT_BOOL bSucc;
3759     HRESULT hr;
3760     BSTR str;
3761     static const CHAR szLinefeedXML[] = "<?xml version=\"1.0\"?>\n<Root>\n\t<Sub val=\"A\" />\n</Root>";
3762     static const CHAR szLinefeedRootXML[] = "<Root>\r\n\t<Sub val=\"A\"/>\r\n</Root>";
3763
3764     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3765     if( hr != S_OK )
3766         return;
3767
3768     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szLinefeedXML), &bSucc);
3769     ok(hr == S_OK, "ret %08x\n", hr );
3770     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
3771
3772     if(bSucc == VARIANT_TRUE)
3773     {
3774         hr = IXMLDOMDocument2_get_documentElement(doc, &pElement);
3775         ok(hr == S_OK, "ret %08x\n", hr );
3776         if(hr == S_OK)
3777         {
3778             hr = IXMLDOMElement_get_xml(pElement, &str);
3779             ok(hr == S_OK, "ret %08x\n", hr );
3780             ok( !lstrcmpW( str, _bstr_(szLinefeedRootXML) ), "incorrect element xml\n");
3781             SysFreeString(str);
3782
3783             IXMLDOMElement_Release(pElement);
3784         }
3785     }
3786
3787     IXMLDOMDocument2_Release(doc);
3788
3789     free_bstrs();
3790 }
3791
3792 static void test_NodeTypeValue(void)
3793 {
3794     IXMLDOMDocument2 *doc = NULL;
3795     IXMLDOMNode *pNode;
3796     VARIANT_BOOL bSucc;
3797     HRESULT hr;
3798     VARIANT v;
3799
3800     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3801     if( hr != S_OK )
3802         return;
3803
3804     hr = IXMLDOMDocument2_loadXML(doc, _bstr_(szTypeValueXML), &bSucc);
3805     ok(hr == S_OK, "ret %08x\n", hr );
3806     ok(bSucc == VARIANT_TRUE, "Expected VARIANT_TRUE got VARIANT_FALSE\n");
3807     if(bSucc == VARIANT_TRUE)
3808     {
3809         hr = IXMLDOMDocument2_get_nodeValue(doc, NULL);
3810         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3811
3812         V_VT(&v) = VT_BSTR;
3813         V_BSTR(&v) = NULL;
3814         hr = IXMLDOMDocument2_get_nodeValue(doc, &v);
3815         ok(hr == S_FALSE, "ret %08x\n", hr );
3816         ok(V_VT(&v) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&v));
3817
3818         hr = IXMLDOMDocument2_get_nodeTypedValue(doc, NULL);
3819         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3820
3821         hr = IXMLDOMDocument2_get_nodeTypedValue(doc, &v);
3822         ok(hr == S_FALSE, "ret %08x\n", hr );
3823
3824         hr = IXMLDOMDocument2_selectSingleNode(doc, _bstr_("string"), &pNode);
3825         ok(hr == S_OK, "ret %08x\n", hr );
3826         if(hr == S_OK)
3827         {
3828             V_VT(&v) = VT_BSTR;
3829             V_BSTR(&v) = NULL;
3830             hr = IXMLDOMNode_get_nodeValue(pNode, &v);
3831             ok(hr == S_FALSE, "ret %08x\n", hr );
3832             ok(V_VT(&v) == VT_NULL, "expect VT_NULL got %d\n", V_VT(&v));
3833
3834             hr = IXMLDOMNode_get_nodeTypedValue(pNode, NULL);
3835             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
3836
3837             hr = IXMLDOMNode_get_nodeTypedValue(pNode, &v);
3838             ok(hr == S_OK, "ret %08x\n", hr );
3839             ok(!lstrcmpW( V_BSTR(&v), _bstr_("Wine") ), "incorrect value\n");
3840
3841             IXMLDOMNode_Release(pNode);
3842         }
3843     }
3844
3845     IXMLDOMDocument2_Release(doc);
3846
3847     free_bstrs();
3848 }
3849
3850 START_TEST(domdoc)
3851 {
3852     HRESULT r;
3853
3854     r = CoInitialize( NULL );
3855     ok( r == S_OK, "failed to init com\n");
3856
3857     test_domdoc();
3858     test_domnode();
3859     test_refs();
3860     test_create();
3861     test_getElementsByTagName();
3862     test_get_text();
3863     test_get_childNodes();
3864     test_removeChild();
3865     test_replaceChild();
3866     test_removeNamedItem();
3867     test_XMLHTTP();
3868     test_IXMLDOMDocument2();
3869     test_XPath();
3870     test_cloneNode();
3871     test_xmlTypes();
3872     test_nodeTypeTests();
3873     test_DocumentSaveToDocument();
3874     test_DocumentSaveToFile();
3875     test_testTransforms();
3876     test_Namespaces();
3877     test_FormattingXML();
3878     test_NodeTypeValue();
3879
3880     CoUninitialize();
3881 }