git.oblomov.eu Git - wine/blob - dlls/msxml3/tests/saxreader.c

   1 /*
   2  * SAXReader/MXWriter tests
   3  *
   4  * Copyright 2008 Piotr Caban
   5  * Copyright 2011 Thomas Mullaly
   6  * Copyright 2012 Nikolay Sivov
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #define COBJMACROS
  24 #define CONST_VTABLE
  25
  26 #include <stdio.h>
  27 #include <assert.h>
  28
  29 #include "windows.h"
  30 #include "ole2.h"
  31 #include "msxml2.h"
  32 #include "msxml2did.h"
  33 #include "ocidl.h"
  34 #include "dispex.h"
  35
  36 #include "wine/test.h"
  37
  38 #define EXPECT_HR(hr,hr_exp) \
  39     ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
  40
  41 #define EXPECT_REF(obj,ref) _expect_ref((IUnknown*)obj, ref, __LINE__)
  42 static void _expect_ref(IUnknown* obj, ULONG ref, int line)
  43 {
  44     ULONG rc = IUnknown_AddRef(obj);
  45     IUnknown_Release(obj);
  46     ok_(__FILE__,line)(rc-1 == ref, "expected refcount %d, got %d\n", ref, rc-1);
  47 }
  48
  49 static LONG get_refcount(void *iface)
  50 {
  51     IUnknown *unk = iface;
  52     LONG ref;
  53
  54     ref = IUnknown_AddRef(unk);
  55     IUnknown_Release(unk);
  56     return ref-1;
  57 }
  58
  59 struct msxmlsupported_data_t
  60 {
  61     const GUID *clsid;
  62     const char *name;
  63     BOOL supported;
  64 };
  65
  66 static BOOL is_clsid_supported(const GUID *clsid, const struct msxmlsupported_data_t *table)
  67 {
  68     while (table->clsid)
  69     {
  70         if (table->clsid == clsid) return table->supported;
  71         table++;
  72     }
  73     return FALSE;
  74 }
  75
  76 static BSTR alloc_str_from_narrow(const char *str)
  77 {
  78     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
  79     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
  80     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
  81     return ret;
  82 }
  83
  84 static BSTR alloced_bstrs[512];
  85 static int alloced_bstrs_count;
  86
  87 static BSTR _bstr_(const char *str)
  88 {
  89     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
  90     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
  91     return alloced_bstrs[alloced_bstrs_count++];
  92 }
  93
  94 static void free_bstrs(void)
  95 {
  96     int i;
  97     for (i = 0; i < alloced_bstrs_count; i++)
  98         SysFreeString(alloced_bstrs[i]);
  99     alloced_bstrs_count = 0;
 100 }
 101
 102 static void test_saxstr(const char *file, unsigned line, BSTR str, const char *expected, int todo, int *failcount)
 103 {
 104     int len, lenexp, cmp;
 105     WCHAR buf[1024];
 106
 107     len = SysStringLen(str);
 108
 109     if (!expected) {
 110         if (str && todo)
 111         {
 112             (*failcount)++;
 113             todo_wine
 114             ok_(file, line) (!str, "got %p, expected null str\n", str);
 115         }
 116         else
 117             ok_(file, line) (!str, "got %p, expected null str\n", str);
 118
 119         if (len && todo)
 120         {
 121             (*failcount)++;
 122             todo_wine
 123             ok_(file, line) (len == 0, "got len %d, expected 0\n", len);
 124         }
 125         else
 126             ok_(file, line) (len == 0, "got len %d, expected 0\n", len);
 127         return;
 128     }
 129
 130     lenexp = strlen(expected);
 131     if (lenexp != len && todo)
 132     {
 133         (*failcount)++;
 134         todo_wine
 135         ok_(file, line) (lenexp == len, "len %d (%s), expected %d (%s)\n", len, wine_dbgstr_wn(str, len), lenexp, expected);
 136     }
 137     else
 138         ok_(file, line) (lenexp == len, "len %d (%s), expected %d (%s)\n", len, wine_dbgstr_wn(str, len), lenexp, expected);
 139
 140     /* exit earlier on length mismatch */
 141     if (lenexp != len) return;
 142
 143     MultiByteToWideChar(CP_ACP, 0, expected, -1, buf, sizeof(buf)/sizeof(WCHAR));
 144
 145     cmp = memcmp(str, buf, lenexp*sizeof(WCHAR));
 146     if (cmp && todo)
 147     {
 148         (*failcount)++;
 149         todo_wine
 150         ok_(file, line) (!cmp, "unexpected str %s, expected %s\n",
 151                          wine_dbgstr_wn(str, len), expected);
 152     }
 153     else
 154         ok_(file, line) (!cmp, "unexpected str %s, expected %s\n",
 155                              wine_dbgstr_wn(str, len), expected);
 156 }
 157
 158 typedef enum _CH {
 159     CH_ENDTEST,
 160     CH_PUTDOCUMENTLOCATOR,
 161     CH_STARTDOCUMENT,
 162     CH_ENDDOCUMENT,
 163     CH_STARTPREFIXMAPPING,
 164     CH_ENDPREFIXMAPPING,
 165     CH_STARTELEMENT,
 166     CH_ENDELEMENT,
 167     CH_CHARACTERS,
 168     CH_IGNORABLEWHITESPACE,
 169     CH_PROCESSINGINSTRUCTION,
 170     CH_SKIPPEDENTITY,
 171     EH_ERROR,
 172     EH_FATALERROR,
 173     EG_IGNORABLEWARNING,
 174     EVENT_LAST
 175 } CH;
 176
 177 static const char *event_names[EVENT_LAST] = {
 178     "endtest",
 179     "putDocumentLocator",
 180     "startDocument",
 181     "endDocument",
 182     "startPrefixMapping",
 183     "endPrefixMapping",
 184     "startElement",
 185     "endElement",
 186     "characters",
 187     "ignorableWhitespace",
 188     "processingInstruction",
 189     "skippedEntity",
 190     "error",
 191     "fatalError",
 192     "ignorableWarning"
 193 };
 194
 195 struct attribute_entry {
 196     const char *uri;
 197     const char *local;
 198     const char *qname;
 199     const char *value;
 200
 201     /* used for actual call data only, null for expected call data */
 202     BSTR uriW;
 203     BSTR localW;
 204     BSTR qnameW;
 205     BSTR valueW;
 206 };
 207
 208 struct call_entry {
 209     CH id;
 210     int line;
 211     int column;
 212     HRESULT ret;
 213     const char *arg1;
 214     const char *arg2;
 215     const char *arg3;
 216
 217     /* allocated once at startElement callback */
 218     struct attribute_entry *attributes;
 219     int attr_count;
 220
 221     /* used for actual call data only, null for expected call data */
 222     BSTR arg1W;
 223     BSTR arg2W;
 224     BSTR arg3W;
 225 };
 226
 227 struct call_sequence
 228 {
 229     int count;
 230     int size;
 231     struct call_entry *sequence;
 232 };
 233
 234 #define CONTENT_HANDLER_INDEX 0
 235 #define NUM_CALL_SEQUENCES    1
 236 static struct call_sequence *sequences[NUM_CALL_SEQUENCES];
 237
 238 static void init_call_entry(ISAXLocator *locator, struct call_entry *call)
 239 {
 240     memset(call, 0, sizeof(*call));
 241     ISAXLocator_getLineNumber(locator, &call->line);
 242     ISAXLocator_getColumnNumber(locator, &call->column);
 243 }
 244
 245 static void add_call(struct call_sequence **seq, int sequence_index,
 246     const struct call_entry *call)
 247 {
 248     struct call_sequence *call_seq = seq[sequence_index];
 249
 250     if (!call_seq->sequence)
 251     {
 252         call_seq->size = 10;
 253         call_seq->sequence = HeapAlloc(GetProcessHeap(), 0,
 254                                       call_seq->size * sizeof (struct call_entry));
 255     }
 256
 257     if (call_seq->count == call_seq->size)
 258     {
 259         call_seq->size *= 2;
 260         call_seq->sequence = HeapReAlloc(GetProcessHeap(), 0,
 261                                         call_seq->sequence,
 262                                         call_seq->size * sizeof (struct call_entry));
 263     }
 264
 265     assert(call_seq->sequence);
 266
 267     call_seq->sequence[call_seq->count].id     = call->id;
 268     call_seq->sequence[call_seq->count].line   = call->line;
 269     call_seq->sequence[call_seq->count].column = call->column;
 270     call_seq->sequence[call_seq->count].arg1W  = call->arg1W;
 271     call_seq->sequence[call_seq->count].arg2W  = call->arg2W;
 272     call_seq->sequence[call_seq->count].arg3W  = call->arg3W;
 273     call_seq->sequence[call_seq->count].ret    = call->ret;
 274     call_seq->sequence[call_seq->count].attr_count = call->attr_count;
 275     call_seq->sequence[call_seq->count].attributes = call->attributes;
 276
 277     call_seq->count++;
 278 }
 279
 280 static inline void flush_sequence(struct call_sequence **seg, int sequence_index)
 281 {
 282     int i;
 283
 284     struct call_sequence *call_seq = seg[sequence_index];
 285
 286     for (i = 0; i < call_seq->count; i++)
 287     {
 288         int j;
 289
 290         for (j = 0; j < call_seq->sequence[i].attr_count; j++)
 291         {
 292             SysFreeString(call_seq->sequence[i].attributes[j].uriW);
 293             SysFreeString(call_seq->sequence[i].attributes[j].localW);
 294             SysFreeString(call_seq->sequence[i].attributes[j].qnameW);
 295         }
 296
 297         SysFreeString(call_seq->sequence[i].arg1W);
 298         SysFreeString(call_seq->sequence[i].arg2W);
 299         SysFreeString(call_seq->sequence[i].arg3W);
 300     }
 301
 302     HeapFree(GetProcessHeap(), 0, call_seq->sequence);
 303     call_seq->sequence = NULL;
 304     call_seq->count = call_seq->size = 0;
 305 }
 306
 307 static inline void flush_sequences(struct call_sequence **seq, int n)
 308 {
 309     int i;
 310     for (i = 0; i < n; i++)
 311         flush_sequence(seq, i);
 312 }
 313
 314 static const char *get_event_name(CH event)
 315 {
 316     return event_names[event];
 317 }
 318
 319 static void compare_attributes(const struct call_entry *actual, const struct call_entry *expected, const char *context,
 320     int todo, const char *file, int line, int *failcount)
 321 {
 322     int i, lenexp = 0;
 323
 324     /* attribute count is not stored for expected data */
 325     if (expected->attributes)
 326     {
 327         struct attribute_entry *ptr = expected->attributes;
 328         while (ptr->uri) { lenexp++; ptr++; };
 329     }
 330
 331     /* check count first and exit earlier */
 332     if (actual->attr_count != lenexp && todo)
 333     {
 334         (*failcount)++;
 335         todo_wine
 336             ok_(file, line) (FALSE, "%s: in event %s expecting attr count %d got %d\n",
 337                 context, get_event_name(actual->id), lenexp, actual->attr_count);
 338     }
 339     else
 340         ok_(file, line) (actual->attr_count == lenexp, "%s: in event %s expecting attr count %d got %d\n",
 341             context, get_event_name(actual->id), lenexp, actual->attr_count);
 342
 343     if (actual->attr_count != lenexp) return;
 344
 345     /* now compare all attributes strings */
 346     for (i = 0; i < actual->attr_count; i++)
 347     {
 348         test_saxstr(file, line, actual->attributes[i].uriW,   expected->attributes[i].uri, todo, failcount);
 349         test_saxstr(file, line, actual->attributes[i].localW, expected->attributes[i].local, todo, failcount);
 350         test_saxstr(file, line, actual->attributes[i].qnameW, expected->attributes[i].qname, todo, failcount);
 351         test_saxstr(file, line, actual->attributes[i].valueW, expected->attributes[i].value, todo, failcount);
 352     }
 353 }
 354
 355 static void ok_sequence_(struct call_sequence **seq, int sequence_index,
 356     const struct call_entry *expected, const char *context, int todo,
 357     const char *file, int line)
 358 {
 359     struct call_sequence *call_seq = seq[sequence_index];
 360     static const struct call_entry end_of_sequence = { CH_ENDTEST };
 361     const struct call_entry *actual, *sequence;
 362     int failcount = 0;
 363
 364     add_call(seq, sequence_index, &end_of_sequence);
 365
 366     sequence = call_seq->sequence;
 367     actual = sequence;
 368
 369     while (expected->id != CH_ENDTEST && actual->id != CH_ENDTEST)
 370     {
 371         if (expected->id == actual->id)
 372         {
 373             /* always test position data */
 374             if (expected->line != actual->line && todo)
 375             {
 376                 todo_wine
 377                 {
 378                     failcount++;
 379                     ok_(file, line) (FALSE,
 380                         "%s: in event %s expecting line %d got %d\n",
 381                         context, get_event_name(actual->id), expected->line, actual->line);
 382                 }
 383             }
 384             else
 385             {
 386                 ok_(file, line) (expected->line == actual->line,
 387                    "%s: in event %s expecting line %d got %d\n",
 388                    context, get_event_name(actual->id), expected->line, actual->line);
 389             }
 390
 391             if (expected->column != actual->column && todo)
 392             {
 393                 todo_wine
 394                 {
 395                     failcount++;
 396                     ok_(file, line) (FALSE,
 397                         "%s: in event %s expecting column %d got %d\n",
 398                         context, get_event_name(actual->id), expected->column, actual->column);
 399                 }
 400             }
 401             else
 402             {
 403                 ok_(file, line) (expected->column == actual->column,
 404                    "%s: in event %s expecting column %d got %d\n",
 405                    context, get_event_name(actual->id), expected->column, actual->column);
 406             }
 407
 408             switch (actual->id)
 409             {
 410             case CH_PUTDOCUMENTLOCATOR:
 411             case CH_STARTDOCUMENT:
 412             case CH_ENDDOCUMENT:
 413                 break;
 414             case CH_STARTPREFIXMAPPING:
 415                 /* prefix, uri */
 416                 test_saxstr(file, line, actual->arg1W, expected->arg1, todo, &failcount);
 417                 test_saxstr(file, line, actual->arg2W, expected->arg2, todo, &failcount);
 418                 break;
 419             case CH_ENDPREFIXMAPPING:
 420                 /* prefix */
 421                 test_saxstr(file, line, actual->arg1W, expected->arg1, todo, &failcount);
 422                 break;
 423             case CH_STARTELEMENT:
 424                 /* compare attributes */
 425                 compare_attributes(actual, expected, context, todo, file, line, &failcount);
 426                 /* fallthrough */
 427             case CH_ENDELEMENT:
 428                 /* uri, localname, qname */
 429                 test_saxstr(file, line, actual->arg1W, expected->arg1, todo, &failcount);
 430                 test_saxstr(file, line, actual->arg2W, expected->arg2, todo, &failcount);
 431                 test_saxstr(file, line, actual->arg3W, expected->arg3, todo, &failcount);
 432                 break;
 433             case CH_CHARACTERS:
 434             case CH_IGNORABLEWHITESPACE:
 435                 /* char data */
 436                 test_saxstr(file, line, actual->arg1W, expected->arg1, todo, &failcount);
 437                 break;
 438             case CH_PROCESSINGINSTRUCTION:
 439                 /* target, data */
 440                 test_saxstr(file, line, actual->arg1W, expected->arg1, todo, &failcount);
 441                 test_saxstr(file, line, actual->arg2W, expected->arg2, todo, &failcount);
 442                 break;
 443             case CH_SKIPPEDENTITY:
 444                 /* name */
 445                 test_saxstr(file, line, actual->arg1W, expected->arg1, todo, &failcount);
 446                 break;
 447             case EH_FATALERROR:
 448                 /* test return value only */
 449                 if (expected->ret != actual->ret && todo)
 450                 {
 451                      failcount++;
 452                      ok_(file, line) (FALSE,
 453                          "%s: in event %s expecting ret 0x%08x got 0x%08x\n",
 454                          context, get_event_name(actual->id), expected->ret, actual->ret);
 455                 }
 456                 else
 457                      ok_(file, line) (expected->ret == actual->ret,
 458                          "%s: in event %s expecting ret 0x%08x got 0x%08x\n",
 459                          context, get_event_name(actual->id), expected->ret, actual->ret);
 460                 break;
 461             case EH_ERROR:
 462             case EG_IGNORABLEWARNING:
 463             default:
 464                 ok(0, "%s: callback not handled, %s\n", context, get_event_name(actual->id));
 465             }
 466             expected++;
 467             actual++;
 468         }
 469         else if (todo)
 470         {
 471             failcount++;
 472             todo_wine
 473             {
 474                 ok_(file, line) (FALSE, "%s: call %s was expected, but got call %s instead\n",
 475                     context, get_event_name(expected->id), get_event_name(actual->id));
 476             }
 477
 478             flush_sequence(seq, sequence_index);
 479             return;
 480         }
 481         else
 482         {
 483             ok_(file, line) (FALSE, "%s: call %s was expected, but got call %s instead\n",
 484                 context, get_event_name(expected->id), get_event_name(actual->id));
 485             expected++;
 486             actual++;
 487         }
 488     }
 489
 490     if (todo)
 491     {
 492         todo_wine
 493         {
 494             if (expected->id != CH_ENDTEST || actual->id != CH_ENDTEST)
 495             {
 496                 failcount++;
 497                 ok_(file, line) (FALSE, "%s: the call sequence is not complete: expected %s - actual %s\n",
 498                     context, get_event_name(expected->id), get_event_name(actual->id));
 499             }
 500         }
 501     }
 502     else if (expected->id != CH_ENDTEST || actual->id != CH_ENDTEST)
 503     {
 504         ok_(file, line) (FALSE, "%s: the call sequence is not complete: expected %s - actual %s\n",
 505             context, get_event_name(expected->id), get_event_name(actual->id));
 506     }
 507
 508     if (todo && !failcount) /* succeeded yet marked todo */
 509     {
 510         todo_wine
 511         {
 512             ok_(file, line)(TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
 513         }
 514     }
 515
 516     flush_sequence(seq, sequence_index);
 517 }
 518
 519 #define ok_sequence(seq, index, exp, contx, todo) \
 520         ok_sequence_(seq, index, (exp), (contx), (todo), __FILE__, __LINE__)
 521
 522 static void init_call_sequences(struct call_sequence **seq, int n)
 523 {
 524     int i;
 525
 526     for (i = 0; i < n; i++)
 527         seq[i] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct call_sequence));
 528 }
 529
 530 static const WCHAR szSimpleXML[] = {
 531 '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\"','1','.','0','\"',' ','?','>','\n',
 532 '<','B','a','n','k','A','c','c','o','u','n','t','>','\n',
 533 ' ',' ',' ','<','N','u','m','b','e','r','>','1','2','3','4','<','/','N','u','m','b','e','r','>','\n',
 534 ' ',' ',' ','<','N','a','m','e','>','C','a','p','t','a','i','n',' ','A','h','a','b','<','/','N','a','m','e','>','\n',
 535 '<','/','B','a','n','k','A','c','c','o','u','n','t','>','\n','\0'
 536 };
 537
 538 static const WCHAR carriage_ret_test[] = {
 539 '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','"','1','.','0','"','?','>','\r','\n',
 540 '<','B','a','n','k','A','c','c','o','u','n','t','>','\r','\n',
 541 '\t','<','N','u','m','b','e','r','>','1','2','3','4','<','/','N','u','m','b','e','r','>','\r','\n',
 542 '\t','<','N','a','m','e','>','C','a','p','t','a','i','n',' ','A','h','a','b','<','/','N','a','m','e','>','\r','\n',
 543 '<','/','B','a','n','k','A','c','c','o','u','n','t','>','\r','\n','\0'
 544 };
 545
 546 static const WCHAR szUtf16XML[] = {
 547 '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','"','1','.','0','"',' ',
 548 'e','n','c','o','d','i','n','g','=','"','U','T','F','-','1','6','"',' ',
 549 's','t','a','n','d','a','l','o','n','e','=','"','n','o','"','?','>','\r','\n'
 550 };
 551
 552 static const CHAR szUtf16BOM[] = {0xff, 0xfe};
 553
 554 static const CHAR szUtf8XML[] =
 555 "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\r\n";
 556
 557 static const char utf8xml2[] =
 558 "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\r\n";
 559
 560 static const CHAR testXML[] =
 561 "<?xml version=\"1.0\" ?>\n"
 562 "<BankAccount>\n"
 563 "   <Number>1234</Number>\n"
 564 "   <Name>Captain Ahab</Name>\n"
 565 "</BankAccount>\n";
 566
 567 static const char test_attributes[] =
 568 "<?xml version=\"1.0\" ?>\n"
 569 "<document xmlns:test=\"prefix_test\" xmlns=\"prefix\" test:arg1=\"arg1\" arg2=\"arg2\" test:ar3=\"arg3\">\n"
 570 "<node1 xmlns:p=\"test\" />"
 571 "</document>\n";
 572
 573 static struct call_entry content_handler_test1[] = {
 574     { CH_PUTDOCUMENTLOCATOR, 0, 0, S_OK },
 575     { CH_STARTDOCUMENT, 0, 0, S_OK },
 576     { CH_STARTELEMENT, 2, 14, S_OK, "", "BankAccount", "BankAccount" },
 577     { CH_CHARACTERS, 2, 14, S_OK, "\n   " },
 578     { CH_STARTELEMENT, 3, 12, S_OK, "", "Number", "Number" },
 579     { CH_CHARACTERS, 3, 12, S_OK, "1234" },
 580     { CH_ENDELEMENT, 3, 18, S_OK, "", "Number", "Number" },
 581     { CH_CHARACTERS, 3, 25, S_OK, "\n   " },
 582     { CH_STARTELEMENT, 4, 10, S_OK, "", "Name", "Name" },
 583     { CH_CHARACTERS, 4, 10, S_OK, "Captain Ahab" },
 584     { CH_ENDELEMENT, 4, 24, S_OK, "", "Name", "Name" },
 585     { CH_CHARACTERS, 4, 29, S_OK, "\n" },
 586     { CH_ENDELEMENT, 5, 3, S_OK, "", "BankAccount", "BankAccount" },
 587     { CH_ENDDOCUMENT, 0, 0, S_OK},
 588     { CH_ENDTEST }
 589 };
 590
 591 /* applies to versions 4 and 6 */
 592 static struct call_entry content_handler_test1_alternate[] = {
 593     { CH_PUTDOCUMENTLOCATOR, 1, 0, S_OK },
 594     { CH_STARTDOCUMENT, 1, 22, S_OK },
 595     { CH_STARTELEMENT, 2, 13, S_OK, "", "BankAccount", "BankAccount" },
 596     { CH_CHARACTERS, 3, 4, S_OK, "\n   " },
 597     { CH_STARTELEMENT, 3, 11, S_OK, "", "Number", "Number" },
 598     { CH_CHARACTERS, 3, 16, S_OK, "1234" },
 599     { CH_ENDELEMENT, 3, 24, S_OK, "", "Number", "Number" },
 600     { CH_CHARACTERS, 4, 4, S_OK, "\n   " },
 601     { CH_STARTELEMENT, 4, 9, S_OK, "", "Name", "Name" },
 602     { CH_CHARACTERS, 4, 22, S_OK, "Captain Ahab" },
 603     { CH_ENDELEMENT, 4, 28, S_OK, "", "Name", "Name" },
 604     { CH_CHARACTERS, 5, 1, S_OK, "\n" },
 605     { CH_ENDELEMENT, 5, 14, S_OK, "", "BankAccount", "BankAccount" },
 606     { CH_ENDDOCUMENT, 6, 0, S_OK },
 607     { CH_ENDTEST }
 608 };
 609
 610 static struct call_entry content_handler_test2[] = {
 611     { CH_PUTDOCUMENTLOCATOR, 0, 0, S_OK },
 612     { CH_STARTDOCUMENT, 0, 0, S_OK },
 613     { CH_STARTELEMENT, 2, 14, S_OK, "", "BankAccount", "BankAccount" },
 614     { CH_CHARACTERS, 2, 14, S_OK, "\n" },
 615     { CH_CHARACTERS, 2, 16, S_OK, "\t" },
 616     { CH_STARTELEMENT, 3, 10, S_OK, "", "Number", "Number" },
 617     { CH_CHARACTERS, 3, 10, S_OK, "1234" },
 618     { CH_ENDELEMENT, 3, 16, S_OK, "", "Number", "Number" },
 619     { CH_CHARACTERS, 3, 23, S_OK, "\n" },
 620     { CH_CHARACTERS, 3, 25, S_OK, "\t" },
 621     { CH_STARTELEMENT, 4, 8, S_OK, "", "Name", "Name" },
 622     { CH_CHARACTERS, 4, 8, S_OK, "Captain Ahab" },
 623     { CH_ENDELEMENT, 4, 22, S_OK, "", "Name", "Name" },
 624     { CH_CHARACTERS, 4, 27, S_OK, "\n" },
 625     { CH_ENDELEMENT, 5, 3, S_OK, "", "BankAccount", "BankAccount" },
 626     { CH_ENDDOCUMENT, 0, 0, S_OK },
 627     { CH_ENDTEST }
 628 };
 629
 630 static struct call_entry content_handler_test2_alternate[] = {
 631     { CH_PUTDOCUMENTLOCATOR, 1, 0, S_OK },
 632     { CH_STARTDOCUMENT, 1, 21, S_OK },
 633     { CH_STARTELEMENT, 2, 13, S_OK, "", "BankAccount", "BankAccount" },
 634     { CH_CHARACTERS, 3, 0, S_OK, "\n" },
 635     { CH_CHARACTERS, 3, 2, S_OK, "\t" },
 636     { CH_STARTELEMENT, 3, 9, S_OK, "", "Number", "Number" },
 637     { CH_CHARACTERS, 3, 14, S_OK, "1234" },
 638     { CH_ENDELEMENT, 3, 22, S_OK, "", "Number", "Number" },
 639     { CH_CHARACTERS, 4, 0, S_OK, "\n" },
 640     { CH_CHARACTERS, 4, 2, S_OK, "\t" },
 641     { CH_STARTELEMENT, 4, 7, S_OK, "", "Name", "Name" },
 642     { CH_CHARACTERS, 4, 20, S_OK, "Captain Ahab" },
 643     { CH_ENDELEMENT, 4, 26, S_OK, "", "Name", "Name" },
 644     { CH_CHARACTERS, 5, 0, S_OK, "\n" },
 645     { CH_ENDELEMENT, 5, 14, S_OK, "", "BankAccount", "BankAccount" },
 646     { CH_ENDDOCUMENT, 6, 0, S_OK },
 647     { CH_ENDTEST }
 648 };
 649
 650 static struct call_entry content_handler_testerror[] = {
 651     { CH_PUTDOCUMENTLOCATOR, 0, 0, E_FAIL },
 652     { EH_FATALERROR, 0, 0, E_FAIL },
 653     { CH_ENDTEST }
 654 };
 655
 656 static struct call_entry content_handler_testerror_alternate[] = {
 657     { CH_PUTDOCUMENTLOCATOR, 1, 0, E_FAIL },
 658     { EH_FATALERROR, 1, 0, E_FAIL },
 659     { CH_ENDTEST }
 660 };
 661
 662 static struct call_entry content_handler_test_callback_rets[] = {
 663     { CH_PUTDOCUMENTLOCATOR, 0, 0, S_FALSE },
 664     { CH_STARTDOCUMENT, 0, 0, S_FALSE },
 665     { EH_FATALERROR, 0, 0, S_FALSE },
 666     { CH_ENDTEST }
 667 };
 668
 669 static struct call_entry content_handler_test_callback_rets_alt[] = {
 670     { CH_PUTDOCUMENTLOCATOR, 1, 0, S_FALSE },
 671     { CH_STARTDOCUMENT, 1, 22, S_FALSE },
 672     { CH_STARTELEMENT, 2, 13, S_FALSE, "", "BankAccount", "BankAccount" },
 673     { CH_CHARACTERS, 3, 4, S_FALSE, "\n   " },
 674     { CH_STARTELEMENT, 3, 11, S_FALSE, "", "Number", "Number" },
 675     { CH_CHARACTERS, 3, 16, S_FALSE, "1234" },
 676     { CH_ENDELEMENT, 3, 24, S_FALSE, "", "Number", "Number" },
 677     { CH_CHARACTERS, 4, 4, S_FALSE, "\n   " },
 678     { CH_STARTELEMENT, 4, 9, S_FALSE, "", "Name", "Name" },
 679     { CH_CHARACTERS, 4, 22, S_FALSE, "Captain Ahab" },
 680     { CH_ENDELEMENT, 4, 28, S_FALSE, "", "Name", "Name" },
 681     { CH_CHARACTERS, 5, 1, S_FALSE, "\n" },
 682     { CH_ENDELEMENT, 5, 14, S_FALSE, "", "BankAccount", "BankAccount" },
 683     { CH_ENDDOCUMENT, 6, 0, S_FALSE },
 684     { CH_ENDTEST }
 685 };
 686
 687 static struct attribute_entry ch_attributes1[] = {
 688     { "", "", "xmlns:test", "prefix_test" },
 689     { "", "", "xmlns", "prefix" },
 690     { "prefix_test", "arg1", "test:arg1", "arg1" },
 691     { "", "arg2", "arg2", "arg2" },
 692     { "prefix_test", "ar3", "test:ar3", "arg3" },
 693     { NULL }
 694 };
 695
 696 static struct attribute_entry ch_attributes2[] = {
 697     { "", "", "xmlns:p", "test" },
 698     { NULL }
 699 };
 700
 701 static struct call_entry content_handler_test_attributes[] = {
 702     { CH_PUTDOCUMENTLOCATOR, 0, 0, S_OK },
 703     { CH_STARTDOCUMENT, 0, 0, S_OK },
 704     { CH_STARTPREFIXMAPPING, 2, 96, S_OK, "test", "prefix_test" },
 705     { CH_STARTPREFIXMAPPING, 2, 96, S_OK, "", "prefix" },
 706     { CH_STARTELEMENT, 2, 96, S_OK, "prefix", "document", "document", ch_attributes1 },
 707     { CH_CHARACTERS, 2, 96, S_OK, "\n" },
 708     { CH_STARTPREFIXMAPPING, 3, 25, S_OK, "p", "test" },
 709     { CH_STARTELEMENT, 3, 25, S_OK, "prefix", "node1", "node1", ch_attributes2 },
 710     { CH_ENDELEMENT, 3, 25, S_OK, "prefix", "node1", "node1" },
 711     { CH_ENDPREFIXMAPPING, 3, 25, S_OK, "p" },
 712     { CH_ENDELEMENT, 3, 27, S_OK, "prefix", "document", "document" },
 713     { CH_ENDPREFIXMAPPING, 3, 27, S_OK, "" },
 714     { CH_ENDPREFIXMAPPING, 3, 27, S_OK, "test" },
 715     { CH_ENDDOCUMENT, 0, 0 },
 716     { CH_ENDTEST }
 717 };
 718
 719 static struct attribute_entry ch_attributes_alt_4[] = {
 720     { "prefix_test", "arg1", "test:arg1", "arg1" },
 721     { "", "arg2", "arg2", "arg2" },
 722     { "prefix_test", "ar3", "test:ar3", "arg3" },
 723     { "", "", "xmlns:test", "prefix_test" },
 724     { "", "", "xmlns", "prefix" },
 725     { NULL }
 726 };
 727
 728 static struct call_entry content_handler_test_attributes_alternate_4[] = {
 729     { CH_PUTDOCUMENTLOCATOR, 1, 0, S_OK },
 730     { CH_STARTDOCUMENT, 1, 22, S_OK },
 731     { CH_STARTPREFIXMAPPING, 2, 95, S_OK, "test", "prefix_test" },
 732     { CH_STARTPREFIXMAPPING, 2, 95, S_OK, "", "prefix" },
 733     { CH_STARTELEMENT, 2, 95, S_OK, "prefix", "document", "document", ch_attributes_alt_4 },
 734     { CH_CHARACTERS, 3, 1, S_OK, "\n" },
 735     { CH_STARTPREFIXMAPPING, 3, 24, S_OK, "p", "test" },
 736     { CH_STARTELEMENT, 3, 24, S_OK, "prefix", "node1", "node1", ch_attributes2 },
 737     { CH_ENDELEMENT, 3, 24, S_OK, "prefix", "node1", "node1" },
 738     { CH_ENDPREFIXMAPPING, 3, 24, S_OK, "p" },
 739     { CH_ENDELEMENT, 3, 35, S_OK, "prefix", "document", "document" },
 740     { CH_ENDPREFIXMAPPING, 3, 35, S_OK, "test" },
 741     { CH_ENDPREFIXMAPPING, 3, 35, S_OK, "" },
 742     { CH_ENDDOCUMENT, 4, 0, S_OK },
 743     { CH_ENDTEST }
 744 };
 745
 746 /* 'namespace' feature switched off */
 747 static struct attribute_entry ch_attributes_alt_no_ns[] = {
 748     { "", "", "xmlns:test", "prefix_test" },
 749     { "", "", "xmlns", "prefix" },
 750     { "", "", "test:arg1", "arg1" },
 751     { "", "", "arg2", "arg2" },
 752     { "", "", "test:ar3", "arg3" },
 753     { NULL }
 754 };
 755
 756 static struct call_entry content_handler_test_attributes_alt_no_ns[] = {
 757     { CH_PUTDOCUMENTLOCATOR, 1, 0, S_OK },
 758     { CH_STARTDOCUMENT, 1, 22, S_OK },
 759     { CH_STARTELEMENT, 2, 95, S_OK, "", "", "document", ch_attributes_alt_no_ns },
 760     { CH_CHARACTERS, 3, 1, S_OK, "\n" },
 761     { CH_STARTELEMENT, 3, 24, S_OK, "", "", "node1", ch_attributes2 },
 762     { CH_ENDELEMENT, 3, 24, S_OK, "", "", "node1" },
 763     { CH_ENDELEMENT, 3, 35, S_OK, "", "", "document" },
 764     { CH_ENDDOCUMENT, 4, 0, S_OK },
 765     { CH_ENDTEST }
 766 };
 767
 768 static struct attribute_entry ch_attributes_alt_6[] = {
 769     { "prefix_test", "arg1", "test:arg1", "arg1" },
 770     { "", "arg2", "arg2", "arg2" },
 771     { "prefix_test", "ar3", "test:ar3", "arg3" },
 772     { "http://www.w3.org/2000/xmlns/", "", "xmlns:test", "prefix_test" },
 773     { "http://www.w3.org/2000/xmlns/", "", "xmlns", "prefix" },
 774     { NULL }
 775 };
 776
 777 static struct attribute_entry ch_attributes2_6[] = {
 778     { "http://www.w3.org/2000/xmlns/", "", "xmlns:p", "test" },
 779     { NULL }
 780 };
 781
 782 static struct call_entry content_handler_test_attributes_alternate_6[] = {
 783     { CH_PUTDOCUMENTLOCATOR, 1, 0, S_OK },
 784     { CH_STARTDOCUMENT, 1, 22, S_OK },
 785     { CH_STARTPREFIXMAPPING, 2, 95, S_OK, "test", "prefix_test" },
 786     { CH_STARTPREFIXMAPPING, 2, 95, S_OK, "", "prefix" },
 787     { CH_STARTELEMENT, 2, 95, S_OK, "prefix", "document", "document", ch_attributes_alt_6 },
 788     { CH_CHARACTERS, 3, 1, S_OK, "\n" },
 789     { CH_STARTPREFIXMAPPING, 3, 24, S_OK, "p", "test" },
 790     { CH_STARTELEMENT, 3, 24, S_OK, "prefix", "node1", "node1", ch_attributes2_6 },
 791     { CH_ENDELEMENT, 3, 24, S_OK, "prefix", "node1", "node1" },
 792     { CH_ENDPREFIXMAPPING, 3, 24, S_OK, "p" },
 793     { CH_ENDELEMENT, 3, 35, S_OK, "prefix", "document", "document" },
 794     { CH_ENDPREFIXMAPPING, 3, 35, S_OK, "test" },
 795     { CH_ENDPREFIXMAPPING, 3, 35, S_OK, "" },
 796     { CH_ENDDOCUMENT, 4, 0, S_OK },
 797     { CH_ENDTEST }
 798 };
 799
 800 /* 'namespaces' is on, 'namespace-prefixes' if off */
 801 static struct attribute_entry ch_attributes_no_prefix[] = {
 802     { "prefix_test", "arg1", "test:arg1", "arg1" },
 803     { "", "arg2", "arg2", "arg2" },
 804     { "prefix_test", "ar3", "test:ar3", "arg3" },
 805     { NULL }
 806 };
 807
 808 static struct call_entry content_handler_test_attributes_alt_no_prefix[] = {
 809     { CH_PUTDOCUMENTLOCATOR, 1, 0, S_OK },
 810     { CH_STARTDOCUMENT, 1, 22, S_OK },
 811     { CH_STARTPREFIXMAPPING, 2, 95, S_OK, "test", "prefix_test" },
 812     { CH_STARTPREFIXMAPPING, 2, 95, S_OK, "", "prefix" },
 813     { CH_STARTELEMENT, 2, 95, S_OK, "prefix", "document", "document", ch_attributes_no_prefix },
 814     { CH_CHARACTERS, 3, 1, S_OK, "\n" },
 815     { CH_STARTPREFIXMAPPING, 3, 24, S_OK, "p", "test" },
 816     { CH_STARTELEMENT, 3, 24, S_OK, "prefix", "node1", "node1", NULL },
 817     { CH_ENDELEMENT, 3, 24, S_OK, "prefix", "node1", "node1" },
 818     { CH_ENDPREFIXMAPPING, 3, 24, S_OK, "p" },
 819     { CH_ENDELEMENT, 3, 35, S_OK, "prefix", "document", "document" },
 820     { CH_ENDPREFIXMAPPING, 3, 35, S_OK, "test" },
 821     { CH_ENDPREFIXMAPPING, 3, 35, S_OK, "" },
 822     { CH_ENDDOCUMENT, 4, 0, S_OK },
 823     { CH_ENDTEST }
 824 };
 825
 826 static struct call_entry content_handler_test_attributes_no_prefix[] = {
 827     { CH_PUTDOCUMENTLOCATOR, 0, 0, S_OK },
 828     { CH_STARTDOCUMENT, 0, 0, S_OK },
 829     { CH_STARTPREFIXMAPPING, 2, 96, S_OK, "test", "prefix_test" },
 830     { CH_STARTPREFIXMAPPING, 2, 96, S_OK, "", "prefix" },
 831     { CH_STARTELEMENT, 2, 96, S_OK, "prefix", "document", "document", ch_attributes_no_prefix },
 832     { CH_CHARACTERS, 2, 96, S_OK, "\n" },
 833     { CH_STARTPREFIXMAPPING, 3, 25, S_OK, "p", "test" },
 834     { CH_STARTELEMENT, 3, 25, S_OK, "prefix", "node1", "node1", NULL },
 835     { CH_ENDELEMENT, 3, 25, S_OK, "prefix", "node1", "node1" },
 836     { CH_ENDPREFIXMAPPING, 3, 25, S_OK, "p" },
 837     { CH_ENDELEMENT, 3, 27, S_OK, "prefix", "document", "document" },
 838     { CH_ENDPREFIXMAPPING, 3, 27, S_OK, "" },
 839     { CH_ENDPREFIXMAPPING, 3, 27, S_OK, "test" },
 840     { CH_ENDDOCUMENT, 0, 0 },
 841     { CH_ENDTEST }
 842 };
 843
 844 static struct attribute_entry xmlspace_attrs[] = {
 845     { "http://www.w3.org/XML/1998/namespace", "space", "xml:space", "preserve" },
 846     { NULL }
 847 };
 848
 849 static struct call_entry xmlspaceattr_test[] = {
 850     { CH_PUTDOCUMENTLOCATOR, 0, 0, S_OK },
 851     { CH_STARTDOCUMENT, 0, 0, S_OK },
 852     { CH_STARTELEMENT, 1, 64, S_OK, "", "a", "a", xmlspace_attrs },
 853     { CH_CHARACTERS, 1, 64, S_OK, " Some text data " },
 854     { CH_ENDELEMENT, 1, 82, S_OK, "", "a", "a" },
 855     { CH_ENDDOCUMENT, 0, 0, S_OK },
 856     { CH_ENDTEST }
 857 };
 858
 859 static struct call_entry xmlspaceattr_test_alternate[] = {
 860     { CH_PUTDOCUMENTLOCATOR, 1, 0, S_OK },
 861     { CH_STARTDOCUMENT, 1, 39, S_OK },
 862     { CH_STARTELEMENT, 1, 63, S_OK, "", "a", "a", xmlspace_attrs },
 863     { CH_CHARACTERS, 1, 80, S_OK, " Some text data " },
 864     { CH_ENDELEMENT, 1, 83, S_OK, "", "a", "a" },
 865     { CH_ENDDOCUMENT, 1, 83, S_OK },
 866     { CH_ENDTEST }
 867 };
 868
 869 /* attribute value normalization test */
 870 static const char attribute_normalize[] =
 871     "<?xml version=\"1.0\" ?>\n"
 872     "<a attr1=\" \r \n \tattr_value &#65; \t \r \n\r\n \n\"/>\n";
 873
 874 static struct attribute_entry attribute_norm_attrs[] = {
 875     { "", "attr1", "attr1", "      attr_value A         " },
 876     { NULL }
 877 };
 878
 879 static struct call_entry attribute_norm[] = {
 880     { CH_PUTDOCUMENTLOCATOR, 0, 0, S_OK },
 881     { CH_STARTDOCUMENT, 0, 0, S_OK },
 882     { CH_STARTELEMENT, 6, 4, S_OK, "", "a", "a", attribute_norm_attrs },
 883     { CH_ENDELEMENT, 6, 4, S_OK, "", "a", "a" },
 884     { CH_ENDDOCUMENT, 0, 0, S_OK },
 885     { CH_ENDTEST }
 886 };
 887
 888 static struct call_entry attribute_norm_alt[] = {
 889     { CH_PUTDOCUMENTLOCATOR, 1, 0, S_OK },
 890     { CH_STARTDOCUMENT, 1, 22, S_OK },
 891     { CH_STARTELEMENT, 8, 3, S_OK, "", "a", "a", attribute_norm_attrs },
 892     { CH_ENDELEMENT, 8, 3, S_OK, "", "a", "a" },
 893     { CH_ENDDOCUMENT, 9, 0, S_OK },
 894     { CH_ENDTEST }
 895 };
 896
 897 static const char xmlspace_attr[] =
 898     "<?xml version=\"1.0\" encoding=\"UTF-16\"?>"
 899     "<a xml:space=\"preserve\"> Some text data </a>";
 900
 901 static struct call_entry *expectCall;
 902 static ISAXLocator *locator;
 903 static ISAXXMLReader *g_reader;
 904 int msxml_version;
 905
 906 static void set_expected_seq(struct call_entry *expected)
 907 {
 908     expectCall = expected;
 909 }
 910
 911 /* to be called once on each tested callback return */
 912 static HRESULT get_expected_ret(void)
 913 {
 914     HRESULT hr = expectCall->ret;
 915     if (expectCall->id != CH_ENDTEST) expectCall++;
 916     return hr;
 917 }
 918
 919 static HRESULT WINAPI contentHandler_QueryInterface(
 920         ISAXContentHandler* iface,
 921         REFIID riid,
 922         void **ppvObject)
 923 {
 924     *ppvObject = NULL;
 925
 926     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXContentHandler))
 927     {
 928         *ppvObject = iface;
 929     }
 930     else
 931     {
 932         return E_NOINTERFACE;
 933     }
 934
 935     return S_OK;
 936 }
 937
 938 static ULONG WINAPI contentHandler_AddRef(
 939         ISAXContentHandler* iface)
 940 {
 941     return 2;
 942 }
 943
 944 static ULONG WINAPI contentHandler_Release(
 945         ISAXContentHandler* iface)
 946 {
 947     return 1;
 948 }
 949
 950 static HRESULT WINAPI contentHandler_putDocumentLocator(
 951         ISAXContentHandler* iface,
 952         ISAXLocator *pLocator)
 953 {
 954     struct call_entry call;
 955     HRESULT hr;
 956
 957     locator = pLocator;
 958
 959     init_call_entry(locator, &call);
 960     call.id = CH_PUTDOCUMENTLOCATOR;
 961     add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 962
 963     if (msxml_version >= 6) {
 964         ISAXAttributes *attr, *attr1;
 965         IMXAttributes *mxattr;
 966
 967         EXPECT_REF(pLocator, 1);
 968         hr = ISAXLocator_QueryInterface(pLocator, &IID_ISAXAttributes, (void**)&attr);
 969         EXPECT_HR(hr, S_OK);
 970         EXPECT_REF(pLocator, 2);
 971         hr = ISAXLocator_QueryInterface(pLocator, &IID_ISAXAttributes, (void**)&attr1);
 972         EXPECT_HR(hr, S_OK);
 973         EXPECT_REF(pLocator, 3);
 974         ok(attr == attr1, "got %p, %p\n", attr, attr1);
 975
 976         hr = ISAXAttributes_QueryInterface(attr, &IID_IMXAttributes, (void**)&mxattr);
 977         EXPECT_HR(hr, E_NOINTERFACE);
 978
 979         ISAXAttributes_Release(attr);
 980         ISAXAttributes_Release(attr1);
 981     }
 982
 983     return get_expected_ret();
 984 }
 985
 986 static ISAXAttributes *test_attr_ptr;
 987 static HRESULT WINAPI contentHandler_startDocument(
 988         ISAXContentHandler* iface)
 989 {
 990     struct call_entry call;
 991
 992     init_call_entry(locator, &call);
 993     call.id = CH_STARTDOCUMENT;
 994     add_call(sequences, CONTENT_HANDLER_INDEX, &call);
 995
 996     test_attr_ptr = NULL;
 997
 998     return get_expected_ret();
 999 }
1000
1001 static HRESULT WINAPI contentHandler_endDocument(
1002         ISAXContentHandler* iface)
1003 {
1004     struct call_entry call;
1005
1006     init_call_entry(locator, &call);
1007     call.id = CH_ENDDOCUMENT;
1008     add_call(sequences, CONTENT_HANDLER_INDEX, &call);
1009
1010     return get_expected_ret();
1011 }
1012
1013 static HRESULT WINAPI contentHandler_startPrefixMapping(
1014         ISAXContentHandler* iface,
1015         const WCHAR *prefix, int prefix_len,
1016         const WCHAR *uri, int uri_len)
1017 {
1018     struct call_entry call;
1019
1020     init_call_entry(locator, &call);
1021     call.id = CH_STARTPREFIXMAPPING;
1022     call.arg1W = SysAllocStringLen(prefix, prefix_len);
1023     call.arg2W = SysAllocStringLen(uri, uri_len);
1024     add_call(sequences, CONTENT_HANDLER_INDEX, &call);
1025
1026     return get_expected_ret();
1027 }
1028
1029 static HRESULT WINAPI contentHandler_endPrefixMapping(
1030         ISAXContentHandler* iface,
1031         const WCHAR *prefix, int len)
1032 {
1033     struct call_entry call;
1034
1035     init_call_entry(locator, &call);
1036     call.id = CH_ENDPREFIXMAPPING;
1037     call.arg1W = SysAllocStringLen(prefix, len);
1038     add_call(sequences, CONTENT_HANDLER_INDEX, &call);
1039
1040     return get_expected_ret();
1041 }
1042
1043 static HRESULT WINAPI contentHandler_startElement(
1044         ISAXContentHandler* iface,
1045         const WCHAR *uri, int uri_len,
1046         const WCHAR *localname, int local_len,
1047         const WCHAR *qname, int qname_len,
1048         ISAXAttributes *saxattr)
1049 {
1050     struct call_entry call;
1051     IMXAttributes *mxattr;
1052     HRESULT hr;
1053     int len;
1054
1055     hr = ISAXAttributes_QueryInterface(saxattr, &IID_IMXAttributes, (void**)&mxattr);
1056     EXPECT_HR(hr, E_NOINTERFACE);
1057
1058     init_call_entry(locator, &call);
1059     call.id = CH_STARTELEMENT;
1060     call.arg1W = SysAllocStringLen(uri, uri_len);
1061     call.arg2W = SysAllocStringLen(localname, local_len);
1062     call.arg3W = SysAllocStringLen(qname, qname_len);
1063
1064     if(!test_attr_ptr)
1065         test_attr_ptr = saxattr;
1066     ok(test_attr_ptr == saxattr, "Multiple ISAXAttributes instances are used (%p %p)\n", test_attr_ptr, saxattr);
1067
1068     /* store actual attributes */
1069     len = 0;
1070     hr = ISAXAttributes_getLength(saxattr, &len);
1071     EXPECT_HR(hr, S_OK);
1072
1073     if (len)
1074     {
1075         VARIANT_BOOL v;
1076         int i;
1077
1078         struct attribute_entry *attr;
1079         attr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(struct attribute_entry));
1080
1081         v = VARIANT_TRUE;
1082         hr = ISAXXMLReader_getFeature(g_reader, _bstr_("http://xml.org/sax/features/namespaces"), &v);
1083         EXPECT_HR(hr, S_OK);
1084
1085         for (i = 0; i < len; i++)
1086         {
1087             const WCHAR *value;
1088             int value_len;
1089
1090             hr = ISAXAttributes_getName(saxattr, i, &uri, &uri_len,
1091                 &localname, &local_len, &qname, &qname_len);
1092             EXPECT_HR(hr, S_OK);
1093
1094             hr = ISAXAttributes_getValue(saxattr, i, &value, &value_len);
1095             EXPECT_HR(hr, S_OK);
1096
1097             /* if 'namespaces' switched off uri and local name contains garbage */
1098             if (v == VARIANT_FALSE && msxml_version > 0)
1099             {
1100                 attr[i].uriW   = SysAllocStringLen(NULL, 0);
1101                 attr[i].localW = SysAllocStringLen(NULL, 0);
1102             }
1103             else
1104             {
1105                 attr[i].uriW   = SysAllocStringLen(uri, uri_len);
1106                 attr[i].localW = SysAllocStringLen(localname, local_len);
1107             }
1108
1109             attr[i].qnameW = SysAllocStringLen(qname, qname_len);
1110             attr[i].valueW = SysAllocStringLen(value, value_len);
1111         }
1112
1113         call.attributes = attr;
1114         call.attr_count = len;
1115     }
1116
1117     add_call(sequences, CONTENT_HANDLER_INDEX, &call);
1118
1119     return get_expected_ret();
1120 }
1121
1122 static HRESULT WINAPI contentHandler_endElement(
1123         ISAXContentHandler* iface,
1124         const WCHAR *uri, int uri_len,
1125         const WCHAR *localname, int local_len,
1126         const WCHAR *qname, int qname_len)
1127 {
1128     struct call_entry call;
1129
1130     init_call_entry(locator, &call);
1131     call.id = CH_ENDELEMENT;
1132     call.arg1W = SysAllocStringLen(uri, uri_len);
1133     call.arg2W = SysAllocStringLen(localname, local_len);
1134     call.arg3W = SysAllocStringLen(qname, qname_len);
1135     add_call(sequences, CONTENT_HANDLER_INDEX, &call);
1136
1137     return get_expected_ret();
1138 }
1139
1140 static HRESULT WINAPI contentHandler_characters(
1141         ISAXContentHandler* iface,
1142         const WCHAR *chars,
1143         int len)
1144 {
1145     struct call_entry call;
1146
1147     init_call_entry(locator, &call);
1148     call.id = CH_CHARACTERS;
1149     call.arg1W = SysAllocStringLen(chars, len);
1150     add_call(sequences, CONTENT_HANDLER_INDEX, &call);
1151
1152     return get_expected_ret();
1153 }
1154
1155 static HRESULT WINAPI contentHandler_ignorableWhitespace(
1156         ISAXContentHandler* iface,
1157         const WCHAR *chars, int len)
1158 {
1159     struct call_entry call;
1160
1161     init_call_entry(locator, &call);
1162     call.id = CH_IGNORABLEWHITESPACE;
1163     call.arg1W = SysAllocStringLen(chars, len);
1164     add_call(sequences, CONTENT_HANDLER_INDEX, &call);
1165
1166     return get_expected_ret();
1167 }
1168
1169 static HRESULT WINAPI contentHandler_processingInstruction(
1170         ISAXContentHandler* iface,
1171         const WCHAR *target, int target_len,
1172         const WCHAR *data, int data_len)
1173 {
1174     struct call_entry call;
1175
1176     init_call_entry(locator, &call);
1177     call.id = CH_PROCESSINGINSTRUCTION;
1178     call.arg1W = SysAllocStringLen(target, target_len);
1179     call.arg2W = SysAllocStringLen(data, data_len);
1180     add_call(sequences, CONTENT_HANDLER_INDEX, &call);
1181
1182     return get_expected_ret();
1183 }
1184
1185 static HRESULT WINAPI contentHandler_skippedEntity(
1186         ISAXContentHandler* iface,
1187         const WCHAR *name, int len)
1188 {
1189     struct call_entry call;
1190
1191     init_call_entry(locator, &call);
1192     call.id = CH_SKIPPEDENTITY;
1193     call.arg1W = SysAllocStringLen(name, len);
1194
1195     return get_expected_ret();
1196 }
1197
1198 static const ISAXContentHandlerVtbl contentHandlerVtbl =
1199 {
1200     contentHandler_QueryInterface,
1201     contentHandler_AddRef,
1202     contentHandler_Release,
1203     contentHandler_putDocumentLocator,
1204     contentHandler_startDocument,
1205     contentHandler_endDocument,
1206     contentHandler_startPrefixMapping,
1207     contentHandler_endPrefixMapping,
1208     contentHandler_startElement,
1209     contentHandler_endElement,
1210     contentHandler_characters,
1211     contentHandler_ignorableWhitespace,
1212     contentHandler_processingInstruction,
1213     contentHandler_skippedEntity
1214 };
1215
1216 static ISAXContentHandler contentHandler = { &contentHandlerVtbl };
1217
1218 static HRESULT WINAPI isaxerrorHandler_QueryInterface(
1219         ISAXErrorHandler* iface,
1220         REFIID riid,
1221         void **ppvObject)
1222 {
1223     *ppvObject = NULL;
1224
1225     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXErrorHandler))
1226     {
1227         *ppvObject = iface;
1228     }
1229     else
1230     {
1231         return E_NOINTERFACE;
1232     }
1233
1234     return S_OK;
1235 }
1236
1237 static ULONG WINAPI isaxerrorHandler_AddRef(
1238         ISAXErrorHandler* iface)
1239 {
1240     return 2;
1241 }
1242
1243 static ULONG WINAPI isaxerrorHandler_Release(
1244         ISAXErrorHandler* iface)
1245 {
1246     return 1;
1247 }
1248
1249 static HRESULT WINAPI isaxerrorHandler_error(
1250         ISAXErrorHandler* iface,
1251         ISAXLocator *pLocator,
1252         const WCHAR *pErrorMessage,
1253         HRESULT hrErrorCode)
1254 {
1255     ok(0, "unexpected call\n");
1256     return S_OK;
1257 }
1258
1259 static HRESULT WINAPI isaxerrorHandler_fatalError(
1260         ISAXErrorHandler* iface,
1261         ISAXLocator *pLocator,
1262         const WCHAR *message,
1263         HRESULT hr)
1264 {
1265     struct call_entry call;
1266
1267     init_call_entry(locator, &call);
1268     call.id  = EH_FATALERROR;
1269     call.ret = hr;
1270
1271     add_call(sequences, CONTENT_HANDLER_INDEX, &call);
1272
1273     get_expected_ret();
1274     return S_OK;
1275 }
1276
1277 static HRESULT WINAPI isaxerrorHanddler_ignorableWarning(
1278         ISAXErrorHandler* iface,
1279         ISAXLocator *pLocator,
1280         const WCHAR *pErrorMessage,
1281         HRESULT hrErrorCode)
1282 {
1283     ok(0, "unexpected call\n");
1284     return S_OK;
1285 }
1286
1287 static const ISAXErrorHandlerVtbl errorHandlerVtbl =
1288 {
1289     isaxerrorHandler_QueryInterface,
1290     isaxerrorHandler_AddRef,
1291     isaxerrorHandler_Release,
1292     isaxerrorHandler_error,
1293     isaxerrorHandler_fatalError,
1294     isaxerrorHanddler_ignorableWarning
1295 };
1296
1297 static ISAXErrorHandler errorHandler = { &errorHandlerVtbl };
1298
1299 static HRESULT WINAPI isaxattributes_QueryInterface(
1300         ISAXAttributes* iface,
1301         REFIID riid,
1302         void **ppvObject)
1303 {
1304     *ppvObject = NULL;
1305
1306     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXAttributes))
1307     {
1308         *ppvObject = iface;
1309     }
1310     else
1311     {
1312         return E_NOINTERFACE;
1313     }
1314
1315     return S_OK;
1316 }
1317
1318 static ULONG WINAPI isaxattributes_AddRef(ISAXAttributes* iface)
1319 {
1320     return 2;
1321 }
1322
1323 static ULONG WINAPI isaxattributes_Release(ISAXAttributes* iface)
1324 {
1325     return 1;
1326 }
1327
1328 static HRESULT WINAPI isaxattributes_getLength(ISAXAttributes* iface, int *length)
1329 {
1330     *length = 3;
1331     return S_OK;
1332 }
1333
1334 static HRESULT WINAPI isaxattributes_getURI(
1335     ISAXAttributes* iface,
1336     int nIndex,
1337     const WCHAR **pUrl,
1338     int *pUriSize)
1339 {
1340     ok(0, "unexpected call\n");
1341     return E_NOTIMPL;
1342 }
1343
1344 static HRESULT WINAPI isaxattributes_getLocalName(
1345     ISAXAttributes* iface,
1346     int nIndex,
1347     const WCHAR **pLocalName,
1348     int *pLocalNameLength)
1349 {
1350     ok(0, "unexpected call\n");
1351     return E_NOTIMPL;
1352 }
1353
1354 static HRESULT WINAPI isaxattributes_getQName(
1355     ISAXAttributes* iface,
1356     int index,
1357     const WCHAR **QName,
1358     int *QNameLength)
1359 {
1360     static const WCHAR attrqnamesW[][15] = {{'a',':','a','t','t','r','1','j','u','n','k',0},
1361                                             {'a','t','t','r','2','j','u','n','k',0},
1362                                             {'a','t','t','r','3',0}};
1363     static const int attrqnamelen[] = {7, 5, 5};
1364
1365     ok(index >= 0 && index <= 2, "invalid index received %d\n", index);
1366
1367     *QName = attrqnamesW[index];
1368     *QNameLength = attrqnamelen[index];
1369
1370     return S_OK;
1371 }
1372
1373 static HRESULT WINAPI isaxattributes_getName(
1374     ISAXAttributes* iface,
1375     int nIndex,
1376     const WCHAR **pUri,
1377     int * pUriLength,
1378     const WCHAR ** pLocalName,
1379     int * pLocalNameSize,
1380     const WCHAR ** pQName,
1381     int * pQNameLength)
1382 {
1383     ok(0, "unexpected call\n");
1384     return E_NOTIMPL;
1385 }
1386
1387 static HRESULT WINAPI isaxattributes_getIndexFromName(
1388     ISAXAttributes* iface,
1389     const WCHAR * pUri,
1390     int cUriLength,
1391     const WCHAR * pLocalName,
1392     int cocalNameLength,
1393     int * index)
1394 {
1395     ok(0, "unexpected call\n");
1396     return E_NOTIMPL;
1397 }
1398
1399 static HRESULT WINAPI isaxattributes_getIndexFromQName(
1400     ISAXAttributes* iface,
1401     const WCHAR * pQName,
1402     int nQNameLength,
1403     int * index)
1404 {
1405     ok(0, "unexpected call\n");
1406     return E_NOTIMPL;
1407 }
1408
1409 static HRESULT WINAPI isaxattributes_getType(
1410     ISAXAttributes* iface,
1411     int nIndex,
1412     const WCHAR ** pType,
1413     int * pTypeLength)
1414 {
1415     ok(0, "unexpected call\n");
1416     return E_NOTIMPL;
1417 }
1418
1419 static HRESULT WINAPI isaxattributes_getTypeFromName(
1420     ISAXAttributes* iface,
1421     const WCHAR * pUri,
1422     int nUri,
1423     const WCHAR * pLocalName,
1424     int nLocalName,
1425     const WCHAR ** pType,
1426     int * nType)
1427 {
1428     ok(0, "unexpected call\n");
1429     return E_NOTIMPL;
1430 }
1431
1432 static HRESULT WINAPI isaxattributes_getTypeFromQName(
1433     ISAXAttributes* iface,
1434     const WCHAR * pQName,
1435     int nQName,
1436     const WCHAR ** pType,
1437     int * nType)
1438 {
1439     ok(0, "unexpected call\n");
1440     return E_NOTIMPL;
1441 }
1442
1443 static HRESULT WINAPI isaxattributes_getValue(ISAXAttributes* iface, int index,
1444     const WCHAR **value, int *nValue)
1445 {
1446     static const WCHAR attrvaluesW[][10] = {{'a','1','j','u','n','k',0},
1447                                             {'a','2','j','u','n','k',0},
1448                                             {'<','&','"','>',0}};
1449     static const int attrvalueslen[] = {2, 2, 4};
1450
1451     ok(index >= 0 && index <= 2, "invalid index received %d\n", index);
1452
1453     *value = attrvaluesW[index];
1454     *nValue = attrvalueslen[index];
1455
1456     return S_OK;
1457 }
1458
1459 static HRESULT WINAPI isaxattributes_getValueFromName(
1460     ISAXAttributes* iface,
1461     const WCHAR * pUri,
1462     int nUri,
1463     const WCHAR * pLocalName,
1464     int nLocalName,
1465     const WCHAR ** pValue,
1466     int * nValue)
1467 {
1468     ok(0, "unexpected call\n");
1469     return E_NOTIMPL;
1470 }
1471
1472 static HRESULT WINAPI isaxattributes_getValueFromQName(
1473     ISAXAttributes* iface,
1474     const WCHAR * pQName,
1475     int nQName,
1476     const WCHAR ** pValue,
1477     int * nValue)
1478 {
1479     ok(0, "unexpected call\n");
1480     return E_NOTIMPL;
1481 }
1482
1483 static const ISAXAttributesVtbl SAXAttributesVtbl =
1484 {
1485     isaxattributes_QueryInterface,
1486     isaxattributes_AddRef,
1487     isaxattributes_Release,
1488     isaxattributes_getLength,
1489     isaxattributes_getURI,
1490     isaxattributes_getLocalName,
1491     isaxattributes_getQName,
1492     isaxattributes_getName,
1493     isaxattributes_getIndexFromName,
1494     isaxattributes_getIndexFromQName,
1495     isaxattributes_getType,
1496     isaxattributes_getTypeFromName,
1497     isaxattributes_getTypeFromQName,
1498     isaxattributes_getValue,
1499     isaxattributes_getValueFromName,
1500     isaxattributes_getValueFromQName
1501 };
1502
1503 static ISAXAttributes saxattributes = { &SAXAttributesVtbl };
1504
1505 struct saxlexicalhandler
1506 {
1507     ISAXLexicalHandler ISAXLexicalHandler_iface;
1508     LONG ref;
1509
1510     HRESULT qi_hr; /* ret value for QueryInterface for handler riid */
1511 };
1512
1513 static inline struct saxlexicalhandler *impl_from_ISAXLexicalHandler( ISAXLexicalHandler *iface )
1514 {
1515     return CONTAINING_RECORD(iface, struct saxlexicalhandler, ISAXLexicalHandler_iface);
1516 }
1517
1518 static HRESULT WINAPI isaxlexical_QueryInterface(ISAXLexicalHandler* iface, REFIID riid, void **out)
1519 {
1520     struct saxlexicalhandler *handler = impl_from_ISAXLexicalHandler(iface);
1521
1522     *out = NULL;
1523
1524     if (IsEqualGUID(riid, &IID_IUnknown))
1525     {
1526         *out = iface;
1527         ok(0, "got unexpected IID_IUnknown query\n");
1528     }
1529     else if (IsEqualGUID(riid, &IID_ISAXLexicalHandler))
1530     {
1531         if (handler->qi_hr == E_NOINTERFACE) return handler->qi_hr;
1532         *out = iface;
1533     }
1534
1535     if (*out)
1536         ISAXLexicalHandler_AddRef(iface);
1537     else
1538         return E_NOINTERFACE;
1539
1540     return S_OK;
1541 }
1542
1543 static ULONG WINAPI isaxlexical_AddRef(ISAXLexicalHandler* iface)
1544 {
1545     struct saxlexicalhandler *handler = impl_from_ISAXLexicalHandler(iface);
1546     return InterlockedIncrement(&handler->ref);
1547 }
1548
1549 static ULONG WINAPI isaxlexical_Release(ISAXLexicalHandler* iface)
1550 {
1551     struct saxlexicalhandler *handler = impl_from_ISAXLexicalHandler(iface);
1552     return InterlockedDecrement(&handler->ref);
1553 }
1554
1555 static HRESULT WINAPI isaxlexical_startDTD(ISAXLexicalHandler* iface,
1556     const WCHAR * pName, int nName, const WCHAR * pPublicId,
1557     int nPublicId, const WCHAR * pSystemId, int nSystemId)
1558 {
1559     ok(0, "call not expected\n");
1560     return E_NOTIMPL;
1561 }
1562
1563 static HRESULT WINAPI isaxlexical_endDTD(ISAXLexicalHandler* iface)
1564 {
1565     ok(0, "call not expected\n");
1566     return E_NOTIMPL;
1567 }
1568
1569 static HRESULT WINAPI isaxlexical_startEntity(ISAXLexicalHandler *iface,
1570     const WCHAR * pName, int nName)
1571 {
1572     ok(0, "call not expected\n");
1573     return E_NOTIMPL;
1574 }
1575
1576 static HRESULT WINAPI isaxlexical_endEntity(ISAXLexicalHandler *iface,
1577     const WCHAR * pName, int nName)
1578 {
1579     ok(0, "call not expected\n");
1580     return E_NOTIMPL;
1581 }
1582
1583 static HRESULT WINAPI isaxlexical_startCDATA(ISAXLexicalHandler *iface)
1584 {
1585     ok(0, "call not expected\n");
1586     return E_NOTIMPL;
1587 }
1588
1589 static HRESULT WINAPI isaxlexical_endCDATA(ISAXLexicalHandler *iface)
1590 {
1591     ok(0, "call not expected\n");
1592     return E_NOTIMPL;
1593 }
1594
1595 static HRESULT WINAPI isaxlexical_comment(ISAXLexicalHandler *iface,
1596     const WCHAR * pChars, int nChars)
1597 {
1598     ok(0, "call not expected\n");
1599     return E_NOTIMPL;
1600 }
1601
1602 static const ISAXLexicalHandlerVtbl SAXLexicalHandlerVtbl =
1603 {
1604    isaxlexical_QueryInterface,
1605    isaxlexical_AddRef,
1606    isaxlexical_Release,
1607    isaxlexical_startDTD,
1608    isaxlexical_endDTD,
1609    isaxlexical_startEntity,
1610    isaxlexical_endEntity,
1611    isaxlexical_startCDATA,
1612    isaxlexical_endCDATA,
1613    isaxlexical_comment
1614 };
1615
1616 static void init_saxlexicalhandler(struct saxlexicalhandler *handler, HRESULT hr)
1617 {
1618     handler->ISAXLexicalHandler_iface.lpVtbl = &SAXLexicalHandlerVtbl;
1619     handler->ref = 1;
1620     handler->qi_hr = hr;
1621 }
1622
1623 struct saxdeclhandler
1624 {
1625     ISAXDeclHandler ISAXDeclHandler_iface;
1626     LONG ref;
1627
1628     HRESULT qi_hr; /* ret value for QueryInterface for handler riid */
1629 };
1630
1631 static inline struct saxdeclhandler *impl_from_ISAXDeclHandler( ISAXDeclHandler *iface )
1632 {
1633     return CONTAINING_RECORD(iface, struct saxdeclhandler, ISAXDeclHandler_iface);
1634 }
1635
1636 static HRESULT WINAPI isaxdecl_QueryInterface(ISAXDeclHandler* iface, REFIID riid, void **out)
1637 {
1638     struct saxdeclhandler *handler = impl_from_ISAXDeclHandler(iface);
1639
1640     *out = NULL;
1641
1642     if (IsEqualGUID(riid, &IID_IUnknown))
1643     {
1644         *out = iface;
1645         ok(0, "got unexpected IID_IUnknown query\n");
1646     }
1647     else if (IsEqualGUID(riid, &IID_ISAXDeclHandler))
1648     {
1649         if (handler->qi_hr == E_NOINTERFACE) return handler->qi_hr;
1650         *out = iface;
1651     }
1652
1653     if (*out)
1654         ISAXDeclHandler_AddRef(iface);
1655     else
1656         return E_NOINTERFACE;
1657
1658     return S_OK;
1659 }
1660
1661 static ULONG WINAPI isaxdecl_AddRef(ISAXDeclHandler* iface)
1662 {
1663     struct saxdeclhandler *handler = impl_from_ISAXDeclHandler(iface);
1664     return InterlockedIncrement(&handler->ref);
1665 }
1666
1667 static ULONG WINAPI isaxdecl_Release(ISAXDeclHandler* iface)
1668 {
1669     struct saxdeclhandler *handler = impl_from_ISAXDeclHandler(iface);
1670     return InterlockedDecrement(&handler->ref);
1671 }
1672
1673 static HRESULT WINAPI isaxdecl_elementDecl(ISAXDeclHandler* iface,
1674     const WCHAR * pName, int nName, const WCHAR * pModel, int nModel)
1675 {
1676     ok(0, "call not expected\n");
1677     return E_NOTIMPL;
1678 }
1679
1680 static HRESULT WINAPI isaxdecl_attributeDecl(ISAXDeclHandler* iface,
1681     const WCHAR * pElementName, int nElementName, const WCHAR * pAttributeName,
1682     int nAttributeName, const WCHAR * pType, int nType, const WCHAR * pValueDefault,
1683     int nValueDefault, const WCHAR * pValue, int nValue)
1684 {
1685     ok(0, "call not expected\n");
1686     return E_NOTIMPL;
1687 }
1688
1689 static HRESULT WINAPI isaxdecl_internalEntityDecl(ISAXDeclHandler* iface,
1690     const WCHAR * pName, int nName, const WCHAR * pValue, int nValue)
1691 {
1692     ok(0, "call not expected\n");
1693     return E_NOTIMPL;
1694 }
1695
1696 static HRESULT WINAPI isaxdecl_externalEntityDecl(ISAXDeclHandler* iface,
1697     const WCHAR * pName, int nName, const WCHAR * pPublicId, int nPublicId,
1698     const WCHAR * pSystemId, int nSystemId)
1699 {
1700     ok(0, "call not expected\n");
1701     return E_NOTIMPL;
1702 }
1703
1704 static const ISAXDeclHandlerVtbl SAXDeclHandlerVtbl =
1705 {
1706    isaxdecl_QueryInterface,
1707    isaxdecl_AddRef,
1708    isaxdecl_Release,
1709    isaxdecl_elementDecl,
1710    isaxdecl_attributeDecl,
1711    isaxdecl_internalEntityDecl,
1712    isaxdecl_externalEntityDecl
1713 };
1714
1715 static void init_saxdeclhandler(struct saxdeclhandler *handler, HRESULT hr)
1716 {
1717     handler->ISAXDeclHandler_iface.lpVtbl = &SAXDeclHandlerVtbl;
1718     handler->ref = 1;
1719     handler->qi_hr = hr;
1720 }
1721
1722 typedef struct mxwriter_write_test_t {
1723     BOOL        last;
1724     const BYTE  *data;
1725     DWORD       cb;
1726     BOOL        null_written;
1727     BOOL        fail_write;
1728 } mxwriter_write_test;
1729
1730 typedef struct mxwriter_stream_test_t {
1731     VARIANT_BOOL        bom;
1732     const char          *encoding;
1733     mxwriter_write_test expected_writes[4];
1734 } mxwriter_stream_test;
1735
1736 static const mxwriter_write_test *current_write_test;
1737 static DWORD current_stream_test_index;
1738
1739 static HRESULT WINAPI istream_QueryInterface(IStream *iface, REFIID riid, void **ppvObject)
1740 {
1741     *ppvObject = NULL;
1742
1743     if(IsEqualGUID(riid, &IID_IStream) || IsEqualGUID(riid, &IID_IUnknown))
1744         *ppvObject = iface;
1745     else
1746         return E_NOINTERFACE;
1747
1748     return S_OK;
1749 }
1750
1751 static ULONG WINAPI istream_AddRef(IStream *iface)
1752 {
1753     return 2;
1754 }
1755
1756 static ULONG WINAPI istream_Release(IStream *iface)
1757 {
1758     return 1;
1759 }
1760
1761 static HRESULT WINAPI istream_Read(IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
1762 {
1763     ok(0, "unexpected call\n");
1764     return E_NOTIMPL;
1765 }
1766
1767 static HRESULT WINAPI istream_Write(IStream *iface, const void *pv, ULONG cb, ULONG *pcbWritten)
1768 {
1769     BOOL fail = FALSE;
1770
1771     ok(pv != NULL, "pv == NULL\n");
1772
1773     if(current_write_test->last) {
1774         ok(0, "Too many Write calls made on test %d\n", current_stream_test_index);
1775         return E_FAIL;
1776     }
1777
1778     fail = current_write_test->fail_write;
1779
1780     ok(current_write_test->cb == cb, "Expected %d, but got %d on test %d\n",
1781         current_write_test->cb, cb, current_stream_test_index);
1782
1783     if(!pcbWritten)
1784         ok(current_write_test->null_written, "pcbWritten was NULL on test %d\n", current_stream_test_index);
1785     else
1786         ok(!memcmp(current_write_test->data, pv, cb), "Unexpected data on test %d\n", current_stream_test_index);
1787
1788     ++current_write_test;
1789
1790     if(pcbWritten)
1791         *pcbWritten = cb;
1792
1793     return fail ? E_FAIL : S_OK;
1794 }
1795
1796 static HRESULT WINAPI istream_Seek(IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin,
1797         ULARGE_INTEGER *plibNewPosition)
1798 {
1799     ok(0, "unexpected call\n");
1800     return E_NOTIMPL;
1801 }
1802
1803 static HRESULT WINAPI istream_SetSize(IStream *iface, ULARGE_INTEGER libNewSize)
1804 {
1805     ok(0, "unexpected call\n");
1806     return E_NOTIMPL;
1807 }
1808
1809 static HRESULT WINAPI istream_CopyTo(IStream *iface, IStream *pstm, ULARGE_INTEGER cb,
1810         ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *plibWritten)
1811 {
1812     ok(0, "unexpected call\n");
1813     return E_NOTIMPL;
1814 }
1815
1816 static HRESULT WINAPI istream_Commit(IStream *iface, DWORD grfCommitFlags)
1817 {
1818     ok(0, "unexpected call\n");
1819     return E_NOTIMPL;
1820 }
1821
1822 static HRESULT WINAPI istream_Revert(IStream *iface)
1823 {
1824     ok(0, "unexpected call\n");
1825     return E_NOTIMPL;
1826 }
1827
1828 static HRESULT WINAPI istream_LockRegion(IStream *iface, ULARGE_INTEGER libOffset,
1829         ULARGE_INTEGER cb, DWORD dwLockType)
1830 {
1831     ok(0, "unexpected call\n");
1832     return E_NOTIMPL;
1833 }
1834
1835 static HRESULT WINAPI istream_UnlockRegion(IStream *iface, ULARGE_INTEGER libOffset,
1836         ULARGE_INTEGER cb, DWORD dwLockType)
1837 {
1838     ok(0, "unexpected call\n");
1839     return E_NOTIMPL;
1840 }
1841
1842 static HRESULT WINAPI istream_Stat(IStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
1843 {
1844     ok(0, "unexpected call\n");
1845     return E_NOTIMPL;
1846 }
1847
1848 static HRESULT WINAPI istream_Clone(IStream *iface, IStream **ppstm)
1849 {
1850     ok(0, "unexpected call\n");
1851     return E_NOTIMPL;
1852 }
1853
1854 static const IStreamVtbl StreamVtbl = {
1855     istream_QueryInterface,
1856     istream_AddRef,
1857     istream_Release,
1858     istream_Read,
1859     istream_Write,
1860     istream_Seek,
1861     istream_SetSize,
1862     istream_CopyTo,
1863     istream_Commit,
1864     istream_Revert,
1865     istream_LockRegion,
1866     istream_UnlockRegion,
1867     istream_Stat,
1868     istream_Clone
1869 };
1870
1871 static IStream mxstream = { &StreamVtbl };
1872
1873 static struct msxmlsupported_data_t reader_support_data[] =
1874 {
1875     { &CLSID_SAXXMLReader,   "SAXReader"   },
1876     { &CLSID_SAXXMLReader30, "SAXReader30" },
1877     { &CLSID_SAXXMLReader40, "SAXReader40" },
1878     { &CLSID_SAXXMLReader60, "SAXReader60" },
1879     { NULL }
1880 };
1881
1882 static void test_saxreader(void)
1883 {
1884     const struct msxmlsupported_data_t *table = reader_support_data;
1885     HRESULT hr;
1886     ISAXXMLReader *reader = NULL;
1887     VARIANT var;
1888     ISAXContentHandler *content;
1889     ISAXErrorHandler *lpErrorHandler;
1890     SAFEARRAY *sa;
1891     SAFEARRAYBOUND SADim[1];
1892     char *ptr = NULL;
1893     IStream *stream;
1894     ULARGE_INTEGER size;
1895     LARGE_INTEGER pos;
1896     ULONG written;
1897     HANDLE file;
1898     static const CHAR testXmlA[] = "test.xml";
1899     static const WCHAR testXmlW[] = {'t','e','s','t','.','x','m','l',0};
1900     IXMLDOMDocument *doc;
1901     VARIANT_BOOL v;
1902
1903     while (table->clsid)
1904     {
1905         struct call_entry *test_seq;
1906         BSTR str;
1907
1908         if (!is_clsid_supported(table->clsid, reader_support_data))
1909         {
1910             table++;
1911             continue;
1912         }
1913
1914         hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER, &IID_ISAXXMLReader, (void**)&reader);
1915         EXPECT_HR(hr, S_OK);
1916         g_reader = reader;
1917
1918         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40))
1919             msxml_version = 4;
1920         else if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
1921             msxml_version = 6;
1922         else
1923             msxml_version = 0;
1924
1925         /* crashes on old versions */
1926         if (!IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) &&
1927             !IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
1928         {
1929             hr = ISAXXMLReader_getContentHandler(reader, NULL);
1930             EXPECT_HR(hr, E_POINTER);
1931
1932             hr = ISAXXMLReader_getErrorHandler(reader, NULL);
1933             EXPECT_HR(hr, E_POINTER);
1934         }
1935
1936         hr = ISAXXMLReader_getContentHandler(reader, &content);
1937         EXPECT_HR(hr, S_OK);
1938         ok(content == NULL, "Expected %p, got %p\n", NULL, content);
1939
1940         hr = ISAXXMLReader_getErrorHandler(reader, &lpErrorHandler);
1941         EXPECT_HR(hr, S_OK);
1942         ok(lpErrorHandler == NULL, "Expected %p, got %p\n", NULL, lpErrorHandler);
1943
1944         hr = ISAXXMLReader_putContentHandler(reader, NULL);
1945         EXPECT_HR(hr, S_OK);
1946
1947         hr = ISAXXMLReader_putContentHandler(reader, &contentHandler);
1948         EXPECT_HR(hr, S_OK);
1949
1950         hr = ISAXXMLReader_putErrorHandler(reader, &errorHandler);
1951         EXPECT_HR(hr, S_OK);
1952
1953         hr = ISAXXMLReader_getContentHandler(reader, &content);
1954         EXPECT_HR(hr, S_OK);
1955         ok(content == &contentHandler, "Expected %p, got %p\n", &contentHandler, content);
1956
1957         V_VT(&var) = VT_BSTR;
1958         V_BSTR(&var) = SysAllocString(szSimpleXML);
1959
1960         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) ||
1961             IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
1962             test_seq = content_handler_test1_alternate;
1963         else
1964             test_seq = content_handler_test1;
1965         set_expected_seq(test_seq);
1966         hr = ISAXXMLReader_parse(reader, var);
1967         EXPECT_HR(hr, S_OK);
1968         ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 1", FALSE);
1969
1970         VariantClear(&var);
1971
1972         SADim[0].lLbound = 0;
1973         SADim[0].cElements = sizeof(testXML)-1;
1974         sa = SafeArrayCreate(VT_UI1, 1, SADim);
1975         SafeArrayAccessData(sa, (void**)&ptr);
1976         memcpy(ptr, testXML, sizeof(testXML)-1);
1977         SafeArrayUnaccessData(sa);
1978         V_VT(&var) = VT_ARRAY|VT_UI1;
1979         V_ARRAY(&var) = sa;
1980
1981         set_expected_seq(test_seq);
1982         hr = ISAXXMLReader_parse(reader, var);
1983         EXPECT_HR(hr, S_OK);
1984         ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 1: from safe array", FALSE);
1985
1986         SafeArrayDestroy(sa);
1987
1988         CreateStreamOnHGlobal(NULL, TRUE, &stream);
1989         size.QuadPart = strlen(testXML);
1990         IStream_SetSize(stream, size);
1991         IStream_Write(stream, testXML, strlen(testXML), &written);
1992         pos.QuadPart = 0;
1993         IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
1994         V_VT(&var) = VT_UNKNOWN;
1995         V_UNKNOWN(&var) = (IUnknown*)stream;
1996
1997         set_expected_seq(test_seq);
1998         hr = ISAXXMLReader_parse(reader, var);
1999         EXPECT_HR(hr, S_OK);
2000         ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 1: from stream", FALSE);
2001
2002         IStream_Release(stream);
2003
2004         CreateStreamOnHGlobal(NULL, TRUE, &stream);
2005         size.QuadPart = strlen(test_attributes);
2006         IStream_SetSize(stream, size);
2007         IStream_Write(stream, test_attributes, strlen(test_attributes), &written);
2008         pos.QuadPart = 0;
2009         IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
2010         V_VT(&var) = VT_UNKNOWN;
2011         V_UNKNOWN(&var) = (IUnknown*)stream;
2012
2013         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40))
2014             test_seq = content_handler_test_attributes_alternate_4;
2015         else if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
2016             test_seq = content_handler_test_attributes_alternate_6;
2017         else
2018             test_seq = content_handler_test_attributes;
2019
2020         set_expected_seq(test_seq);
2021         hr = ISAXXMLReader_parse(reader, var);
2022         EXPECT_HR(hr, S_OK);
2023
2024         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) ||
2025             IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
2026             ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test attributes", FALSE);
2027         else
2028             ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test attributes", TRUE);
2029
2030         IStream_Release(stream);
2031
2032         V_VT(&var) = VT_BSTR;
2033         V_BSTR(&var) = SysAllocString(carriage_ret_test);
2034
2035         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) ||
2036             IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
2037             test_seq = content_handler_test2_alternate;
2038         else
2039             test_seq = content_handler_test2;
2040
2041         set_expected_seq(test_seq);
2042         hr = ISAXXMLReader_parse(reader, var);
2043         EXPECT_HR(hr, S_OK);
2044         ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 2", FALSE);
2045
2046         VariantClear(&var);
2047
2048         /* from file url */
2049         file = CreateFileA(testXmlA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2050         ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
2051         WriteFile(file, testXML, sizeof(testXML)-1, &written, NULL);
2052         CloseHandle(file);
2053
2054         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) ||
2055             IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
2056             test_seq = content_handler_test1_alternate;
2057         else
2058             test_seq = content_handler_test1;
2059         set_expected_seq(test_seq);
2060         hr = ISAXXMLReader_parseURL(reader, testXmlW);
2061         EXPECT_HR(hr, S_OK);
2062         ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test 1: from file url", FALSE);
2063
2064         /* error handler */
2065         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) ||
2066             IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
2067             test_seq = content_handler_testerror_alternate;
2068         else
2069             test_seq = content_handler_testerror;
2070         set_expected_seq(test_seq);
2071         hr = ISAXXMLReader_parseURL(reader, testXmlW);
2072         EXPECT_HR(hr, E_FAIL);
2073         ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test error", FALSE);
2074
2075         /* callback ret values */
2076         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) ||
2077             IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
2078         {
2079             test_seq = content_handler_test_callback_rets_alt;
2080             set_expected_seq(test_seq);
2081             hr = ISAXXMLReader_parseURL(reader, testXmlW);
2082             EXPECT_HR(hr, S_OK);
2083         }
2084         else
2085         {
2086             test_seq = content_handler_test_callback_rets;
2087             set_expected_seq(test_seq);
2088             hr = ISAXXMLReader_parseURL(reader, testXmlW);
2089             EXPECT_HR(hr, S_FALSE);
2090         }
2091         ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content callback ret values", FALSE);
2092
2093         DeleteFileA(testXmlA);
2094
2095         /* parse from IXMLDOMDocument */
2096         hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER,
2097                 &IID_IXMLDOMDocument, (void**)&doc);
2098         EXPECT_HR(hr, S_OK);
2099
2100         str = SysAllocString(szSimpleXML);
2101         hr = IXMLDOMDocument_loadXML(doc, str, &v);
2102         EXPECT_HR(hr, S_OK);
2103         SysFreeString(str);
2104
2105         V_VT(&var) = VT_UNKNOWN;
2106         V_UNKNOWN(&var) = (IUnknown*)doc;
2107
2108         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) ||
2109             IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
2110             test_seq = content_handler_test2_alternate;
2111         else
2112             test_seq = content_handler_test2;
2113
2114         set_expected_seq(test_seq);
2115         hr = ISAXXMLReader_parse(reader, var);
2116         EXPECT_HR(hr, S_OK);
2117         ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "parse from IXMLDOMDocument", FALSE);
2118         IXMLDOMDocument_Release(doc);
2119
2120         /* xml:space test */
2121         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) ||
2122             IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
2123         {
2124             test_seq = xmlspaceattr_test_alternate;
2125         }
2126         else
2127             test_seq = xmlspaceattr_test;
2128
2129         set_expected_seq(test_seq);
2130         V_VT(&var) = VT_BSTR;
2131         V_BSTR(&var) = _bstr_(xmlspace_attr);
2132         hr = ISAXXMLReader_parse(reader, var);
2133         EXPECT_HR(hr, S_OK);
2134
2135         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) ||
2136             IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
2137         {
2138             ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "xml:space handling", TRUE);
2139         }
2140         else
2141             ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "xml:space handling", FALSE);
2142
2143         /* switch off 'namespaces' feature */
2144         hr = ISAXXMLReader_putFeature(reader, _bstr_("http://xml.org/sax/features/namespaces"), VARIANT_FALSE);
2145         EXPECT_HR(hr, S_OK);
2146
2147         CreateStreamOnHGlobal(NULL, TRUE, &stream);
2148         size.QuadPart = strlen(test_attributes);
2149         IStream_SetSize(stream, size);
2150         IStream_Write(stream, test_attributes, strlen(test_attributes), &written);
2151         pos.QuadPart = 0;
2152         IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
2153         V_VT(&var) = VT_UNKNOWN;
2154         V_UNKNOWN(&var) = (IUnknown*)stream;
2155
2156         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) ||
2157             IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
2158         {
2159             test_seq = content_handler_test_attributes_alt_no_ns;
2160         }
2161         else
2162             test_seq = content_handler_test_attributes;
2163
2164         set_expected_seq(test_seq);
2165         hr = ISAXXMLReader_parse(reader, var);
2166         EXPECT_HR(hr, S_OK);
2167         ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test attributes", TRUE);
2168         hr = ISAXXMLReader_putFeature(reader, _bstr_("http://xml.org/sax/features/namespaces"), VARIANT_TRUE);
2169         EXPECT_HR(hr, S_OK);
2170
2171         /* switch off 'namespace-prefixes' feature */
2172         hr = ISAXXMLReader_putFeature(reader, _bstr_("http://xml.org/sax/features/namespace-prefixes"), VARIANT_FALSE);
2173         EXPECT_HR(hr, S_OK);
2174
2175         CreateStreamOnHGlobal(NULL, TRUE, &stream);
2176         size.QuadPart = strlen(test_attributes);
2177         IStream_SetSize(stream, size);
2178         IStream_Write(stream, test_attributes, strlen(test_attributes), &written);
2179         pos.QuadPart = 0;
2180         IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
2181         V_VT(&var) = VT_UNKNOWN;
2182         V_UNKNOWN(&var) = (IUnknown*)stream;
2183
2184         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) ||
2185             IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
2186         {
2187             test_seq = content_handler_test_attributes_alt_no_prefix;
2188         }
2189         else
2190             test_seq = content_handler_test_attributes_no_prefix;
2191
2192         set_expected_seq(test_seq);
2193         hr = ISAXXMLReader_parse(reader, var);
2194         EXPECT_HR(hr, S_OK);
2195         ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "content test attributes", FALSE);
2196
2197         hr = ISAXXMLReader_putFeature(reader, _bstr_("http://xml.org/sax/features/namespace-prefixes"), VARIANT_TRUE);
2198         EXPECT_HR(hr, S_OK);
2199
2200         /* attribute normalization */
2201         CreateStreamOnHGlobal(NULL, TRUE, &stream);
2202         size.QuadPart = strlen(attribute_normalize);
2203         IStream_SetSize(stream, size);
2204         IStream_Write(stream, attribute_normalize, strlen(attribute_normalize), &written);
2205         pos.QuadPart = 0;
2206         IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
2207         V_VT(&var) = VT_UNKNOWN;
2208         V_UNKNOWN(&var) = (IUnknown*)stream;
2209
2210         if (IsEqualGUID(table->clsid, &CLSID_SAXXMLReader40) ||
2211             IsEqualGUID(table->clsid, &CLSID_SAXXMLReader60))
2212         {
2213             test_seq = attribute_norm_alt;
2214         }
2215         else
2216             test_seq = attribute_norm;
2217
2218         set_expected_seq(test_seq);
2219         hr = ISAXXMLReader_parse(reader, var);
2220         EXPECT_HR(hr, S_OK);
2221         ok_sequence(sequences, CONTENT_HANDLER_INDEX, test_seq, "attribute value normalization", TRUE);
2222
2223         ISAXXMLReader_Release(reader);
2224         table++;
2225     }
2226
2227     free_bstrs();
2228 }
2229
2230 struct saxreader_props_test_t
2231 {
2232     const char *prop_name;
2233     IUnknown   *iface;
2234 };
2235
2236 static struct saxlexicalhandler lexicalhandler;
2237 static struct saxdeclhandler declhandler;
2238
2239 static const struct saxreader_props_test_t props_test_data[] = {
2240     { "http://xml.org/sax/properties/lexical-handler", (IUnknown*)&lexicalhandler.ISAXLexicalHandler_iface },
2241     { "http://xml.org/sax/properties/declaration-handler", (IUnknown*)&declhandler.ISAXDeclHandler_iface },
2242     { 0 }
2243 };
2244
2245 static void test_saxreader_properties(void)
2246 {
2247     const struct saxreader_props_test_t *ptr = props_test_data;
2248     ISAXXMLReader *reader;
2249     HRESULT hr;
2250
2251     hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
2252             &IID_ISAXXMLReader, (void**)&reader);
2253     EXPECT_HR(hr, S_OK);
2254
2255     hr = ISAXXMLReader_getProperty(reader, _bstr_("http://xml.org/sax/properties/lexical-handler"), NULL);
2256     EXPECT_HR(hr, E_POINTER);
2257
2258     while (ptr->prop_name)
2259     {
2260         VARIANT v;
2261         LONG ref;
2262
2263         init_saxlexicalhandler(&lexicalhandler, S_OK);
2264         init_saxdeclhandler(&declhandler, S_OK);
2265
2266         V_VT(&v) = VT_EMPTY;
2267         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
2268         hr = ISAXXMLReader_getProperty(reader, _bstr_(ptr->prop_name), &v);
2269         EXPECT_HR(hr, S_OK);
2270         ok(V_VT(&v) == VT_UNKNOWN, "got %d\n", V_VT(&v));
2271         ok(V_UNKNOWN(&v) == NULL, "got %p\n", V_UNKNOWN(&v));
2272
2273         V_VT(&v) = VT_UNKNOWN;
2274         V_UNKNOWN(&v) = ptr->iface;
2275         ref = get_refcount(ptr->iface);
2276         hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
2277         EXPECT_HR(hr, S_OK);
2278         ok(ref < get_refcount(ptr->iface), "expected inreased refcount\n");
2279
2280         V_VT(&v) = VT_EMPTY;
2281         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
2282
2283         ref = get_refcount(ptr->iface);
2284         hr = ISAXXMLReader_getProperty(reader, _bstr_(ptr->prop_name), &v);
2285         EXPECT_HR(hr, S_OK);
2286         ok(V_VT(&v) == VT_UNKNOWN, "got %d\n", V_VT(&v));
2287         ok(V_UNKNOWN(&v) == ptr->iface, "got %p\n", V_UNKNOWN(&v));
2288         ok(ref < get_refcount(ptr->iface), "expected inreased refcount\n");
2289         VariantClear(&v);
2290
2291         V_VT(&v) = VT_EMPTY;
2292         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
2293         hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
2294         EXPECT_HR(hr, S_OK);
2295
2296         V_VT(&v) = VT_EMPTY;
2297         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
2298         hr = ISAXXMLReader_getProperty(reader, _bstr_(ptr->prop_name), &v);
2299         EXPECT_HR(hr, S_OK);
2300         ok(V_VT(&v) == VT_UNKNOWN, "got %d\n", V_VT(&v));
2301         ok(V_UNKNOWN(&v) == NULL, "got %p\n", V_UNKNOWN(&v));
2302
2303         V_VT(&v) = VT_UNKNOWN;
2304         V_UNKNOWN(&v) = ptr->iface;
2305         hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
2306         EXPECT_HR(hr, S_OK);
2307
2308         /* only VT_EMPTY seems to be valid to reset property */
2309         V_VT(&v) = VT_I4;
2310         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
2311         hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
2312         EXPECT_HR(hr, E_INVALIDARG);
2313
2314         V_VT(&v) = VT_EMPTY;
2315         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
2316         hr = ISAXXMLReader_getProperty(reader, _bstr_(ptr->prop_name), &v);
2317         EXPECT_HR(hr, S_OK);
2318         ok(V_VT(&v) == VT_UNKNOWN, "got %d\n", V_VT(&v));
2319         ok(V_UNKNOWN(&v) == ptr->iface, "got %p\n", V_UNKNOWN(&v));
2320         VariantClear(&v);
2321
2322         V_VT(&v) = VT_UNKNOWN;
2323         V_UNKNOWN(&v) = NULL;
2324         hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
2325         EXPECT_HR(hr, S_OK);
2326
2327         V_VT(&v) = VT_EMPTY;
2328         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
2329         hr = ISAXXMLReader_getProperty(reader, _bstr_(ptr->prop_name), &v);
2330         EXPECT_HR(hr, S_OK);
2331         ok(V_VT(&v) == VT_UNKNOWN, "got %d\n", V_VT(&v));
2332         ok(V_UNKNOWN(&v) == NULL, "got %p\n", V_UNKNOWN(&v));
2333
2334         /* block QueryInterface on handler riid */
2335         V_VT(&v) = VT_UNKNOWN;
2336         V_UNKNOWN(&v) = ptr->iface;
2337         hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
2338         EXPECT_HR(hr, S_OK);
2339
2340         init_saxlexicalhandler(&lexicalhandler, E_NOINTERFACE);
2341         init_saxdeclhandler(&declhandler, E_NOINTERFACE);
2342
2343         V_VT(&v) = VT_UNKNOWN;
2344         V_UNKNOWN(&v) = ptr->iface;
2345         EXPECT_REF(ptr->iface, 1);
2346         ref = get_refcount(ptr->iface);
2347         hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
2348         EXPECT_HR(hr, E_NOINTERFACE);
2349         EXPECT_REF(ptr->iface, 1);
2350
2351         V_VT(&v) = VT_EMPTY;
2352         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
2353         hr = ISAXXMLReader_getProperty(reader, _bstr_(ptr->prop_name), &v);
2354         EXPECT_HR(hr, S_OK);
2355         ok(V_VT(&v) == VT_UNKNOWN, "got %d\n", V_VT(&v));
2356         ok(V_UNKNOWN(&v) != NULL, "got %p\n", V_UNKNOWN(&v));
2357
2358         ptr++;
2359     }
2360
2361     ISAXXMLReader_Release(reader);
2362     free_bstrs();
2363 }
2364
2365 struct feature_ns_entry_t {
2366     const GUID *guid;
2367     const char *clsid;
2368     VARIANT_BOOL value;
2369     VARIANT_BOOL value2; /* feature value after feature set to 0xc */
2370 };
2371
2372 static const struct feature_ns_entry_t feature_ns_entry_data[] = {
2373     { &CLSID_SAXXMLReader,   "CLSID_SAXXMLReader",   VARIANT_TRUE, VARIANT_FALSE },
2374     { &CLSID_SAXXMLReader30, "CLSID_SAXXMLReader30", VARIANT_TRUE, VARIANT_FALSE },
2375     { &CLSID_SAXXMLReader40, "CLSID_SAXXMLReader40", VARIANT_TRUE, VARIANT_TRUE },
2376     { &CLSID_SAXXMLReader60, "CLSID_SAXXMLReader60", VARIANT_TRUE, VARIANT_TRUE },
2377     { 0 }
2378 };
2379
2380 static const char *feature_names[] = {
2381     "http://xml.org/sax/features/namespaces",
2382     "http://xml.org/sax/features/namespace-prefixes",
2383     0
2384 };
2385
2386 static void test_saxreader_features(void)
2387 {
2388     const struct feature_ns_entry_t *entry = feature_ns_entry_data;
2389     ISAXXMLReader *reader;
2390
2391     while (entry->guid)
2392     {
2393         VARIANT_BOOL value;
2394         const char **name;
2395         HRESULT hr;
2396
2397         hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_ISAXXMLReader, (void**)&reader);
2398         if (hr != S_OK)
2399         {
2400             win_skip("can't create %s instance\n", entry->clsid);
2401             entry++;
2402             continue;
2403         }
2404
2405         name = feature_names;
2406         while (*name)
2407         {
2408             value = 0xc;
2409             hr = ISAXXMLReader_getFeature(reader, _bstr_(*name), &value);
2410             EXPECT_HR(hr, S_OK);
2411             ok(entry->value == value, "%s: got wrong default value %x, expected %x\n", entry->clsid, value, entry->value);
2412
2413             value = 0xc;
2414             hr = ISAXXMLReader_putFeature(reader, _bstr_(*name), value);
2415             EXPECT_HR(hr, S_OK);
2416
2417             value = 0xd;
2418             hr = ISAXXMLReader_getFeature(reader, _bstr_(*name), &value);
2419             EXPECT_HR(hr, S_OK);
2420             ok(entry->value2 == value, "%s: got wrong value %x, expected %x\n", entry->clsid, value, entry->value2);
2421
2422             hr = ISAXXMLReader_putFeature(reader, _bstr_(*name), VARIANT_FALSE);
2423             EXPECT_HR(hr, S_OK);
2424             value = 0xd;
2425             hr = ISAXXMLReader_getFeature(reader, _bstr_(*name), &value);
2426             EXPECT_HR(hr, S_OK);
2427             ok(value == VARIANT_FALSE, "%s: got wrong value %x, expected VARIANT_FALSE\n", entry->clsid, value);
2428
2429             hr = ISAXXMLReader_putFeature(reader, _bstr_(*name), VARIANT_TRUE);
2430             EXPECT_HR(hr, S_OK);
2431             value = 0xd;
2432             hr = ISAXXMLReader_getFeature(reader, _bstr_(*name), &value);
2433             EXPECT_HR(hr, S_OK);
2434             ok(value == VARIANT_TRUE, "%s: got wrong value %x, expected VARIANT_TRUE\n", entry->clsid, value);
2435
2436             name++;
2437         }
2438
2439         ISAXXMLReader_Release(reader);
2440
2441         entry++;
2442     }
2443 }
2444
2445 /* UTF-8 data with UTF-8 BOM and UTF-16 in prolog */
2446 static const CHAR UTF8BOMTest[] =
2447 "\xEF\xBB\xBF<?xml version = \"1.0\" encoding = \"UTF-16\"?>\n"
2448 "<a></a>\n";
2449
2450 struct enc_test_entry_t {
2451     const GUID *guid;
2452     const char *clsid;
2453     const char *data;
2454     HRESULT hr;
2455     int todo;
2456 };
2457
2458 static const struct enc_test_entry_t encoding_test_data[] = {
2459     { &CLSID_SAXXMLReader,   "CLSID_SAXXMLReader",   UTF8BOMTest, 0xc00ce56f, 1 },
2460     { &CLSID_SAXXMLReader30, "CLSID_SAXXMLReader30", UTF8BOMTest, 0xc00ce56f, 1 },
2461     { &CLSID_SAXXMLReader40, "CLSID_SAXXMLReader40", UTF8BOMTest, S_OK, 0 },
2462     { &CLSID_SAXXMLReader60, "CLSID_SAXXMLReader60", UTF8BOMTest, S_OK, 0 },
2463     { 0 }
2464 };
2465
2466 static void test_saxreader_encoding(void)
2467 {
2468     const struct enc_test_entry_t *entry = encoding_test_data;
2469     static const WCHAR testXmlW[] = {'t','e','s','t','.','x','m','l',0};
2470     static const CHAR testXmlA[] = "test.xml";
2471
2472     while (entry->guid)
2473     {
2474         ISAXXMLReader *reader;
2475         VARIANT input;
2476         DWORD written;
2477         HANDLE file;
2478         HRESULT hr;
2479
2480         hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_ISAXXMLReader, (void**)&reader);
2481         if (hr != S_OK)
2482         {
2483             win_skip("can't create %s instance\n", entry->clsid);
2484             entry++;
2485             continue;
2486         }
2487
2488         file = CreateFileA(testXmlA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2489         ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
2490         WriteFile(file, UTF8BOMTest, sizeof(UTF8BOMTest)-1, &written, NULL);
2491         CloseHandle(file);
2492
2493         hr = ISAXXMLReader_parseURL(reader, testXmlW);
2494         if (entry->todo)
2495             todo_wine ok(hr == entry->hr, "Expected 0x%08x, got 0x%08x. CLSID %s\n", entry->hr, hr, entry->clsid);
2496         else
2497             ok(hr == entry->hr, "Expected 0x%08x, got 0x%08x. CLSID %s\n", entry->hr, hr, entry->clsid);
2498
2499         DeleteFileA(testXmlA);
2500
2501         /* try BSTR input with no BOM or '<?xml' instruction */
2502         V_VT(&input) = VT_BSTR;
2503         V_BSTR(&input) = _bstr_("<element></element>");
2504         hr = ISAXXMLReader_parse(reader, input);
2505         EXPECT_HR(hr, S_OK);
2506
2507         ISAXXMLReader_Release(reader);
2508
2509         free_bstrs();
2510         entry++;
2511     }
2512 }
2513
2514 static void test_mxwriter_handlers(void)
2515 {
2516     ISAXContentHandler *handler;
2517     IMXWriter *writer, *writer2;
2518     ISAXDeclHandler *decl;
2519     ISAXLexicalHandler *lh;
2520     HRESULT hr;
2521
2522     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
2523             &IID_IMXWriter, (void**)&writer);
2524     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2525
2526     EXPECT_REF(writer, 1);
2527
2528     /* ISAXContentHandler */
2529     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&handler);
2530     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2531     EXPECT_REF(writer, 2);
2532     EXPECT_REF(handler, 2);
2533
2534     hr = ISAXContentHandler_QueryInterface(handler, &IID_IMXWriter, (void**)&writer2);
2535     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2536     ok(writer2 == writer, "got %p, expected %p\n", writer2, writer);
2537     EXPECT_REF(writer, 3);
2538     EXPECT_REF(writer2, 3);
2539     IMXWriter_Release(writer2);
2540     ISAXContentHandler_Release(handler);
2541
2542     /* ISAXLexicalHandler */
2543     hr = IMXWriter_QueryInterface(writer, &IID_ISAXLexicalHandler, (void**)&lh);
2544     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2545     EXPECT_REF(writer, 2);
2546     EXPECT_REF(lh, 2);
2547
2548     hr = ISAXLexicalHandler_QueryInterface(lh, &IID_IMXWriter, (void**)&writer2);
2549     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2550     ok(writer2 == writer, "got %p, expected %p\n", writer2, writer);
2551     EXPECT_REF(writer, 3);
2552     EXPECT_REF(writer2, 3);
2553     IMXWriter_Release(writer2);
2554     ISAXLexicalHandler_Release(lh);
2555
2556     /* ISAXDeclHandler */
2557     hr = IMXWriter_QueryInterface(writer, &IID_ISAXDeclHandler, (void**)&decl);
2558     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2559     EXPECT_REF(writer, 2);
2560     EXPECT_REF(lh, 2);
2561
2562     hr = ISAXDeclHandler_QueryInterface(decl, &IID_IMXWriter, (void**)&writer2);
2563     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2564     ok(writer2 == writer, "got %p, expected %p\n", writer2, writer);
2565     EXPECT_REF(writer, 3);
2566     EXPECT_REF(writer2, 3);
2567     IMXWriter_Release(writer2);
2568     ISAXDeclHandler_Release(decl);
2569
2570     IMXWriter_Release(writer);
2571 }
2572
2573
2574 static struct msxmlsupported_data_t mxwriter_support_data[] =
2575 {
2576     { &CLSID_MXXMLWriter,   "MXXMLWriter"   },
2577     { &CLSID_MXXMLWriter30, "MXXMLWriter30" },
2578     { &CLSID_MXXMLWriter40, "MXXMLWriter40" },
2579     { &CLSID_MXXMLWriter60, "MXXMLWriter60" },
2580     { NULL }
2581 };
2582
2583 static struct msxmlsupported_data_t mxattributes_support_data[] =
2584 {
2585     { &CLSID_SAXAttributes,   "SAXAttributes"   },
2586     { &CLSID_SAXAttributes30, "SAXAttributes30" },
2587     { &CLSID_SAXAttributes40, "SAXAttributes40" },
2588     { &CLSID_SAXAttributes60, "SAXAttributes60" },
2589     { NULL }
2590 };
2591
2592 struct mxwriter_props_t
2593 {
2594     const GUID *clsid;
2595     VARIANT_BOOL bom;
2596     VARIANT_BOOL disable_escape;
2597     VARIANT_BOOL indent;
2598     VARIANT_BOOL omitdecl;
2599     VARIANT_BOOL standalone;
2600     const char *encoding;
2601 };
2602
2603 static const struct mxwriter_props_t mxwriter_default_props[] =
2604 {
2605     { &CLSID_MXXMLWriter,   VARIANT_TRUE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, "UTF-16" },
2606     { &CLSID_MXXMLWriter30, VARIANT_TRUE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, "UTF-16" },
2607     { &CLSID_MXXMLWriter40, VARIANT_TRUE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, "UTF-16" },
2608     { &CLSID_MXXMLWriter60, VARIANT_TRUE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, "UTF-16" },
2609     { NULL }
2610 };
2611
2612 static void test_mxwriter_default_properties(const struct mxwriter_props_t *table)
2613 {
2614     int i = 0;
2615
2616     while (table->clsid)
2617     {
2618         IMXWriter *writer;
2619         VARIANT_BOOL b;
2620         BSTR encoding;
2621         HRESULT hr;
2622
2623         if (!is_clsid_supported(table->clsid, mxwriter_support_data))
2624         {
2625             table++;
2626             i++;
2627             continue;
2628         }
2629
2630         hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
2631             &IID_IMXWriter, (void**)&writer);
2632         EXPECT_HR(hr, S_OK);
2633
2634         b = !table->bom;
2635         hr = IMXWriter_get_byteOrderMark(writer, &b);
2636         EXPECT_HR(hr, S_OK);
2637         ok(table->bom == b, "test %d: got BOM %d, expected %d\n", i, b, table->bom);
2638
2639         b = !table->disable_escape;
2640         hr = IMXWriter_get_disableOutputEscaping(writer, &b);
2641         EXPECT_HR(hr, S_OK);
2642         ok(table->disable_escape == b, "test %d: got disable escape %d, expected %d\n", i, b,
2643            table->disable_escape);
2644
2645         b = !table->indent;
2646         hr = IMXWriter_get_indent(writer, &b);
2647         EXPECT_HR(hr, S_OK);
2648         ok(table->indent == b, "test %d: got indent %d, expected %d\n", i, b, table->indent);
2649
2650         b = !table->omitdecl;
2651         hr = IMXWriter_get_omitXMLDeclaration(writer, &b);
2652         EXPECT_HR(hr, S_OK);
2653         ok(table->omitdecl == b, "test %d: got omitdecl %d, expected %d\n", i, b, table->omitdecl);
2654
2655         b = !table->standalone;
2656         hr = IMXWriter_get_standalone(writer, &b);
2657         EXPECT_HR(hr, S_OK);
2658         ok(table->standalone == b, "test %d: got standalone %d, expected %d\n", i, b, table->standalone);
2659
2660         hr = IMXWriter_get_encoding(writer, &encoding);
2661         EXPECT_HR(hr, S_OK);
2662         ok(!lstrcmpW(encoding, _bstr_(table->encoding)), "test %d: got encoding %s, expected %s\n",
2663             i, wine_dbgstr_w(encoding), table->encoding);
2664         SysFreeString(encoding);
2665
2666         IMXWriter_Release(writer);
2667
2668         table++;
2669         i++;
2670     }
2671 }
2672
2673 static void test_mxwriter_properties(void)
2674 {
2675     static const WCHAR utf16W[] = {'U','T','F','-','1','6',0};
2676     static const WCHAR emptyW[] = {0};
2677     static const WCHAR testW[] = {'t','e','s','t',0};
2678     ISAXContentHandler *content;
2679     IMXWriter *writer;
2680     VARIANT_BOOL b;
2681     HRESULT hr;
2682     BSTR str, str2;
2683     VARIANT dest;
2684
2685     test_mxwriter_default_properties(mxwriter_default_props);
2686
2687     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
2688             &IID_IMXWriter, (void**)&writer);
2689     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2690
2691     hr = IMXWriter_get_disableOutputEscaping(writer, NULL);
2692     ok(hr == E_POINTER, "got %08x\n", hr);
2693
2694     hr = IMXWriter_get_byteOrderMark(writer, NULL);
2695     ok(hr == E_POINTER, "got %08x\n", hr);
2696
2697     hr = IMXWriter_get_indent(writer, NULL);
2698     ok(hr == E_POINTER, "got %08x\n", hr);
2699
2700     hr = IMXWriter_get_omitXMLDeclaration(writer, NULL);
2701     ok(hr == E_POINTER, "got %08x\n", hr);
2702
2703     hr = IMXWriter_get_standalone(writer, NULL);
2704     ok(hr == E_POINTER, "got %08x\n", hr);
2705
2706     /* set and check */
2707     hr = IMXWriter_put_standalone(writer, VARIANT_TRUE);
2708     ok(hr == S_OK, "got %08x\n", hr);
2709
2710     b = VARIANT_FALSE;
2711     hr = IMXWriter_get_standalone(writer, &b);
2712     ok(hr == S_OK, "got %08x\n", hr);
2713     ok(b == VARIANT_TRUE, "got %d\n", b);
2714
2715     hr = IMXWriter_get_encoding(writer, NULL);
2716     EXPECT_HR(hr, E_POINTER);
2717
2718     /* UTF-16 is a default setting apparently */
2719     str = (void*)0xdeadbeef;
2720     hr = IMXWriter_get_encoding(writer, &str);
2721     EXPECT_HR(hr, S_OK);
2722     ok(lstrcmpW(str, utf16W) == 0, "expected empty string, got %s\n", wine_dbgstr_w(str));
2723
2724     str2 = (void*)0xdeadbeef;
2725     hr = IMXWriter_get_encoding(writer, &str2);
2726     ok(hr == S_OK, "got %08x\n", hr);
2727     ok(str != str2, "expected newly allocated, got same %p\n", str);
2728
2729     SysFreeString(str2);
2730     SysFreeString(str);
2731
2732     /* put empty string */
2733     str = SysAllocString(emptyW);
2734     hr = IMXWriter_put_encoding(writer, str);
2735     ok(hr == E_INVALIDARG, "got %08x\n", hr);
2736     SysFreeString(str);
2737
2738     str = (void*)0xdeadbeef;
2739     hr = IMXWriter_get_encoding(writer, &str);
2740     EXPECT_HR(hr, S_OK);
2741     ok(!lstrcmpW(str, _bstr_("UTF-16")), "got %s\n", wine_dbgstr_w(str));
2742     SysFreeString(str);
2743
2744     /* invalid encoding name */
2745     str = SysAllocString(testW);
2746     hr = IMXWriter_put_encoding(writer, str);
2747     ok(hr == E_INVALIDARG, "got %08x\n", hr);
2748     SysFreeString(str);
2749
2750     /* test case sensivity */
2751     hr = IMXWriter_put_encoding(writer, _bstr_("utf-8"));
2752     EXPECT_HR(hr, S_OK);
2753     str = (void*)0xdeadbeef;
2754     hr = IMXWriter_get_encoding(writer, &str);
2755     EXPECT_HR(hr, S_OK);
2756     ok(!lstrcmpW(str, _bstr_("utf-8")), "got %s\n", wine_dbgstr_w(str));
2757     SysFreeString(str);
2758
2759     hr = IMXWriter_put_encoding(writer, _bstr_("uTf-16"));
2760     EXPECT_HR(hr, S_OK);
2761     str = (void*)0xdeadbeef;
2762     hr = IMXWriter_get_encoding(writer, &str);
2763     EXPECT_HR(hr, S_OK);
2764     ok(!lstrcmpW(str, _bstr_("uTf-16")), "got %s\n", wine_dbgstr_w(str));
2765     SysFreeString(str);
2766
2767     /* how it affects document creation */
2768     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
2769     EXPECT_HR(hr, S_OK);
2770
2771     hr = ISAXContentHandler_startDocument(content);
2772     EXPECT_HR(hr, S_OK);
2773     hr = ISAXContentHandler_endDocument(content);
2774     EXPECT_HR(hr, S_OK);
2775
2776     V_VT(&dest) = VT_EMPTY;
2777     hr = IMXWriter_get_output(writer, &dest);
2778     EXPECT_HR(hr, S_OK);
2779     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
2780     ok(!lstrcmpW(_bstr_("<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"yes\"?>\r\n"),
2781         V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
2782     VariantClear(&dest);
2783     ISAXContentHandler_Release(content);
2784
2785     hr = IMXWriter_get_version(writer, NULL);
2786     ok(hr == E_POINTER, "got %08x\n", hr);
2787     /* default version is 'surprisingly' 1.0 */
2788     hr = IMXWriter_get_version(writer, &str);
2789     ok(hr == S_OK, "got %08x\n", hr);
2790     ok(!lstrcmpW(str, _bstr_("1.0")), "got %s\n", wine_dbgstr_w(str));
2791     SysFreeString(str);
2792
2793     /* store version string as is */
2794     hr = IMXWriter_put_version(writer, NULL);
2795     ok(hr == E_INVALIDARG, "got %08x\n", hr);
2796
2797     hr = IMXWriter_put_version(writer, _bstr_("1.0"));
2798     ok(hr == S_OK, "got %08x\n", hr);
2799
2800     hr = IMXWriter_put_version(writer, _bstr_(""));
2801     ok(hr == S_OK, "got %08x\n", hr);
2802     hr = IMXWriter_get_version(writer, &str);
2803     ok(hr == S_OK, "got %08x\n", hr);
2804     ok(!lstrcmpW(str, _bstr_("")), "got %s\n", wine_dbgstr_w(str));
2805     SysFreeString(str);
2806
2807     hr = IMXWriter_put_version(writer, _bstr_("a.b"));
2808     ok(hr == S_OK, "got %08x\n", hr);
2809     hr = IMXWriter_get_version(writer, &str);
2810     ok(hr == S_OK, "got %08x\n", hr);
2811     ok(!lstrcmpW(str, _bstr_("a.b")), "got %s\n", wine_dbgstr_w(str));
2812     SysFreeString(str);
2813
2814     hr = IMXWriter_put_version(writer, _bstr_("2.0"));
2815     ok(hr == S_OK, "got %08x\n", hr);
2816     hr = IMXWriter_get_version(writer, &str);
2817     ok(hr == S_OK, "got %08x\n", hr);
2818     ok(!lstrcmpW(str, _bstr_("2.0")), "got %s\n", wine_dbgstr_w(str));
2819     SysFreeString(str);
2820
2821     IMXWriter_Release(writer);
2822     free_bstrs();
2823 }
2824
2825 static void test_mxwriter_flush(void)
2826 {
2827     static const WCHAR emptyW[] = {0};
2828     ISAXContentHandler *content;
2829     IMXWriter *writer;
2830     LARGE_INTEGER pos;
2831     ULARGE_INTEGER pos2;
2832     IStream *stream;
2833     VARIANT dest;
2834     HRESULT hr;
2835     char *buff;
2836     LONG ref;
2837     int len;
2838
2839     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
2840             &IID_IMXWriter, (void**)&writer);
2841     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2842
2843     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
2844     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2845     EXPECT_REF(stream, 1);
2846
2847     /* detach when nothing was attached */
2848     V_VT(&dest) = VT_EMPTY;
2849     hr = IMXWriter_put_output(writer, dest);
2850     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2851
2852     /* attach stream */
2853     V_VT(&dest) = VT_UNKNOWN;
2854     V_UNKNOWN(&dest) = (IUnknown*)stream;
2855     hr = IMXWriter_put_output(writer, dest);
2856     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2857     todo_wine EXPECT_REF(stream, 3);
2858
2859     /* detach setting VT_EMPTY destination */
2860     V_VT(&dest) = VT_EMPTY;
2861     hr = IMXWriter_put_output(writer, dest);
2862     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2863     EXPECT_REF(stream, 1);
2864
2865     V_VT(&dest) = VT_UNKNOWN;
2866     V_UNKNOWN(&dest) = (IUnknown*)stream;
2867     hr = IMXWriter_put_output(writer, dest);
2868     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2869
2870     /* flush() doesn't detach a stream */
2871     hr = IMXWriter_flush(writer);
2872     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2873     todo_wine EXPECT_REF(stream, 3);
2874
2875     pos.QuadPart = 0;
2876     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
2877     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2878     ok(pos2.QuadPart == 0, "expected stream beginning\n");
2879
2880     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
2881     ok(hr == S_OK, "got %08x\n", hr);
2882
2883     hr = ISAXContentHandler_startDocument(content);
2884     ok(hr == S_OK, "got %08x\n", hr);
2885
2886     pos.QuadPart = 0;
2887     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
2888     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2889     ok(pos2.QuadPart != 0, "expected stream beginning\n");
2890
2891     /* already started */
2892     hr = ISAXContentHandler_startDocument(content);
2893     ok(hr == S_OK, "got %08x\n", hr);
2894
2895     hr = ISAXContentHandler_endDocument(content);
2896     ok(hr == S_OK, "got %08x\n", hr);
2897
2898     /* flushed on endDocument() */
2899     pos.QuadPart = 0;
2900     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
2901     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2902     ok(pos2.QuadPart != 0, "expected stream position moved\n");
2903
2904     IStream_Release(stream);
2905
2906     /* auto-flush feature */
2907     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
2908     EXPECT_HR(hr, S_OK);
2909     EXPECT_REF(stream, 1);
2910
2911     V_VT(&dest) = VT_UNKNOWN;
2912     V_UNKNOWN(&dest) = (IUnknown*)stream;
2913     hr = IMXWriter_put_output(writer, dest);
2914     EXPECT_HR(hr, S_OK);
2915
2916     hr = IMXWriter_put_byteOrderMark(writer, VARIANT_FALSE);
2917     EXPECT_HR(hr, S_OK);
2918
2919     hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
2920     EXPECT_HR(hr, S_OK);
2921
2922     hr = ISAXContentHandler_startDocument(content);
2923     EXPECT_HR(hr, S_OK);
2924
2925     hr = ISAXContentHandler_startElement(content, emptyW, 0, emptyW, 0, _bstr_("a"), -1, NULL);
2926     EXPECT_HR(hr, S_OK);
2927
2928     /* internal buffer is flushed automatically on certain threshold */
2929     pos.QuadPart = 0;
2930     pos2.QuadPart = 1;
2931     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
2932     EXPECT_HR(hr, S_OK);
2933     ok(pos2.QuadPart == 0, "expected stream beginning\n");
2934
2935     len = 2048;
2936     buff = HeapAlloc(GetProcessHeap(), 0, len);
2937     memset(buff, 'A', len);
2938     hr = ISAXContentHandler_characters(content, _bstr_(buff), len);
2939     EXPECT_HR(hr, S_OK);
2940
2941     pos.QuadPart = 0;
2942     pos2.QuadPart = 0;
2943     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
2944     EXPECT_HR(hr, S_OK);
2945 todo_wine
2946     ok(pos2.QuadPart != 0, "unexpected stream beginning\n");
2947
2948     hr = IMXWriter_get_output(writer, NULL);
2949     EXPECT_HR(hr, E_POINTER);
2950
2951     ref = get_refcount(stream);
2952     V_VT(&dest) = VT_EMPTY;
2953     hr = IMXWriter_get_output(writer, &dest);
2954     EXPECT_HR(hr, S_OK);
2955     ok(V_VT(&dest) == VT_UNKNOWN, "got vt type %d\n", V_VT(&dest));
2956     ok(V_UNKNOWN(&dest) == (IUnknown*)stream, "got pointer %p\n", V_UNKNOWN(&dest));
2957     ok(ref+1 == get_refcount(stream), "expected increased refcount\n");
2958     VariantClear(&dest);
2959
2960     hr = ISAXContentHandler_endDocument(content);
2961     EXPECT_HR(hr, S_OK);
2962
2963     IStream_Release(stream);
2964
2965     /* test char count lower than threshold */
2966     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
2967     EXPECT_HR(hr, S_OK);
2968     EXPECT_REF(stream, 1);
2969
2970     hr = ISAXContentHandler_startDocument(content);
2971     EXPECT_HR(hr, S_OK);
2972
2973     hr = ISAXContentHandler_startElement(content, emptyW, 0, emptyW, 0, _bstr_("a"), -1, NULL);
2974     EXPECT_HR(hr, S_OK);
2975
2976     pos.QuadPart = 0;
2977     pos2.QuadPart = 1;
2978     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
2979     EXPECT_HR(hr, S_OK);
2980     ok(pos2.QuadPart == 0, "expected stream beginning\n");
2981
2982     memset(buff, 'A', len);
2983     hr = ISAXContentHandler_characters(content, _bstr_(buff), len - 8);
2984     EXPECT_HR(hr, S_OK);
2985
2986     pos.QuadPart = 0;
2987     pos2.QuadPart = 1;
2988     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
2989     EXPECT_HR(hr, S_OK);
2990     ok(pos2.QuadPart == 0, "expected stream beginning\n");
2991
2992     hr = ISAXContentHandler_endDocument(content);
2993     EXPECT_HR(hr, S_OK);
2994
2995     /* test auto-flush function when stream is not set */
2996     V_VT(&dest) = VT_EMPTY;
2997     hr = IMXWriter_put_output(writer, dest);
2998     EXPECT_HR(hr, S_OK);
2999
3000     hr = ISAXContentHandler_startDocument(content);
3001     EXPECT_HR(hr, S_OK);
3002
3003     hr = ISAXContentHandler_startElement(content, emptyW, 0, emptyW, 0, _bstr_("a"), -1, NULL);
3004     EXPECT_HR(hr, S_OK);
3005
3006     memset(buff, 'A', len);
3007     hr = ISAXContentHandler_characters(content, _bstr_(buff), len);
3008     EXPECT_HR(hr, S_OK);
3009
3010     V_VT(&dest) = VT_EMPTY;
3011     hr = IMXWriter_get_output(writer, &dest);
3012     EXPECT_HR(hr, S_OK);
3013     len += strlen("<a>");
3014     ok(SysStringLen(V_BSTR(&dest)) == len, "got len=%d, expected %d\n", SysStringLen(V_BSTR(&dest)), len);
3015     VariantClear(&dest);
3016
3017     HeapFree(GetProcessHeap(), 0, buff);
3018     ISAXContentHandler_Release(content);
3019     IStream_Release(stream);
3020     IMXWriter_Release(writer);
3021     free_bstrs();
3022 }
3023
3024 static void test_mxwriter_startenddocument(void)
3025 {
3026     ISAXContentHandler *content;
3027     IMXWriter *writer;
3028     VARIANT dest;
3029     HRESULT hr;
3030
3031     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
3032             &IID_IMXWriter, (void**)&writer);
3033     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
3034
3035     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
3036     ok(hr == S_OK, "got %08x\n", hr);
3037
3038     hr = ISAXContentHandler_startDocument(content);
3039     ok(hr == S_OK, "got %08x\n", hr);
3040
3041     hr = ISAXContentHandler_endDocument(content);
3042     ok(hr == S_OK, "got %08x\n", hr);
3043
3044     V_VT(&dest) = VT_EMPTY;
3045     hr = IMXWriter_get_output(writer, &dest);
3046     ok(hr == S_OK, "got %08x\n", hr);
3047     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3048     ok(!lstrcmpW(_bstr_("<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n"), V_BSTR(&dest)),
3049         "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3050     VariantClear(&dest);
3051
3052     /* now try another startDocument */
3053     hr = ISAXContentHandler_startDocument(content);
3054     ok(hr == S_OK, "got %08x\n", hr);
3055     /* and get duplicated prolog */
3056     V_VT(&dest) = VT_EMPTY;
3057     hr = IMXWriter_get_output(writer, &dest);
3058     ok(hr == S_OK, "got %08x\n", hr);
3059     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3060     ok(!lstrcmpW(_bstr_("<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n"
3061                         "<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n"), V_BSTR(&dest)),
3062         "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3063     VariantClear(&dest);
3064
3065     ISAXContentHandler_Release(content);
3066     IMXWriter_Release(writer);
3067
3068     /* now with omitted declaration */
3069     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
3070             &IID_IMXWriter, (void**)&writer);
3071     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
3072
3073     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
3074     ok(hr == S_OK, "got %08x\n", hr);
3075
3076     hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
3077     ok(hr == S_OK, "got %08x\n", hr);
3078
3079     hr = ISAXContentHandler_startDocument(content);
3080     ok(hr == S_OK, "got %08x\n", hr);
3081
3082     hr = ISAXContentHandler_endDocument(content);
3083     ok(hr == S_OK, "got %08x\n", hr);
3084
3085     V_VT(&dest) = VT_EMPTY;
3086     hr = IMXWriter_get_output(writer, &dest);
3087     ok(hr == S_OK, "got %08x\n", hr);
3088     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3089     ok(!lstrcmpW(_bstr_(""), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3090     VariantClear(&dest);
3091
3092     ISAXContentHandler_Release(content);
3093     IMXWriter_Release(writer);
3094
3095     free_bstrs();
3096 }
3097
3098 enum startendtype
3099 {
3100     StartElement    = 0x001,
3101     EndElement      = 0x010,
3102     StartEndElement = 0x011,
3103     DisableEscaping = 0x100
3104 };
3105
3106 struct writer_startendelement_t {
3107     const GUID *clsid;
3108     enum startendtype type;
3109     const char *uri;
3110     const char *local_name;
3111     const char *qname;
3112     const char *output;
3113     HRESULT hr;
3114     ISAXAttributes *attr;
3115 };
3116
3117 static const char startelement_xml[] = "<uri:local a:attr1=\"a1\" attr2=\"a2\" attr3=\"&lt;&amp;&quot;&gt;\">";
3118 static const char startendelement_xml[] = "<uri:local a:attr1=\"a1\" attr2=\"a2\" attr3=\"&lt;&amp;&quot;&gt;\"/>";
3119 static const char startendelement_noescape_xml[] = "<uri:local a:attr1=\"a1\" attr2=\"a2\" attr3=\"<&\">\"/>";
3120
3121 static const struct writer_startendelement_t writer_startendelement[] = {
3122     /* 0 */
3123     { &CLSID_MXXMLWriter,   StartElement, NULL, NULL, NULL, NULL, E_INVALIDARG },
3124     { &CLSID_MXXMLWriter30, StartElement, NULL, NULL, NULL, NULL, E_INVALIDARG },
3125     { &CLSID_MXXMLWriter40, StartElement, NULL, NULL, NULL, NULL, E_INVALIDARG },
3126     { &CLSID_MXXMLWriter60, StartElement, NULL, NULL, NULL, "<>", S_OK },
3127     { &CLSID_MXXMLWriter,   StartElement, "uri", NULL, NULL, NULL, E_INVALIDARG },
3128     /* 5 */
3129     { &CLSID_MXXMLWriter30, StartElement, "uri", NULL, NULL, NULL, E_INVALIDARG },
3130     { &CLSID_MXXMLWriter40, StartElement, "uri", NULL, NULL, NULL, E_INVALIDARG },
3131     { &CLSID_MXXMLWriter60, StartElement, "uri", NULL, NULL, "<>", S_OK },
3132     { &CLSID_MXXMLWriter,   StartElement, NULL, "local", NULL, NULL, E_INVALIDARG },
3133     { &CLSID_MXXMLWriter30, StartElement, NULL, "local", NULL, NULL, E_INVALIDARG },
3134     /* 10 */
3135     { &CLSID_MXXMLWriter40, StartElement, NULL, "local", NULL, NULL, E_INVALIDARG },
3136     { &CLSID_MXXMLWriter60, StartElement, NULL, "local", NULL, "<>", S_OK },
3137     { &CLSID_MXXMLWriter,   StartElement, NULL, NULL, "qname", NULL, E_INVALIDARG },
3138     { &CLSID_MXXMLWriter30, StartElement, NULL, NULL, "qname", NULL, E_INVALIDARG },
3139     { &CLSID_MXXMLWriter40, StartElement, NULL, NULL, "qname", NULL, E_INVALIDARG },
3140     /* 15 */
3141     { &CLSID_MXXMLWriter60, StartElement, NULL, NULL, "qname", "<qname>", S_OK },
3142     { &CLSID_MXXMLWriter,   StartElement, "uri", "local", "qname", "<qname>", S_OK },
3143     { &CLSID_MXXMLWriter30, StartElement, "uri", "local", "qname", "<qname>", S_OK },
3144     { &CLSID_MXXMLWriter40, StartElement, "uri", "local", "qname", "<qname>", S_OK },
3145     { &CLSID_MXXMLWriter60, StartElement, "uri", "local", "qname", "<qname>", S_OK },
3146     /* 20 */
3147     { &CLSID_MXXMLWriter,   StartElement, "uri", "local", NULL, NULL, E_INVALIDARG },
3148     { &CLSID_MXXMLWriter30, StartElement, "uri", "local", NULL, NULL, E_INVALIDARG },
3149     { &CLSID_MXXMLWriter40, StartElement, "uri", "local", NULL, NULL, E_INVALIDARG },
3150     { &CLSID_MXXMLWriter60, StartElement, "uri", "local", NULL, "<>", S_OK },
3151     { &CLSID_MXXMLWriter,   StartElement, "uri", "local", "uri:local", "<uri:local>", S_OK },
3152     /* 25 */
3153     { &CLSID_MXXMLWriter30, StartElement, "uri", "local", "uri:local", "<uri:local>", S_OK },
3154     { &CLSID_MXXMLWriter40, StartElement, "uri", "local", "uri:local", "<uri:local>", S_OK },
3155     { &CLSID_MXXMLWriter60, StartElement, "uri", "local", "uri:local", "<uri:local>", S_OK },
3156     { &CLSID_MXXMLWriter,   StartElement, "uri", "local", "uri:local2", "<uri:local2>", S_OK },
3157     { &CLSID_MXXMLWriter30, StartElement, "uri", "local", "uri:local2", "<uri:local2>", S_OK },
3158     /* 30 */
3159     { &CLSID_MXXMLWriter40, StartElement, "uri", "local", "uri:local2", "<uri:local2>", S_OK },
3160     { &CLSID_MXXMLWriter60, StartElement, "uri", "local", "uri:local2", "<uri:local2>", S_OK },
3161     /* endElement tests */
3162     { &CLSID_MXXMLWriter,   EndElement, NULL, NULL, NULL, NULL, E_INVALIDARG },
3163     { &CLSID_MXXMLWriter30, EndElement, NULL, NULL, NULL, NULL, E_INVALIDARG },
3164     { &CLSID_MXXMLWriter40, EndElement, NULL, NULL, NULL, NULL, E_INVALIDARG },
3165     /* 35 */
3166     { &CLSID_MXXMLWriter60, EndElement, NULL, NULL, NULL, "</>", S_OK },
3167     { &CLSID_MXXMLWriter,   EndElement, "uri", NULL, NULL, NULL, E_INVALIDARG },
3168     { &CLSID_MXXMLWriter30, EndElement, "uri", NULL, NULL, NULL, E_INVALIDARG },
3169     { &CLSID_MXXMLWriter40, EndElement, "uri", NULL, NULL, NULL, E_INVALIDARG },
3170     { &CLSID_MXXMLWriter60, EndElement, "uri", NULL, NULL, "</>", S_OK },
3171     /* 40 */
3172     { &CLSID_MXXMLWriter,   EndElement, NULL, "local", NULL, NULL, E_INVALIDARG },
3173     { &CLSID_MXXMLWriter30, EndElement, NULL, "local", NULL, NULL, E_INVALIDARG },
3174     { &CLSID_MXXMLWriter40, EndElement, NULL, "local", NULL, NULL, E_INVALIDARG },
3175     { &CLSID_MXXMLWriter60, EndElement, NULL, "local", NULL, "</>", S_OK },
3176     { &CLSID_MXXMLWriter,   EndElement, NULL, NULL, "qname", NULL, E_INVALIDARG },
3177     /* 45 */
3178     { &CLSID_MXXMLWriter30, EndElement, NULL, NULL, "qname", NULL, E_INVALIDARG },
3179     { &CLSID_MXXMLWriter40, EndElement, NULL, NULL, "qname", NULL, E_INVALIDARG },
3180     { &CLSID_MXXMLWriter60, EndElement, NULL, NULL, "qname", "</qname>", S_OK },
3181     { &CLSID_MXXMLWriter,   EndElement, "uri", "local", "qname", "</qname>", S_OK },
3182     { &CLSID_MXXMLWriter30, EndElement, "uri", "local", "qname", "</qname>", S_OK },
3183     /* 50 */
3184     { &CLSID_MXXMLWriter40, EndElement, "uri", "local", "qname", "</qname>", S_OK },
3185     { &CLSID_MXXMLWriter60, EndElement, "uri", "local", "qname", "</qname>", S_OK },
3186     { &CLSID_MXXMLWriter,   EndElement, "uri", "local", NULL, NULL, E_INVALIDARG },
3187     { &CLSID_MXXMLWriter30, EndElement, "uri", "local", NULL, NULL, E_INVALIDARG },
3188     { &CLSID_MXXMLWriter40, EndElement, "uri", "local", NULL, NULL, E_INVALIDARG },
3189     /* 55 */
3190     { &CLSID_MXXMLWriter60, EndElement, "uri", "local", NULL, "</>", S_OK },
3191     { &CLSID_MXXMLWriter,   EndElement, "uri", "local", "uri:local", "</uri:local>", S_OK },
3192     { &CLSID_MXXMLWriter30, EndElement, "uri", "local", "uri:local", "</uri:local>", S_OK },
3193     { &CLSID_MXXMLWriter40, EndElement, "uri", "local", "uri:local", "</uri:local>", S_OK },
3194     { &CLSID_MXXMLWriter60, EndElement, "uri", "local", "uri:local", "</uri:local>", S_OK },
3195     /* 60 */
3196     { &CLSID_MXXMLWriter,   EndElement, "uri", "local", "uri:local2", "</uri:local2>", S_OK },
3197     { &CLSID_MXXMLWriter30, EndElement, "uri", "local", "uri:local2", "</uri:local2>", S_OK },
3198     { &CLSID_MXXMLWriter40, EndElement, "uri", "local", "uri:local2", "</uri:local2>", S_OK },
3199     { &CLSID_MXXMLWriter60, EndElement, "uri", "local", "uri:local2", "</uri:local2>", S_OK },
3200
3201     /* with attributes */
3202     { &CLSID_MXXMLWriter,   StartElement, "uri", "local", "uri:local", startelement_xml, S_OK, &saxattributes },
3203     /* 65 */
3204     { &CLSID_MXXMLWriter30, StartElement, "uri", "local", "uri:local", startelement_xml, S_OK, &saxattributes },
3205     { &CLSID_MXXMLWriter40, StartElement, "uri", "local", "uri:local", startelement_xml, S_OK, &saxattributes },
3206     { &CLSID_MXXMLWriter60, StartElement, "uri", "local", "uri:local", startelement_xml, S_OK, &saxattributes },
3207     /* empty elements */
3208     { &CLSID_MXXMLWriter,   StartEndElement, "uri", "local", "uri:local", startendelement_xml, S_OK, &saxattributes },
3209     { &CLSID_MXXMLWriter30, StartEndElement, "uri", "local", "uri:local", startendelement_xml, S_OK, &saxattributes },
3210     /* 70 */
3211     { &CLSID_MXXMLWriter40, StartEndElement, "uri", "local", "uri:local", startendelement_xml, S_OK, &saxattributes },
3212     { &CLSID_MXXMLWriter60, StartEndElement, "uri", "local", "uri:local", startendelement_xml, S_OK, &saxattributes },
3213     { &CLSID_MXXMLWriter,   StartEndElement, "", "", "", "</>", S_OK },
3214     { &CLSID_MXXMLWriter30, StartEndElement, "", "", "", "</>", S_OK },
3215     { &CLSID_MXXMLWriter40, StartEndElement, "", "", "", "</>", S_OK },
3216     /* 75 */
3217     { &CLSID_MXXMLWriter60, StartEndElement, "", "", "", "</>", S_OK },
3218
3219     /* with disabled output escaping */
3220     { &CLSID_MXXMLWriter,   StartEndElement | DisableEscaping, "uri", "local", "uri:local", startendelement_noescape_xml, S_OK, &saxattributes },
3221     { &CLSID_MXXMLWriter30, StartEndElement | DisableEscaping, "uri", "local", "uri:local", startendelement_noescape_xml, S_OK, &saxattributes },
3222     { &CLSID_MXXMLWriter40, StartEndElement | DisableEscaping, "uri", "local", "uri:local", startendelement_xml, S_OK, &saxattributes },
3223     { &CLSID_MXXMLWriter60, StartEndElement | DisableEscaping, "uri", "local", "uri:local", startendelement_xml, S_OK, &saxattributes },
3224
3225     { NULL }
3226 };
3227
3228 static void get_class_support_data(struct msxmlsupported_data_t *table, REFIID riid)
3229 {
3230     while (table->clsid)
3231     {
3232         IUnknown *unk;
3233         HRESULT hr;
3234
3235         hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER, riid, (void**)&unk);
3236         if (hr == S_OK) IUnknown_Release(unk);
3237
3238         table->supported = hr == S_OK;
3239         if (hr != S_OK) win_skip("class %s not supported\n", table->name);
3240
3241         table++;
3242     }
3243 }
3244
3245 static void test_mxwriter_startendelement_batch(const struct writer_startendelement_t *table)
3246 {
3247     int i = 0;
3248
3249     while (table->clsid)
3250     {
3251         ISAXContentHandler *content;
3252         IMXWriter *writer;
3253         HRESULT hr;
3254
3255         if (!is_clsid_supported(table->clsid, mxwriter_support_data))
3256         {
3257             table++;
3258             i++;
3259             continue;
3260         }
3261
3262         hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
3263             &IID_IMXWriter, (void**)&writer);
3264         EXPECT_HR(hr, S_OK);
3265
3266         hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
3267         EXPECT_HR(hr, S_OK);
3268
3269         hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
3270         EXPECT_HR(hr, S_OK);
3271
3272         hr = ISAXContentHandler_startDocument(content);
3273         EXPECT_HR(hr, S_OK);
3274
3275         if (table->type & DisableEscaping)
3276         {
3277             hr = IMXWriter_put_disableOutputEscaping(writer, VARIANT_TRUE);
3278             EXPECT_HR(hr, S_OK);
3279         }
3280
3281         if (table->type & StartElement)
3282         {
3283             hr = ISAXContentHandler_startElement(content, _bstr_(table->uri), lstrlen(table->uri),
3284                 _bstr_(table->local_name), lstrlen(table->local_name), _bstr_(table->qname), lstrlen(table->qname), table->attr);
3285             ok(hr == table->hr, "test %d: got 0x%08x, expected 0x%08x\n", i, hr, table->hr);
3286         }
3287
3288         if (table->type & EndElement)
3289         {
3290             hr = ISAXContentHandler_endElement(content, _bstr_(table->uri), lstrlen(table->uri),
3291                 _bstr_(table->local_name), lstrlen(table->local_name), _bstr_(table->qname), lstrlen(table->qname));
3292             ok(hr == table->hr, "test %d: got 0x%08x, expected 0x%08x\n", i, hr, table->hr);
3293         }
3294
3295         /* test output */
3296         if (hr == S_OK)
3297         {
3298             VARIANT dest;
3299
3300             V_VT(&dest) = VT_EMPTY;
3301             hr = IMXWriter_get_output(writer, &dest);
3302             EXPECT_HR(hr, S_OK);
3303             ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3304             ok(!lstrcmpW(_bstr_(table->output), V_BSTR(&dest)),
3305                 "test %d: got wrong content %s, expected %s\n", i, wine_dbgstr_w(V_BSTR(&dest)), table->output);
3306             VariantClear(&dest);
3307         }
3308
3309         ISAXContentHandler_Release(content);
3310         IMXWriter_Release(writer);
3311
3312         table++;
3313         i++;
3314     }
3315
3316     free_bstrs();
3317 }
3318
3319 /* point of these test is to start/end element with different names and name lengths */
3320 struct writer_startendelement2_t {
3321     const GUID *clsid;
3322     const char *qnamestart;
3323     int qnamestart_len;
3324     const char *qnameend;
3325     int qnameend_len;
3326     const char *output;
3327     HRESULT hr;
3328 };
3329
3330 static const struct writer_startendelement2_t writer_startendelement2[] = {
3331     { &CLSID_MXXMLWriter,   "a", -1, "b", -1, "<a/>", S_OK },
3332     { &CLSID_MXXMLWriter30, "a", -1, "b", -1, "<a/>", S_OK },
3333     { &CLSID_MXXMLWriter40, "a", -1, "b", -1, "<a/>", S_OK },
3334     /* -1 length is not allowed for version 6 */
3335     { &CLSID_MXXMLWriter60, "a", -1, "b", -1, "<a/>", E_INVALIDARG },
3336
3337     { &CLSID_MXXMLWriter,   "a", 1, "b", 1, "<a/>", S_OK },
3338     { &CLSID_MXXMLWriter30, "a", 1, "b", 1, "<a/>", S_OK },
3339     { &CLSID_MXXMLWriter40, "a", 1, "b", 1, "<a/>", S_OK },
3340     { &CLSID_MXXMLWriter60, "a", 1, "b", 1, "<a/>", S_OK },
3341     { NULL }
3342 };
3343
3344 static void test_mxwriter_startendelement_batch2(const struct writer_startendelement2_t *table)
3345 {
3346     int i = 0;
3347
3348     while (table->clsid)
3349     {
3350         ISAXContentHandler *content;
3351         IMXWriter *writer;
3352         HRESULT hr;
3353
3354         if (!is_clsid_supported(table->clsid, mxwriter_support_data))
3355         {
3356             table++;
3357             i++;
3358             continue;
3359         }
3360
3361         hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
3362             &IID_IMXWriter, (void**)&writer);
3363         EXPECT_HR(hr, S_OK);
3364
3365         hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
3366         EXPECT_HR(hr, S_OK);
3367
3368         hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
3369         EXPECT_HR(hr, S_OK);
3370
3371         hr = ISAXContentHandler_startDocument(content);
3372         EXPECT_HR(hr, S_OK);
3373
3374         hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_(""), 0,
3375             _bstr_(table->qnamestart), table->qnamestart_len, NULL);
3376         ok(hr == table->hr, "test %d: got 0x%08x, expected 0x%08x\n", i, hr, table->hr);
3377
3378         hr = ISAXContentHandler_endElement(content, _bstr_(""), 0, _bstr_(""), 0,
3379             _bstr_(table->qnameend), table->qnameend_len);
3380         ok(hr == table->hr, "test %d: got 0x%08x, expected 0x%08x\n", i, hr, table->hr);
3381
3382         /* test output */
3383         if (hr == S_OK)
3384         {
3385             VARIANT dest;
3386
3387             V_VT(&dest) = VT_EMPTY;
3388             hr = IMXWriter_get_output(writer, &dest);
3389             EXPECT_HR(hr, S_OK);
3390             ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3391             ok(!lstrcmpW(_bstr_(table->output), V_BSTR(&dest)),
3392                 "test %d: got wrong content %s, expected %s\n", i, wine_dbgstr_w(V_BSTR(&dest)), table->output);
3393             VariantClear(&dest);
3394         }
3395
3396         ISAXContentHandler_Release(content);
3397         IMXWriter_Release(writer);
3398
3399         table++;
3400         i++;
3401
3402         free_bstrs();
3403     }
3404 }
3405
3406
3407 static void test_mxwriter_startendelement(void)
3408 {
3409     ISAXContentHandler *content;
3410     IMXWriter *writer;
3411     VARIANT dest;
3412     HRESULT hr;
3413
3414     test_mxwriter_startendelement_batch(writer_startendelement);
3415     test_mxwriter_startendelement_batch2(writer_startendelement2);
3416
3417     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
3418             &IID_IMXWriter, (void**)&writer);
3419     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
3420
3421     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
3422     ok(hr == S_OK, "got %08x\n", hr);
3423
3424     hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
3425     ok(hr == S_OK, "got %08x\n", hr);
3426
3427     hr = ISAXContentHandler_startDocument(content);
3428     ok(hr == S_OK, "got %08x\n", hr);
3429
3430     /* all string pointers should be not null */
3431     hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_("b"), 1, _bstr_(""), 0, NULL);
3432     ok(hr == S_OK, "got %08x\n", hr);
3433
3434     V_VT(&dest) = VT_EMPTY;
3435     hr = IMXWriter_get_output(writer, &dest);
3436     ok(hr == S_OK, "got %08x\n", hr);
3437     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3438     ok(!lstrcmpW(_bstr_("<>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3439     VariantClear(&dest);
3440
3441     hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("b"), 1, NULL);
3442     ok(hr == S_OK, "got %08x\n", hr);
3443
3444     V_VT(&dest) = VT_EMPTY;
3445     hr = IMXWriter_get_output(writer, &dest);
3446     ok(hr == S_OK, "got %08x\n", hr);
3447     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3448     ok(!lstrcmpW(_bstr_("<><b>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3449     VariantClear(&dest);
3450
3451     hr = ISAXContentHandler_endElement(content, NULL, 0, NULL, 0, _bstr_("a:b"), 3);
3452     EXPECT_HR(hr, E_INVALIDARG);
3453
3454     hr = ISAXContentHandler_endElement(content, NULL, 0, _bstr_("b"), 1, _bstr_("a:b"), 3);
3455     EXPECT_HR(hr, E_INVALIDARG);
3456
3457     /* only local name is an error too */
3458     hr = ISAXContentHandler_endElement(content, NULL, 0, _bstr_("b"), 1, NULL, 0);
3459     EXPECT_HR(hr, E_INVALIDARG);
3460
3461     hr = ISAXContentHandler_endElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("b"), 1);
3462     EXPECT_HR(hr, S_OK);
3463
3464     V_VT(&dest) = VT_EMPTY;
3465     hr = IMXWriter_get_output(writer, &dest);
3466     EXPECT_HR(hr, S_OK);
3467     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3468     ok(!lstrcmpW(_bstr_("<><b></b>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3469     VariantClear(&dest);
3470
3471     hr = ISAXContentHandler_endDocument(content);
3472     EXPECT_HR(hr, S_OK);
3473
3474     V_VT(&dest) = VT_EMPTY;
3475     hr = IMXWriter_put_output(writer, dest);
3476     EXPECT_HR(hr, S_OK);
3477
3478     V_VT(&dest) = VT_EMPTY;
3479     hr = IMXWriter_get_output(writer, &dest);
3480     EXPECT_HR(hr, S_OK);
3481     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3482     ok(!lstrcmpW(_bstr_(""), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3483     VariantClear(&dest);
3484
3485     hr = ISAXContentHandler_startDocument(content);
3486     EXPECT_HR(hr, S_OK);
3487
3488     hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("abcdef"), 3, NULL);
3489     EXPECT_HR(hr, S_OK);
3490
3491     V_VT(&dest) = VT_EMPTY;
3492     hr = IMXWriter_get_output(writer, &dest);
3493     EXPECT_HR(hr, S_OK);
3494     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3495     ok(!lstrcmpW(_bstr_("<abc>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3496     VariantClear(&dest);
3497
3498     ISAXContentHandler_endDocument(content);
3499     IMXWriter_flush(writer);
3500
3501     hr = ISAXContentHandler_endElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("abdcdef"), 3);
3502     EXPECT_HR(hr, S_OK);
3503     V_VT(&dest) = VT_EMPTY;
3504     hr = IMXWriter_get_output(writer, &dest);
3505     EXPECT_HR(hr, S_OK);
3506     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3507     ok(!lstrcmpW(_bstr_("<abc></abd>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3508     VariantClear(&dest);
3509
3510     V_VT(&dest) = VT_EMPTY;
3511     hr = IMXWriter_put_output(writer, dest);
3512     EXPECT_HR(hr, S_OK);
3513
3514     /* length -1 */
3515     hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("a"), -1, NULL);
3516     EXPECT_HR(hr, S_OK);
3517     V_VT(&dest) = VT_EMPTY;
3518     hr = IMXWriter_get_output(writer, &dest);
3519     EXPECT_HR(hr, S_OK);
3520     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3521     ok(!lstrcmpW(_bstr_("<a>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3522     VariantClear(&dest);
3523
3524     ISAXContentHandler_Release(content);
3525     IMXWriter_Release(writer);
3526     free_bstrs();
3527 }
3528
3529 struct writer_characters_t {
3530     const GUID *clsid;
3531     const char *data;
3532     const char *output;
3533 };
3534
3535 static const struct writer_characters_t writer_characters[] = {
3536     { &CLSID_MXXMLWriter,   "< > & \"", "&lt; &gt; &amp; \"" },
3537     { &CLSID_MXXMLWriter30, "< > & \"", "&lt; &gt; &amp; \"" },
3538     { &CLSID_MXXMLWriter40, "< > & \"", "&lt; &gt; &amp; \"" },
3539     { &CLSID_MXXMLWriter60, "< > & \"", "&lt; &gt; &amp; \"" },
3540     { NULL }
3541 };
3542
3543 static void test_mxwriter_characters(void)
3544 {
3545     static const WCHAR chardataW[] = {'T','E','S','T','C','H','A','R','D','A','T','A',' ','.',0};
3546     const struct writer_characters_t *table = writer_characters;
3547     ISAXContentHandler *content;
3548     IMXWriter *writer;
3549     VARIANT dest;
3550     HRESULT hr;
3551     int i = 0;
3552
3553     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
3554             &IID_IMXWriter, (void**)&writer);
3555     EXPECT_HR(hr, S_OK);
3556
3557     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
3558     EXPECT_HR(hr, S_OK);
3559
3560     hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
3561     EXPECT_HR(hr, S_OK);
3562
3563     hr = ISAXContentHandler_startDocument(content);
3564     EXPECT_HR(hr, S_OK);
3565
3566     hr = ISAXContentHandler_characters(content, NULL, 0);
3567     EXPECT_HR(hr, E_INVALIDARG);
3568
3569     hr = ISAXContentHandler_characters(content, chardataW, 0);
3570     EXPECT_HR(hr, S_OK);
3571
3572     hr = ISAXContentHandler_characters(content, chardataW, sizeof(chardataW)/sizeof(WCHAR) - 1);
3573     EXPECT_HR(hr, S_OK);
3574
3575     V_VT(&dest) = VT_EMPTY;
3576     hr = IMXWriter_get_output(writer, &dest);
3577     EXPECT_HR(hr, S_OK);
3578     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3579     ok(!lstrcmpW(_bstr_("TESTCHARDATA ."), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3580     VariantClear(&dest);
3581
3582     hr = ISAXContentHandler_endDocument(content);
3583     EXPECT_HR(hr, S_OK);
3584
3585     ISAXContentHandler_Release(content);
3586     IMXWriter_Release(writer);
3587
3588     /* try empty characters data to see if element is closed */
3589     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
3590             &IID_IMXWriter, (void**)&writer);
3591     EXPECT_HR(hr, S_OK);
3592
3593     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
3594     EXPECT_HR(hr, S_OK);
3595
3596     hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
3597     EXPECT_HR(hr, S_OK);
3598
3599     hr = ISAXContentHandler_startDocument(content);
3600     EXPECT_HR(hr, S_OK);
3601
3602     hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("a"), 1, NULL);
3603     EXPECT_HR(hr, S_OK);
3604
3605     hr = ISAXContentHandler_characters(content, chardataW, 0);
3606     EXPECT_HR(hr, S_OK);
3607
3608     hr = ISAXContentHandler_endElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("a"), 1);
3609     EXPECT_HR(hr, S_OK);
3610
3611     V_VT(&dest) = VT_EMPTY;
3612     hr = IMXWriter_get_output(writer, &dest);
3613     EXPECT_HR(hr, S_OK);
3614     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3615     ok(!lstrcmpW(_bstr_("<a></a>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3616     VariantClear(&dest);
3617
3618     ISAXContentHandler_Release(content);
3619     IMXWriter_Release(writer);
3620
3621     /* batch tests */
3622     while (table->clsid)
3623     {
3624         ISAXContentHandler *content;
3625         IMXWriter *writer;
3626         VARIANT dest;
3627         HRESULT hr;
3628
3629         if (!is_clsid_supported(table->clsid, mxwriter_support_data))
3630         {
3631             table++;
3632             i++;
3633             continue;
3634         }
3635
3636         hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
3637             &IID_IMXWriter, (void**)&writer);
3638         EXPECT_HR(hr, S_OK);
3639
3640         hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
3641         EXPECT_HR(hr, S_OK);
3642
3643         hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
3644         EXPECT_HR(hr, S_OK);
3645
3646         hr = ISAXContentHandler_startDocument(content);
3647         EXPECT_HR(hr, S_OK);
3648
3649         hr = ISAXContentHandler_characters(content, _bstr_(table->data), strlen(table->data));
3650         EXPECT_HR(hr, S_OK);
3651
3652         /* test output */
3653         if (hr == S_OK)
3654         {
3655             V_VT(&dest) = VT_EMPTY;
3656             hr = IMXWriter_get_output(writer, &dest);
3657             EXPECT_HR(hr, S_OK);
3658             ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3659             ok(!lstrcmpW(_bstr_(table->output), V_BSTR(&dest)),
3660                 "test %d: got wrong content %s, expected \"%s\"\n", i, wine_dbgstr_w(V_BSTR(&dest)), table->output);
3661             VariantClear(&dest);
3662         }
3663
3664         /* with disabled escaping */
3665         V_VT(&dest) = VT_EMPTY;
3666         hr = IMXWriter_put_output(writer, dest);
3667         EXPECT_HR(hr, S_OK);
3668
3669         hr = IMXWriter_put_disableOutputEscaping(writer, VARIANT_TRUE);
3670         EXPECT_HR(hr, S_OK);
3671
3672         hr = ISAXContentHandler_characters(content, _bstr_(table->data), strlen(table->data));
3673         EXPECT_HR(hr, S_OK);
3674
3675         /* test output */
3676         if (hr == S_OK)
3677         {
3678             V_VT(&dest) = VT_EMPTY;
3679             hr = IMXWriter_get_output(writer, &dest);
3680             EXPECT_HR(hr, S_OK);
3681             ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
3682             ok(!lstrcmpW(_bstr_(table->data), V_BSTR(&dest)),
3683                 "test %d: got wrong content %s, expected \"%s\"\n", i, wine_dbgstr_w(V_BSTR(&dest)), table->data);
3684             VariantClear(&dest);
3685         }
3686
3687         ISAXContentHandler_Release(content);
3688         IMXWriter_Release(writer);
3689
3690         table++;
3691         i++;
3692     }
3693
3694     free_bstrs();
3695 }
3696
3697 static const mxwriter_stream_test mxwriter_stream_tests[] = {
3698     {
3699         VARIANT_TRUE,"UTF-16",
3700         {
3701             {FALSE,(const BYTE*)szUtf16BOM,sizeof(szUtf16BOM),TRUE},
3702             {FALSE,(const BYTE*)szUtf16XML,sizeof(szUtf16XML)},
3703             {TRUE}
3704         }
3705     },
3706     {
3707         VARIANT_FALSE,"UTF-16",
3708         {
3709             {FALSE,(const BYTE*)szUtf16XML,sizeof(szUtf16XML)},
3710             {TRUE}
3711         }
3712     },
3713     {
3714         VARIANT_TRUE,"UTF-8",
3715         {
3716             {FALSE,(const BYTE*)szUtf8XML,sizeof(szUtf8XML)-1},
3717             /* For some reason Windows makes an empty write call when UTF-8 encoding is used
3718              * and the writer is released.
3719              */
3720             {FALSE,NULL,0},
3721             {TRUE}
3722         }
3723     },
3724     {
3725         VARIANT_TRUE,"utf-8",
3726         {
3727             {FALSE,(const BYTE*)utf8xml2,sizeof(utf8xml2)-1},
3728             /* For some reason Windows makes an empty write call when UTF-8 encoding is used
3729              * and the writer is released.
3730              */
3731             {FALSE,NULL,0},
3732             {TRUE}
3733         }
3734     },
3735     {
3736         VARIANT_TRUE,"UTF-16",
3737         {
3738             {FALSE,(const BYTE*)szUtf16BOM,sizeof(szUtf16BOM),TRUE},
3739             {FALSE,(const BYTE*)szUtf16XML,sizeof(szUtf16XML)},
3740             {TRUE}
3741         }
3742     },
3743     {
3744         VARIANT_TRUE,"UTF-16",
3745         {
3746             {FALSE,(const BYTE*)szUtf16BOM,sizeof(szUtf16BOM),TRUE,TRUE},
3747             {FALSE,(const BYTE*)szUtf16XML,sizeof(szUtf16XML)},
3748             {TRUE}
3749         }
3750     }
3751 };
3752
3753 static void test_mxwriter_stream(void)
3754 {
3755     IMXWriter *writer;
3756     ISAXContentHandler *content;
3757     HRESULT hr;
3758     VARIANT dest;
3759     IStream *stream;
3760     LARGE_INTEGER pos;
3761     ULARGE_INTEGER pos2;
3762     DWORD test_count = sizeof(mxwriter_stream_tests)/sizeof(mxwriter_stream_tests[0]);
3763
3764     for(current_stream_test_index = 0; current_stream_test_index < test_count; ++current_stream_test_index) {
3765         const mxwriter_stream_test *test = mxwriter_stream_tests+current_stream_test_index;
3766
3767         hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
3768                 &IID_IMXWriter, (void**)&writer);
3769         ok(hr == S_OK, "CoCreateInstance failed: %08x\n", hr);
3770
3771         hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
3772         ok(hr == S_OK, "QueryInterface(ISAXContentHandler) failed: %08x\n", hr);
3773
3774         hr = IMXWriter_put_encoding(writer, _bstr_(test->encoding));
3775         ok(hr == S_OK, "put_encoding failed with %08x on test %d\n", hr, current_stream_test_index);
3776
3777         V_VT(&dest) = VT_UNKNOWN;
3778         V_UNKNOWN(&dest) = (IUnknown*)&mxstream;
3779         hr = IMXWriter_put_output(writer, dest);
3780         ok(hr == S_OK, "put_output failed with %08x on test %d\n", hr, current_stream_test_index);
3781         VariantClear(&dest);
3782
3783         hr = IMXWriter_put_byteOrderMark(writer, test->bom);
3784         ok(hr == S_OK, "put_byteOrderMark failed with %08x on test %d\n", hr, current_stream_test_index);
3785
3786         current_write_test = test->expected_writes;
3787
3788         hr = ISAXContentHandler_startDocument(content);
3789         ok(hr == S_OK, "startDocument failed with %08x on test %d\n", hr, current_stream_test_index);
3790
3791         hr = ISAXContentHandler_endDocument(content);
3792         ok(hr == S_OK, "endDocument failed with %08x on test %d\n", hr, current_stream_test_index);
3793
3794         ISAXContentHandler_Release(content);
3795         IMXWriter_Release(writer);
3796
3797         ok(current_write_test->last, "The last %d write calls on test %d were missed\n",
3798             (int)(current_write_test-test->expected_writes), current_stream_test_index);
3799     }
3800
3801     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
3802             &IID_IMXWriter, (void**)&writer);
3803     ok(hr == S_OK, "CoCreateInstance failed: %08x\n", hr);
3804
3805     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
3806     ok(hr == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hr);
3807
3808     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
3809     ok(hr == S_OK, "QueryInterface(ISAXContentHandler) failed: %08x\n", hr);
3810
3811     hr = IMXWriter_put_encoding(writer, _bstr_("UTF-8"));
3812     ok(hr == S_OK, "put_encoding failed: %08x\n", hr);
3813
3814     V_VT(&dest) = VT_UNKNOWN;
3815     V_UNKNOWN(&dest) = (IUnknown*)stream;
3816     hr = IMXWriter_put_output(writer, dest);
3817     ok(hr == S_OK, "put_output failed: %08x\n", hr);
3818
3819     hr = ISAXContentHandler_startDocument(content);
3820     ok(hr == S_OK, "startDocument failed: %08x\n", hr);
3821
3822     /* Setting output of the mxwriter causes the current output to be flushed,
3823      * and the writer to start over.
3824      */
3825     V_VT(&dest) = VT_EMPTY;
3826     hr = IMXWriter_put_output(writer, dest);
3827     ok(hr == S_OK, "put_output failed: %08x\n", hr);
3828
3829     pos.QuadPart = 0;
3830     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
3831     ok(hr == S_OK, "Seek failed: %08x\n", hr);
3832     ok(pos2.QuadPart != 0, "expected stream position moved\n");
3833
3834     hr = ISAXContentHandler_startDocument(content);
3835     ok(hr == S_OK, "startDocument failed: %08x\n", hr);
3836
3837     hr = ISAXContentHandler_endDocument(content);
3838     ok(hr == S_OK, "endDocument failed: %08x\n", hr);
3839
3840     V_VT(&dest) = VT_EMPTY;
3841     hr = IMXWriter_get_output(writer, &dest);
3842     ok(hr == S_OK, "get_output failed: %08x\n", hr);
3843     ok(V_VT(&dest) == VT_BSTR, "Expected VT_BSTR, got %d\n", V_VT(&dest));
3844     ok(!lstrcmpW(_bstr_("<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n"), V_BSTR(&dest)),
3845             "Got wrong content: %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3846     VariantClear(&dest);
3847
3848     /* test when BOM is written to output stream */
3849     V_VT(&dest) = VT_EMPTY;
3850     hr = IMXWriter_put_output(writer, dest);
3851     EXPECT_HR(hr, S_OK);
3852
3853     pos.QuadPart = 0;
3854     hr = IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
3855     EXPECT_HR(hr, S_OK);
3856
3857     V_VT(&dest) = VT_UNKNOWN;
3858     V_UNKNOWN(&dest) = (IUnknown*)stream;
3859     hr = IMXWriter_put_output(writer, dest);
3860     EXPECT_HR(hr, S_OK);
3861
3862     hr = IMXWriter_put_byteOrderMark(writer, VARIANT_TRUE);
3863     EXPECT_HR(hr, S_OK);
3864
3865     hr = IMXWriter_put_encoding(writer, _bstr_("UTF-16"));
3866     EXPECT_HR(hr, S_OK);
3867
3868     hr = ISAXContentHandler_startDocument(content);
3869     EXPECT_HR(hr, S_OK);
3870
3871     pos.QuadPart = 0;
3872     pos2.QuadPart = 0;
3873     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
3874     EXPECT_HR(hr, S_OK);
3875     ok(pos2.QuadPart == 2, "got wrong position\n");
3876
3877     ISAXContentHandler_Release(content);
3878     IMXWriter_Release(writer);
3879
3880     free_bstrs();
3881 }
3882
3883 static const char *encoding_names[] = {
3884     "iso-8859-1",
3885     "iso-8859-2",
3886     "iso-8859-3",
3887     "iso-8859-4",
3888     "iso-8859-5",
3889     "iso-8859-7",
3890     "iso-8859-9",
3891     "iso-8859-13",
3892     "iso-8859-15",
3893     NULL
3894 };
3895
3896 static void test_mxwriter_encoding(void)
3897 {
3898     ISAXContentHandler *content;
3899     IMXWriter *writer;
3900     IStream *stream;
3901     const char *enc;
3902     VARIANT dest;
3903     HRESULT hr;
3904     HGLOBAL g;
3905     char *ptr;
3906     BSTR s;
3907     int i;
3908
3909     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
3910             &IID_IMXWriter, (void**)&writer);
3911     EXPECT_HR(hr, S_OK);
3912
3913     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
3914     EXPECT_HR(hr, S_OK);
3915
3916     hr = IMXWriter_put_encoding(writer, _bstr_("UTF-8"));
3917     EXPECT_HR(hr, S_OK);
3918
3919     hr = ISAXContentHandler_startDocument(content);
3920     EXPECT_HR(hr, S_OK);
3921
3922     hr = ISAXContentHandler_endDocument(content);
3923     EXPECT_HR(hr, S_OK);
3924
3925     /* The content is always re-encoded to UTF-16 when the output is
3926      * retrieved as a BSTR.
3927      */
3928     V_VT(&dest) = VT_EMPTY;
3929     hr = IMXWriter_get_output(writer, &dest);
3930     EXPECT_HR(hr, S_OK);
3931     ok(V_VT(&dest) == VT_BSTR, "Expected VT_BSTR, got %d\n", V_VT(&dest));
3932     ok(!lstrcmpW(_bstr_("<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n"), V_BSTR(&dest)),
3933             "got wrong content: %s\n", wine_dbgstr_w(V_BSTR(&dest)));
3934     VariantClear(&dest);
3935
3936     /* switch encoding when something is written already */
3937     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
3938     EXPECT_HR(hr, S_OK);
3939
3940     V_VT(&dest) = VT_UNKNOWN;
3941     V_UNKNOWN(&dest) = (IUnknown*)stream;
3942     hr = IMXWriter_put_output(writer, dest);
3943     EXPECT_HR(hr, S_OK);
3944
3945     hr = IMXWriter_put_encoding(writer, _bstr_("UTF-8"));
3946     EXPECT_HR(hr, S_OK);
3947
3948     /* write empty element */
3949     hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("a"), 1, NULL);
3950     EXPECT_HR(hr, S_OK);
3951
3952     hr = ISAXContentHandler_endElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("a"), 1);
3953     EXPECT_HR(hr, S_OK);
3954
3955     /* switch */
3956     hr = IMXWriter_put_encoding(writer, _bstr_("UTF-16"));
3957     EXPECT_HR(hr, S_OK);
3958
3959     hr = IMXWriter_flush(writer);
3960     EXPECT_HR(hr, S_OK);
3961
3962     hr = GetHGlobalFromStream(stream, &g);
3963     EXPECT_HR(hr, S_OK);
3964
3965     ptr = GlobalLock(g);
3966     ok(!strncmp(ptr, "<a/>", 4), "got %c%c%c%c\n", ptr[0],ptr[1],ptr[2],ptr[3]);
3967     GlobalUnlock(g);
3968
3969     /* so output is unaffected, encoding name is stored however */
3970     hr = IMXWriter_get_encoding(writer, &s);
3971     EXPECT_HR(hr, S_OK);
3972     ok(!lstrcmpW(s, _bstr_("UTF-16")), "got %s\n", wine_dbgstr_w(s));
3973     SysFreeString(s);
3974
3975     IStream_Release(stream);
3976
3977     i = 0;
3978     enc = encoding_names[i];
3979     while (enc)
3980     {
3981         char expectedA[200];
3982
3983         hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
3984         EXPECT_HR(hr, S_OK);
3985
3986         V_VT(&dest) = VT_UNKNOWN;
3987         V_UNKNOWN(&dest) = (IUnknown*)stream;
3988         hr = IMXWriter_put_output(writer, dest);
3989         EXPECT_HR(hr, S_OK);
3990
3991         hr = IMXWriter_put_encoding(writer, _bstr_(enc));
3992         ok(hr == S_OK || broken(hr != S_OK) /* old win versions do not support certain encodings */,
3993             "%s: encoding not accepted\n", enc);
3994         if (hr != S_OK)
3995         {
3996             enc = encoding_names[++i];
3997             IStream_Release(stream);
3998             continue;
3999         }
4000
4001         hr = ISAXContentHandler_startDocument(content);
4002         EXPECT_HR(hr, S_OK);
4003
4004         hr = ISAXContentHandler_endDocument(content);
4005         EXPECT_HR(hr, S_OK);
4006
4007         hr = IMXWriter_flush(writer);
4008         EXPECT_HR(hr, S_OK);
4009
4010         /* prepare expected string */
4011         *expectedA = 0;
4012         strcat(expectedA, "<?xml version=\"1.0\" encoding=\"");
4013         strcat(expectedA, enc);
4014         strcat(expectedA, "\" standalone=\"no\"?>\r\n");
4015
4016         hr = GetHGlobalFromStream(stream, &g);
4017         EXPECT_HR(hr, S_OK);
4018
4019         ptr = GlobalLock(g);
4020         ok(!strncmp(ptr, expectedA, strlen(expectedA)), "%s: got %s, expected %.50s\n", enc, ptr, expectedA);
4021         GlobalUnlock(g);
4022
4023         V_VT(&dest) = VT_EMPTY;
4024         hr = IMXWriter_put_output(writer, dest);
4025         EXPECT_HR(hr, S_OK);
4026
4027         IStream_Release(stream);
4028
4029         enc = encoding_names[++i];
4030     }
4031
4032     ISAXContentHandler_Release(content);
4033     IMXWriter_Release(writer);
4034
4035     free_bstrs();
4036 }
4037
4038 static void test_obj_dispex(IUnknown *obj)
4039 {
4040     static const WCHAR starW[] = {'*',0};
4041     DISPID dispid = DISPID_SAX_XMLREADER_GETFEATURE;
4042     IDispatchEx *dispex;
4043     IUnknown *unk;
4044     DWORD props;
4045     UINT ticnt;
4046     HRESULT hr;
4047     BSTR name;
4048
4049     hr = IUnknown_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
4050     EXPECT_HR(hr, S_OK);
4051     if (FAILED(hr)) return;
4052
4053     ticnt = 0;
4054     hr = IDispatchEx_GetTypeInfoCount(dispex, &ticnt);
4055     EXPECT_HR(hr, S_OK);
4056     ok(ticnt == 1, "ticnt=%u\n", ticnt);
4057
4058     name = SysAllocString(starW);
4059     hr = IDispatchEx_DeleteMemberByName(dispex, name, fdexNameCaseSensitive);
4060     EXPECT_HR(hr, E_NOTIMPL);
4061     SysFreeString(name);
4062
4063     hr = IDispatchEx_DeleteMemberByDispID(dispex, dispid);
4064     EXPECT_HR(hr, E_NOTIMPL);
4065
4066     props = 0;
4067     hr = IDispatchEx_GetMemberProperties(dispex, dispid, grfdexPropCanAll, &props);
4068     EXPECT_HR(hr, E_NOTIMPL);
4069     ok(props == 0, "expected 0 got %d\n", props);
4070
4071     hr = IDispatchEx_GetMemberName(dispex, dispid, &name);
4072     EXPECT_HR(hr, E_NOTIMPL);
4073     if (SUCCEEDED(hr)) SysFreeString(name);
4074
4075     hr = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, DISPID_SAX_XMLREADER_GETFEATURE, &dispid);
4076     EXPECT_HR(hr, E_NOTIMPL);
4077
4078     hr = IDispatchEx_GetNameSpaceParent(dispex, &unk);
4079     EXPECT_HR(hr, E_NOTIMPL);
4080     if (hr == S_OK && unk) IUnknown_Release(unk);
4081
4082     IDispatchEx_Release(dispex);
4083 }
4084
4085 static void test_dispex(void)
4086 {
4087      IVBSAXXMLReader *vbreader;
4088      ISAXXMLReader *reader;
4089      IUnknown *unk;
4090      HRESULT hr;
4091
4092      hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
4093                 &IID_ISAXXMLReader, (void**)&reader);
4094      EXPECT_HR(hr, S_OK);
4095
4096      hr = ISAXXMLReader_QueryInterface(reader, &IID_IUnknown, (void**)&unk);
4097      EXPECT_HR(hr, S_OK);
4098      test_obj_dispex(unk);
4099      IUnknown_Release(unk);
4100
4101      hr = ISAXXMLReader_QueryInterface(reader, &IID_IVBSAXXMLReader, (void**)&vbreader);
4102      EXPECT_HR(hr, S_OK);
4103      hr = IVBSAXXMLReader_QueryInterface(vbreader, &IID_IUnknown, (void**)&unk);
4104      EXPECT_HR(hr, S_OK);
4105      test_obj_dispex(unk);
4106      IUnknown_Release(unk);
4107      IVBSAXXMLReader_Release(vbreader);
4108
4109      ISAXXMLReader_Release(reader);
4110 }
4111
4112 static void test_mxwriter_dispex(void)
4113 {
4114     IDispatchEx *dispex;
4115     IMXWriter *writer;
4116     IUnknown *unk;
4117     HRESULT hr;
4118
4119     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
4120             &IID_IMXWriter, (void**)&writer);
4121     EXPECT_HR(hr, S_OK);
4122
4123     hr = IMXWriter_QueryInterface(writer, &IID_IDispatchEx, (void**)&dispex);
4124     EXPECT_HR(hr, S_OK);
4125     hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
4126     test_obj_dispex(unk);
4127     IUnknown_Release(unk);
4128     IDispatchEx_Release(dispex);
4129
4130     IMXWriter_Release(writer);
4131 }
4132
4133 static void test_mxwriter_comment(void)
4134 {
4135     static const WCHAR commentW[] = {'c','o','m','m','e','n','t',0};
4136     ISAXContentHandler *content;
4137     ISAXLexicalHandler *lexical;
4138     IMXWriter *writer;
4139     VARIANT dest;
4140     HRESULT hr;
4141
4142     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
4143             &IID_IMXWriter, (void**)&writer);
4144     EXPECT_HR(hr, S_OK);
4145
4146     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
4147     EXPECT_HR(hr, S_OK);
4148
4149     hr = IMXWriter_QueryInterface(writer, &IID_ISAXLexicalHandler, (void**)&lexical);
4150     EXPECT_HR(hr, S_OK);
4151
4152     hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
4153     EXPECT_HR(hr, S_OK);
4154
4155     hr = ISAXContentHandler_startDocument(content);
4156     EXPECT_HR(hr, S_OK);
4157
4158     hr = ISAXLexicalHandler_comment(lexical, NULL, 0);
4159     EXPECT_HR(hr, E_INVALIDARG);
4160
4161     hr = ISAXLexicalHandler_comment(lexical, commentW, 0);
4162     EXPECT_HR(hr, S_OK);
4163
4164     V_VT(&dest) = VT_EMPTY;
4165     hr = IMXWriter_get_output(writer, &dest);
4166     EXPECT_HR(hr, S_OK);
4167     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4168     ok(!lstrcmpW(_bstr_("<!---->\r\n"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4169     VariantClear(&dest);
4170
4171     hr = ISAXLexicalHandler_comment(lexical, commentW, sizeof(commentW)/sizeof(WCHAR)-1);
4172     EXPECT_HR(hr, S_OK);
4173
4174     V_VT(&dest) = VT_EMPTY;
4175     hr = IMXWriter_get_output(writer, &dest);
4176     EXPECT_HR(hr, S_OK);
4177     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4178     ok(!lstrcmpW(_bstr_("<!---->\r\n<!--comment-->\r\n"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4179     VariantClear(&dest);
4180
4181     ISAXContentHandler_Release(content);
4182     ISAXLexicalHandler_Release(lexical);
4183     IMXWriter_Release(writer);
4184     free_bstrs();
4185 }
4186
4187 static void test_mxwriter_cdata(void)
4188 {
4189     ISAXContentHandler *content;
4190     ISAXLexicalHandler *lexical;
4191     IMXWriter *writer;
4192     VARIANT dest;
4193     HRESULT hr;
4194
4195     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
4196             &IID_IMXWriter, (void**)&writer);
4197     EXPECT_HR(hr, S_OK);
4198
4199     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
4200     EXPECT_HR(hr, S_OK);
4201
4202     hr = IMXWriter_QueryInterface(writer, &IID_ISAXLexicalHandler, (void**)&lexical);
4203     EXPECT_HR(hr, S_OK);
4204
4205     hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
4206     EXPECT_HR(hr, S_OK);
4207
4208     hr = ISAXContentHandler_startDocument(content);
4209     EXPECT_HR(hr, S_OK);
4210
4211     hr = ISAXLexicalHandler_startCDATA(lexical);
4212     EXPECT_HR(hr, S_OK);
4213
4214     V_VT(&dest) = VT_EMPTY;
4215     hr = IMXWriter_get_output(writer, &dest);
4216     EXPECT_HR(hr, S_OK);
4217     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4218     ok(!lstrcmpW(_bstr_("<![CDATA["), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4219     VariantClear(&dest);
4220
4221     hr = ISAXLexicalHandler_startCDATA(lexical);
4222     EXPECT_HR(hr, S_OK);
4223
4224     /* all these are escaped for text nodes */
4225     hr = ISAXContentHandler_characters(content, _bstr_("< > & \""), 7);
4226     EXPECT_HR(hr, S_OK);
4227
4228     hr = ISAXLexicalHandler_endCDATA(lexical);
4229     EXPECT_HR(hr, S_OK);
4230
4231     V_VT(&dest) = VT_EMPTY;
4232     hr = IMXWriter_get_output(writer, &dest);
4233     EXPECT_HR(hr, S_OK);
4234     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4235     ok(!lstrcmpW(_bstr_("<![CDATA[<![CDATA[< > & \"]]>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4236     VariantClear(&dest);
4237
4238     ISAXContentHandler_Release(content);
4239     ISAXLexicalHandler_Release(lexical);
4240     IMXWriter_Release(writer);
4241     free_bstrs();
4242 }
4243
4244 static void test_mxwriter_pi(void)
4245 {
4246     static const WCHAR targetW[] = {'t','a','r','g','e','t',0};
4247     static const WCHAR dataW[] = {'d','a','t','a',0};
4248     ISAXContentHandler *content;
4249     IMXWriter *writer;
4250     VARIANT dest;
4251     HRESULT hr;
4252
4253     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
4254             &IID_IMXWriter, (void**)&writer);
4255     EXPECT_HR(hr, S_OK);
4256
4257     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
4258     EXPECT_HR(hr, S_OK);
4259
4260     hr = ISAXContentHandler_processingInstruction(content, NULL, 0, NULL, 0);
4261     EXPECT_HR(hr, E_INVALIDARG);
4262
4263     hr = ISAXContentHandler_processingInstruction(content, targetW, 0, NULL, 0);
4264     EXPECT_HR(hr, S_OK);
4265
4266     hr = ISAXContentHandler_processingInstruction(content, targetW, 6, NULL, 0);
4267     EXPECT_HR(hr, S_OK);
4268
4269     V_VT(&dest) = VT_EMPTY;
4270     hr = IMXWriter_get_output(writer, &dest);
4271     EXPECT_HR(hr, S_OK);
4272     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4273     ok(!lstrcmpW(_bstr_("<?\?>\r\n<?target?>\r\n"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4274     VariantClear(&dest);
4275
4276     hr = ISAXContentHandler_processingInstruction(content, targetW, 4, dataW, 4);
4277     EXPECT_HR(hr, S_OK);
4278
4279     V_VT(&dest) = VT_EMPTY;
4280     hr = IMXWriter_get_output(writer, &dest);
4281     EXPECT_HR(hr, S_OK);
4282     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4283     ok(!lstrcmpW(_bstr_("<?\?>\r\n<?target?>\r\n<?targ data?>\r\n"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4284     VariantClear(&dest);
4285
4286     V_VT(&dest) = VT_EMPTY;
4287     hr = IMXWriter_put_output(writer, dest);
4288     EXPECT_HR(hr, S_OK);
4289
4290     hr = ISAXContentHandler_processingInstruction(content, targetW, 6, dataW, 0);
4291     EXPECT_HR(hr, S_OK);
4292
4293     V_VT(&dest) = VT_EMPTY;
4294     hr = IMXWriter_get_output(writer, &dest);
4295     EXPECT_HR(hr, S_OK);
4296     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4297     ok(!lstrcmpW(_bstr_("<?target?>\r\n"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4298     VariantClear(&dest);
4299
4300
4301     ISAXContentHandler_Release(content);
4302     IMXWriter_Release(writer);
4303 }
4304
4305 static void test_mxwriter_ignorablespaces(void)
4306 {
4307     static const WCHAR dataW[] = {'d','a','t','a',0};
4308     ISAXContentHandler *content;
4309     IMXWriter *writer;
4310     VARIANT dest;
4311     HRESULT hr;
4312
4313     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
4314             &IID_IMXWriter, (void**)&writer);
4315     EXPECT_HR(hr, S_OK);
4316
4317     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
4318     EXPECT_HR(hr, S_OK);
4319
4320     hr = ISAXContentHandler_ignorableWhitespace(content, NULL, 0);
4321     EXPECT_HR(hr, E_INVALIDARG);
4322
4323     hr = ISAXContentHandler_ignorableWhitespace(content, dataW, 0);
4324     EXPECT_HR(hr, S_OK);
4325
4326     hr = ISAXContentHandler_ignorableWhitespace(content, dataW, 4);
4327     EXPECT_HR(hr, S_OK);
4328
4329     hr = ISAXContentHandler_ignorableWhitespace(content, dataW, 1);
4330     EXPECT_HR(hr, S_OK);
4331
4332     V_VT(&dest) = VT_EMPTY;
4333     hr = IMXWriter_get_output(writer, &dest);
4334     EXPECT_HR(hr, S_OK);
4335     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4336     ok(!lstrcmpW(_bstr_("datad"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4337     VariantClear(&dest);
4338
4339     ISAXContentHandler_Release(content);
4340     IMXWriter_Release(writer);
4341 }
4342
4343 static void test_mxwriter_dtd(void)
4344 {
4345     static const WCHAR contentW[] = {'c','o','n','t','e','n','t'};
4346     static const WCHAR nameW[] = {'n','a','m','e'};
4347     static const WCHAR pubW[] = {'p','u','b'};
4348     static const WCHAR sysW[] = {'s','y','s'};
4349     ISAXContentHandler *content;
4350     ISAXLexicalHandler *lexical;
4351     ISAXDeclHandler *decl;
4352     IMXWriter *writer;
4353     VARIANT dest;
4354     HRESULT hr;
4355
4356     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
4357             &IID_IMXWriter, (void**)&writer);
4358     EXPECT_HR(hr, S_OK);
4359
4360     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
4361     EXPECT_HR(hr, S_OK);
4362
4363     hr = IMXWriter_QueryInterface(writer, &IID_ISAXLexicalHandler, (void**)&lexical);
4364     EXPECT_HR(hr, S_OK);
4365
4366     hr = IMXWriter_QueryInterface(writer, &IID_ISAXDeclHandler, (void**)&decl);
4367     EXPECT_HR(hr, S_OK);
4368
4369     hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
4370     EXPECT_HR(hr, S_OK);
4371
4372     hr = ISAXContentHandler_startDocument(content);
4373     EXPECT_HR(hr, S_OK);
4374
4375     hr = ISAXLexicalHandler_startDTD(lexical, NULL, 0, NULL, 0, NULL, 0);
4376     EXPECT_HR(hr, E_INVALIDARG);
4377
4378     hr = ISAXLexicalHandler_startDTD(lexical, NULL, 0, pubW, sizeof(pubW)/sizeof(WCHAR), NULL, 0);
4379     EXPECT_HR(hr, E_INVALIDARG);
4380
4381     hr = ISAXLexicalHandler_startDTD(lexical, NULL, 0, NULL, 0, sysW, sizeof(sysW)/sizeof(WCHAR));
4382     EXPECT_HR(hr, E_INVALIDARG);
4383
4384     hr = ISAXLexicalHandler_startDTD(lexical, NULL, 0, pubW, sizeof(pubW)/sizeof(WCHAR), sysW, sizeof(sysW)/sizeof(WCHAR));
4385     EXPECT_HR(hr, E_INVALIDARG);
4386
4387     hr = ISAXLexicalHandler_startDTD(lexical, nameW, sizeof(nameW)/sizeof(WCHAR), NULL, 0, NULL, 0);
4388     EXPECT_HR(hr, S_OK);
4389
4390     V_VT(&dest) = VT_EMPTY;
4391     hr = IMXWriter_get_output(writer, &dest);
4392     EXPECT_HR(hr, S_OK);
4393     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4394     ok(!lstrcmpW(_bstr_("<!DOCTYPE name [\r\n"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4395     VariantClear(&dest);
4396
4397     /* system id is required if public is present */
4398     hr = ISAXLexicalHandler_startDTD(lexical, nameW, sizeof(nameW)/sizeof(WCHAR), pubW, sizeof(pubW)/sizeof(WCHAR), NULL, 0);
4399     EXPECT_HR(hr, E_INVALIDARG);
4400
4401     hr = ISAXLexicalHandler_startDTD(lexical, nameW, sizeof(nameW)/sizeof(WCHAR),
4402         pubW, sizeof(pubW)/sizeof(WCHAR), sysW, sizeof(sysW)/sizeof(WCHAR));
4403     EXPECT_HR(hr, S_OK);
4404
4405     V_VT(&dest) = VT_EMPTY;
4406     hr = IMXWriter_get_output(writer, &dest);
4407     EXPECT_HR(hr, S_OK);
4408     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4409     ok(!lstrcmpW(_bstr_("<!DOCTYPE name [\r\n<!DOCTYPE name PUBLIC \"pub\""
4410         "<!DOCTYPE name PUBLIC \"pub\" \"sys\" [\r\n"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4411     VariantClear(&dest);
4412
4413     hr = ISAXLexicalHandler_endDTD(lexical);
4414     EXPECT_HR(hr, S_OK);
4415
4416     hr = ISAXLexicalHandler_endDTD(lexical);
4417     EXPECT_HR(hr, S_OK);
4418
4419     V_VT(&dest) = VT_EMPTY;
4420     hr = IMXWriter_get_output(writer, &dest);
4421     EXPECT_HR(hr, S_OK);
4422     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4423     ok(!lstrcmpW(_bstr_("<!DOCTYPE name [\r\n<!DOCTYPE name PUBLIC \"pub\""
4424          "<!DOCTYPE name PUBLIC \"pub\" \"sys\" [\r\n]>\r\n]>\r\n"),
4425         V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4426     VariantClear(&dest);
4427
4428     /* element declaration */
4429     V_VT(&dest) = VT_EMPTY;
4430     hr = IMXWriter_put_output(writer, dest);
4431     EXPECT_HR(hr, S_OK);
4432
4433     hr = ISAXDeclHandler_elementDecl(decl, NULL, 0, NULL, 0);
4434     EXPECT_HR(hr, E_INVALIDARG);
4435
4436     hr = ISAXDeclHandler_elementDecl(decl, nameW, sizeof(nameW)/sizeof(WCHAR), NULL, 0);
4437     EXPECT_HR(hr, E_INVALIDARG);
4438
4439     hr = ISAXDeclHandler_elementDecl(decl, nameW, sizeof(nameW)/sizeof(WCHAR), contentW, sizeof(contentW)/sizeof(WCHAR));
4440     EXPECT_HR(hr, S_OK);
4441
4442     V_VT(&dest) = VT_EMPTY;
4443     hr = IMXWriter_get_output(writer, &dest);
4444     EXPECT_HR(hr, S_OK);
4445     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4446     ok(!lstrcmpW(_bstr_("<!ELEMENT name content>\r\n"),
4447         V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4448     VariantClear(&dest);
4449
4450     V_VT(&dest) = VT_EMPTY;
4451     hr = IMXWriter_put_output(writer, dest);
4452     EXPECT_HR(hr, S_OK);
4453
4454     hr = ISAXDeclHandler_elementDecl(decl, nameW, sizeof(nameW)/sizeof(WCHAR), contentW, 0);
4455     EXPECT_HR(hr, S_OK);
4456
4457     V_VT(&dest) = VT_EMPTY;
4458     hr = IMXWriter_get_output(writer, &dest);
4459     EXPECT_HR(hr, S_OK);
4460     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4461     ok(!lstrcmpW(_bstr_("<!ELEMENT name >\r\n"),
4462         V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4463     VariantClear(&dest);
4464
4465     /* attribute declaration */
4466     V_VT(&dest) = VT_EMPTY;
4467     hr = IMXWriter_put_output(writer, dest);
4468     EXPECT_HR(hr, S_OK);
4469
4470     hr = ISAXDeclHandler_attributeDecl(decl, _bstr_("element"), strlen("element"),
4471         _bstr_("attribute"), strlen("attribute"), _bstr_("CDATA"), strlen("CDATA"),
4472         _bstr_("#REQUIRED"), strlen("#REQUIRED"), _bstr_("value"), strlen("value"));
4473     EXPECT_HR(hr, S_OK);
4474
4475     V_VT(&dest) = VT_EMPTY;
4476     hr = IMXWriter_get_output(writer, &dest);
4477     EXPECT_HR(hr, S_OK);
4478     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4479     ok(!lstrcmpW(_bstr_("<!ATTLIST element attribute CDATA #REQUIRED \"value\">\r\n"),
4480         V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4481     VariantClear(&dest);
4482
4483     hr = ISAXDeclHandler_attributeDecl(decl, _bstr_("element"), strlen("element"),
4484         _bstr_("attribute2"), strlen("attribute2"), _bstr_("CDATA"), strlen("CDATA"),
4485         _bstr_("#REQUIRED"), strlen("#REQUIRED"), _bstr_("value2"), strlen("value2"));
4486     EXPECT_HR(hr, S_OK);
4487
4488     hr = ISAXDeclHandler_attributeDecl(decl, _bstr_("element2"), strlen("element2"),
4489         _bstr_("attribute3"), strlen("attribute3"), _bstr_("CDATA"), strlen("CDATA"),
4490         _bstr_("#REQUIRED"), strlen("#REQUIRED"), _bstr_("value3"), strlen("value3"));
4491     EXPECT_HR(hr, S_OK);
4492
4493     V_VT(&dest) = VT_EMPTY;
4494     hr = IMXWriter_get_output(writer, &dest);
4495     EXPECT_HR(hr, S_OK);
4496     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4497     ok(!lstrcmpW(_bstr_("<!ATTLIST element attribute CDATA #REQUIRED \"value\">\r\n"
4498                         "<!ATTLIST element attribute2 CDATA #REQUIRED \"value2\">\r\n"
4499                         "<!ATTLIST element2 attribute3 CDATA #REQUIRED \"value3\">\r\n"),
4500         V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4501     VariantClear(&dest);
4502
4503     /* internal entities */
4504     V_VT(&dest) = VT_EMPTY;
4505     hr = IMXWriter_put_output(writer, dest);
4506     EXPECT_HR(hr, S_OK);
4507
4508     hr = ISAXDeclHandler_internalEntityDecl(decl, NULL, 0, NULL, 0);
4509     EXPECT_HR(hr, E_INVALIDARG);
4510
4511     hr = ISAXDeclHandler_internalEntityDecl(decl, _bstr_("name"), -1, NULL, 0);
4512     EXPECT_HR(hr, E_INVALIDARG);
4513
4514     hr = ISAXDeclHandler_internalEntityDecl(decl, _bstr_("name"), strlen("name"), _bstr_("value"), strlen("value"));
4515     EXPECT_HR(hr, S_OK);
4516
4517     V_VT(&dest) = VT_EMPTY;
4518     hr = IMXWriter_get_output(writer, &dest);
4519     EXPECT_HR(hr, S_OK);
4520     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
4521     ok(!lstrcmpW(_bstr_("<!ENTITY name \"value\">\r\n"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
4522     VariantClear(&dest);
4523
4524     ISAXContentHandler_Release(content);
4525     ISAXLexicalHandler_Release(lexical);
4526     ISAXDeclHandler_Release(decl);
4527     IMXWriter_Release(writer);
4528     free_bstrs();
4529 }
4530
4531 typedef struct {
4532     const CLSID *clsid;
4533     const char *uri;
4534     const char *local;
4535     const char *qname;
4536     const char *type;
4537     const char *value;
4538     HRESULT hr;
4539 } addattribute_test_t;
4540
4541 static const addattribute_test_t addattribute_data[] = {
4542     { &CLSID_SAXAttributes,   NULL, NULL, "ns:qname", NULL, "value", E_INVALIDARG },
4543     { &CLSID_SAXAttributes30, NULL, NULL, "ns:qname", NULL, "value", E_INVALIDARG },
4544     { &CLSID_SAXAttributes40, NULL, NULL, "ns:qname", NULL, "value", E_INVALIDARG },
4545     { &CLSID_SAXAttributes60, NULL, NULL, "ns:qname", NULL, "value", S_OK },
4546
4547     { &CLSID_SAXAttributes,   NULL, "qname", "ns:qname", NULL, "value", E_INVALIDARG },
4548     { &CLSID_SAXAttributes30, NULL, "qname", "ns:qname", NULL, "value", E_INVALIDARG },
4549     { &CLSID_SAXAttributes40, NULL, "qname", "ns:qname", NULL, "value", E_INVALIDARG },
4550     { &CLSID_SAXAttributes60, NULL, "qname", "ns:qname", NULL, "value", S_OK },
4551
4552     { &CLSID_SAXAttributes,   "uri", "qname", "ns:qname", NULL, "value", E_INVALIDARG },
4553     { &CLSID_SAXAttributes30, "uri", "qname", "ns:qname", NULL, "value", E_INVALIDARG },
4554     { &CLSID_SAXAttributes40, "uri", "qname", "ns:qname", NULL, "value", E_INVALIDARG },
4555     { &CLSID_SAXAttributes60, "uri", "qname", "ns:qname", NULL, "value", S_OK },
4556
4557     { &CLSID_SAXAttributes,   "uri", "qname", "ns:qname", "type", "value", S_OK },
4558     { &CLSID_SAXAttributes30, "uri", "qname", "ns:qname", "type", "value", S_OK },
4559     { &CLSID_SAXAttributes40, "uri", "qname", "ns:qname", "type", "value", S_OK },
4560     { &CLSID_SAXAttributes60, "uri", "qname", "ns:qname", "type", "value", S_OK },
4561
4562     { NULL }
4563 };
4564
4565 static void test_mxattr_addAttribute(void)
4566 {
4567     const addattribute_test_t *table = addattribute_data;
4568     int i = 0;
4569
4570     while (table->clsid)
4571     {
4572         ISAXAttributes *saxattr;
4573         IMXAttributes *mxattr;
4574         const WCHAR *value;
4575         int len, index;
4576         HRESULT hr;
4577
4578         if (!is_clsid_supported(table->clsid, mxattributes_support_data))
4579         {
4580             table++;
4581             i++;
4582             continue;
4583         }
4584
4585         hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
4586             &IID_IMXAttributes, (void**)&mxattr);
4587         EXPECT_HR(hr, S_OK);
4588
4589         hr = IMXAttributes_QueryInterface(mxattr, &IID_ISAXAttributes, (void**)&saxattr);
4590         EXPECT_HR(hr, S_OK);
4591
4592         /* SAXAttributes40 and SAXAttributes60 both crash on this test */
4593         if (IsEqualGUID(table->clsid, &CLSID_SAXAttributes) ||
4594             IsEqualGUID(table->clsid, &CLSID_SAXAttributes30))
4595         {
4596             hr = ISAXAttributes_getLength(saxattr, NULL);
4597             EXPECT_HR(hr, E_POINTER);
4598         }
4599
4600         len = -1;
4601         hr = ISAXAttributes_getLength(saxattr, &len);
4602         EXPECT_HR(hr, S_OK);
4603         ok(len == 0, "got %d\n", len);
4604
4605         hr = ISAXAttributes_getValue(saxattr, 0, &value, &len);
4606         EXPECT_HR(hr, E_INVALIDARG);
4607
4608         hr = ISAXAttributes_getValue(saxattr, 0, NULL, &len);
4609         EXPECT_HR(hr, E_INVALIDARG);
4610
4611         hr = ISAXAttributes_getValue(saxattr, 0, &value, NULL);
4612         EXPECT_HR(hr, E_INVALIDARG);
4613
4614         hr = ISAXAttributes_getValue(saxattr, 0, NULL, NULL);
4615         EXPECT_HR(hr, E_INVALIDARG);
4616
4617         hr = ISAXAttributes_getType(saxattr, 0, &value, &len);
4618         EXPECT_HR(hr, E_INVALIDARG);
4619
4620         hr = ISAXAttributes_getType(saxattr, 0, NULL, &len);
4621         EXPECT_HR(hr, E_INVALIDARG);
4622
4623         hr = ISAXAttributes_getType(saxattr, 0, &value, NULL);
4624         EXPECT_HR(hr, E_INVALIDARG);
4625
4626         hr = ISAXAttributes_getType(saxattr, 0, NULL, NULL);
4627         EXPECT_HR(hr, E_INVALIDARG);
4628
4629         hr = IMXAttributes_addAttribute(mxattr, _bstr_(table->uri), _bstr_(table->local),
4630             _bstr_(table->qname), _bstr_(table->type), _bstr_(table->value));
4631         ok(hr == table->hr, "%d: got 0x%08x, expected 0x%08x\n", i, hr, table->hr);
4632
4633         if (hr == S_OK)
4634         {
4635             /* SAXAttributes40 and SAXAttributes60 both crash on this test */
4636             if (IsEqualGUID(table->clsid, &CLSID_SAXAttributes) ||
4637                 IsEqualGUID(table->clsid, &CLSID_SAXAttributes30))
4638             {
4639                hr = ISAXAttributes_getValue(saxattr, 0, NULL, &len);
4640                EXPECT_HR(hr, E_POINTER);
4641
4642                hr = ISAXAttributes_getValue(saxattr, 0, &value, NULL);
4643                EXPECT_HR(hr, E_POINTER);
4644
4645                hr = ISAXAttributes_getValue(saxattr, 0, NULL, NULL);
4646                EXPECT_HR(hr, E_POINTER);
4647
4648                hr = ISAXAttributes_getType(saxattr, 0, NULL, &len);
4649                EXPECT_HR(hr, E_POINTER);
4650
4651                hr = ISAXAttributes_getType(saxattr, 0, &value, NULL);
4652                EXPECT_HR(hr, E_POINTER);
4653
4654                hr = ISAXAttributes_getType(saxattr, 0, NULL, NULL);
4655                EXPECT_HR(hr, E_POINTER);
4656             }
4657
4658             len = -1;
4659             hr = ISAXAttributes_getValue(saxattr, 0, &value, &len);
4660             EXPECT_HR(hr, S_OK);
4661             ok(!lstrcmpW(_bstr_(table->value), value), "%d: got %s, expected %s\n", i, wine_dbgstr_w(value),
4662                 table->value);
4663             ok(lstrlenW(value) == len, "%d: got wrong value length %d\n", i, len);
4664
4665             len = -1;
4666             value = (void*)0xdeadbeef;
4667             hr = ISAXAttributes_getType(saxattr, 0, &value, &len);
4668             EXPECT_HR(hr, S_OK);
4669
4670             if (table->type)
4671             {
4672                 ok(!lstrcmpW(_bstr_(table->type), value), "%d: got %s, expected %s\n", i, wine_dbgstr_w(value),
4673                     table->type);
4674                 ok(lstrlenW(value) == len, "%d: got wrong type value length %d\n", i, len);
4675             }
4676             else
4677             {
4678                 ok(*value == 0, "%d: got type value %s\n", i, wine_dbgstr_w(value));
4679                 ok(len == 0, "%d: got wrong type value length %d\n", i, len);
4680             }
4681
4682             hr = ISAXAttributes_getIndexFromQName(saxattr, NULL, 0, NULL);
4683             if (IsEqualGUID(table->clsid, &CLSID_SAXAttributes) ||
4684                 IsEqualGUID(table->clsid, &CLSID_SAXAttributes30))
4685             {
4686                 EXPECT_HR(hr, E_POINTER);
4687             }
4688             else
4689                 EXPECT_HR(hr, E_INVALIDARG);
4690
4691             hr = ISAXAttributes_getIndexFromQName(saxattr, NULL, 0, &index);
4692             EXPECT_HR(hr, E_INVALIDARG);
4693
4694             index = -1;
4695             hr = ISAXAttributes_getIndexFromQName(saxattr, _bstr_("nonexistent"), 11, &index);
4696             EXPECT_HR(hr, E_INVALIDARG);
4697             ok(index == -1, "%d: got wrong index %d\n", i, index);
4698
4699             index = -1;
4700             hr = ISAXAttributes_getIndexFromQName(saxattr, _bstr_(table->qname), 0, &index);
4701             EXPECT_HR(hr, E_INVALIDARG);
4702             ok(index == -1, "%d: got wrong index %d\n", i, index);
4703
4704             index = -1;
4705             hr = ISAXAttributes_getIndexFromQName(saxattr, _bstr_(table->qname), strlen(table->qname), &index);
4706             EXPECT_HR(hr, S_OK);
4707             ok(index == 0, "%d: got wrong index %d\n", i, index);
4708
4709             index = -1;
4710             hr = ISAXAttributes_getIndexFromQName(saxattr, _bstr_(table->qname), strlen(table->qname)-1, &index);
4711             EXPECT_HR(hr, E_INVALIDARG);
4712             ok(index == -1, "%d: got wrong index %d\n", i, index);
4713
4714             if (IsEqualGUID(table->clsid, &CLSID_SAXAttributes40) ||
4715                 IsEqualGUID(table->clsid, &CLSID_SAXAttributes60))
4716             {
4717                 hr = ISAXAttributes_getValueFromQName(saxattr, NULL, 0, NULL, NULL);
4718                 EXPECT_HR(hr, E_INVALIDARG);
4719
4720                 hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), 0, NULL, NULL);
4721                 EXPECT_HR(hr, E_INVALIDARG);
4722
4723                 hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), 0, &value, NULL);
4724                 EXPECT_HR(hr, E_INVALIDARG);
4725
4726                 hr = ISAXAttributes_getValueFromName(saxattr, NULL, 0, NULL, 0, NULL, NULL);
4727                 EXPECT_HR(hr, E_INVALIDARG);
4728
4729                 hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), 0, NULL, 0, NULL, NULL);
4730                 EXPECT_HR(hr, E_INVALIDARG);
4731
4732                 hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), 0, NULL, 0, &value, NULL);
4733                 EXPECT_HR(hr, E_INVALIDARG);
4734             }
4735             else
4736             {
4737                 hr = ISAXAttributes_getValueFromQName(saxattr, NULL, 0, NULL, NULL);
4738                 EXPECT_HR(hr, E_POINTER);
4739
4740                 hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), 0, NULL, NULL);
4741                 EXPECT_HR(hr, E_POINTER);
4742
4743                 hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), 0, &value, NULL);
4744                 EXPECT_HR(hr, E_POINTER);
4745
4746                 /* versions 4 and 6 crash */
4747                 hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), strlen(table->qname), NULL, NULL);
4748                 EXPECT_HR(hr, E_POINTER);
4749
4750                 hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), strlen(table->qname), NULL, &len);
4751                 EXPECT_HR(hr, E_POINTER);
4752
4753                 hr = ISAXAttributes_getValueFromName(saxattr, NULL, 0, NULL, 0, NULL, NULL);
4754                 EXPECT_HR(hr, E_POINTER);
4755
4756                 hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), 0, NULL, 0, NULL, NULL);
4757                 EXPECT_HR(hr, E_POINTER);
4758
4759                 hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), 0, NULL, 0, &value, NULL);
4760                 EXPECT_HR(hr, E_POINTER);
4761
4762                 hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), 0, _bstr_(table->local), 0, &value, NULL);
4763                 EXPECT_HR(hr, E_POINTER);
4764
4765                 hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), 0, _bstr_(table->local), 0, NULL, &len);
4766                 EXPECT_HR(hr, E_POINTER);
4767
4768                 hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), strlen(table->uri), _bstr_(table->local),
4769                     strlen(table->local), NULL, NULL);
4770                 EXPECT_HR(hr, E_POINTER);
4771             }
4772
4773             hr = ISAXAttributes_getValueFromQName(saxattr, _bstr_(table->qname), strlen(table->qname), &value, &len);
4774             EXPECT_HR(hr, S_OK);
4775             ok(!lstrcmpW(_bstr_(table->value), value), "%d: got %s, expected %s\n", i, wine_dbgstr_w(value),
4776                 table->value);
4777             ok(lstrlenW(value) == len, "%d: got wrong value length %d\n", i, len);
4778
4779             if (table->uri) {
4780                 hr = ISAXAttributes_getValueFromName(saxattr, _bstr_(table->uri), strlen(table->uri),
4781                     _bstr_(table->local), strlen(table->local), &value, &len);
4782                 EXPECT_HR(hr, S_OK);
4783                 ok(!lstrcmpW(_bstr_(table->value), value), "%d: got %s, expected %s\n", i, wine_dbgstr_w(value),
4784                     table->value);
4785                 ok(lstrlenW(value) == len, "%d: got wrong value length %d\n", i, len);
4786             }
4787         }
4788
4789         len = -1;
4790         hr = ISAXAttributes_getLength(saxattr, &len);
4791         EXPECT_HR(hr, S_OK);
4792         if (table->hr == S_OK)
4793             ok(len == 1, "%d: got %d length, expected 1\n", i, len);
4794         else
4795             ok(len == 0, "%d: got %d length, expected 0\n", i, len);
4796
4797         ISAXAttributes_Release(saxattr);
4798         IMXAttributes_Release(mxattr);
4799
4800         table++;
4801         i++;
4802     }
4803
4804     free_bstrs();
4805 }
4806
4807 static void test_mxattr_clear(void)
4808 {
4809     ISAXAttributes *saxattr;
4810     IMXAttributes *mxattr;
4811     const WCHAR *ptr;
4812     HRESULT hr;
4813     int len;
4814
4815     hr = CoCreateInstance(&CLSID_SAXAttributes, NULL, CLSCTX_INPROC_SERVER,
4816         &IID_IMXAttributes, (void**)&mxattr);
4817     EXPECT_HR(hr, S_OK);
4818
4819     hr = IMXAttributes_QueryInterface(mxattr, &IID_ISAXAttributes, (void**)&saxattr);
4820     EXPECT_HR(hr, S_OK);
4821
4822     hr = ISAXAttributes_getQName(saxattr, 0, NULL, NULL);
4823     EXPECT_HR(hr, E_INVALIDARG);
4824
4825     hr = ISAXAttributes_getQName(saxattr, 0, &ptr, &len);
4826     EXPECT_HR(hr, E_INVALIDARG);
4827
4828     hr = IMXAttributes_clear(mxattr);
4829     EXPECT_HR(hr, S_OK);
4830
4831     hr = IMXAttributes_addAttribute(mxattr, _bstr_("uri"), _bstr_("local"),
4832         _bstr_("qname"), _bstr_("type"), _bstr_("value"));
4833     EXPECT_HR(hr, S_OK);
4834
4835     len = -1;
4836     hr = ISAXAttributes_getLength(saxattr, &len);
4837     EXPECT_HR(hr, S_OK);
4838     ok(len == 1, "got %d\n", len);
4839
4840     len = -1;
4841     hr = ISAXAttributes_getQName(saxattr, 0, NULL, &len);
4842     EXPECT_HR(hr, E_POINTER);
4843     ok(len == -1, "got %d\n", len);
4844
4845     ptr = (void*)0xdeadbeef;
4846     hr = ISAXAttributes_getQName(saxattr, 0, &ptr, NULL);
4847     EXPECT_HR(hr, E_POINTER);
4848     ok(ptr == (void*)0xdeadbeef, "got %p\n", ptr);
4849
4850     len = 0;
4851     hr = ISAXAttributes_getQName(saxattr, 0, &ptr, &len);
4852     EXPECT_HR(hr, S_OK);
4853     ok(len == 5, "got %d\n", len);
4854     ok(!lstrcmpW(ptr, _bstr_("qname")), "got %s\n", wine_dbgstr_w(ptr));
4855
4856     hr = IMXAttributes_clear(mxattr);
4857     EXPECT_HR(hr, S_OK);
4858
4859     len = -1;
4860     hr = ISAXAttributes_getLength(saxattr, &len);
4861     EXPECT_HR(hr, S_OK);
4862     ok(len == 0, "got %d\n", len);
4863
4864     len = -1;
4865     ptr = (void*)0xdeadbeef;
4866     hr = ISAXAttributes_getQName(saxattr, 0, &ptr, &len);
4867     EXPECT_HR(hr, E_INVALIDARG);
4868     ok(len == -1, "got %d\n", len);
4869     ok(ptr == (void*)0xdeadbeef, "got %p\n", ptr);
4870
4871     IMXAttributes_Release(mxattr);
4872     ISAXAttributes_Release(saxattr);
4873     free_bstrs();
4874 }
4875
4876 static void test_mxattr_dispex(void)
4877 {
4878     IMXAttributes *mxattr;
4879     IDispatchEx *dispex;
4880     IUnknown *unk;
4881     HRESULT hr;
4882
4883     hr = CoCreateInstance(&CLSID_SAXAttributes, NULL, CLSCTX_INPROC_SERVER,
4884             &IID_IMXAttributes, (void**)&mxattr);
4885     EXPECT_HR(hr, S_OK);
4886
4887     hr = IMXAttributes_QueryInterface(mxattr, &IID_IDispatchEx, (void**)&dispex);
4888     EXPECT_HR(hr, S_OK);
4889     hr = IDispatchEx_QueryInterface(dispex, &IID_IUnknown, (void**)&unk);
4890     test_obj_dispex(unk);
4891     IUnknown_Release(unk);
4892     IDispatchEx_Release(dispex);
4893
4894     IMXAttributes_Release(mxattr);
4895 }
4896
4897 static void test_mxattr_qi(void)
4898 {
4899     IVBSAXAttributes *vbsaxattr, *vbsaxattr2;
4900     ISAXAttributes *saxattr;
4901     IMXAttributes *mxattr;
4902     HRESULT hr;
4903
4904     hr = CoCreateInstance(&CLSID_SAXAttributes, NULL, CLSCTX_INPROC_SERVER,
4905             &IID_IMXAttributes, (void**)&mxattr);
4906     EXPECT_HR(hr, S_OK);
4907
4908     EXPECT_REF(mxattr, 1);
4909     hr = IMXAttributes_QueryInterface(mxattr, &IID_ISAXAttributes, (void**)&saxattr);
4910     EXPECT_HR(hr, S_OK);
4911
4912     EXPECT_REF(mxattr, 2);
4913     EXPECT_REF(saxattr, 2);
4914
4915     hr = IMXAttributes_QueryInterface(mxattr, &IID_IVBSAXAttributes, (void**)&vbsaxattr);
4916     EXPECT_HR(hr, S_OK);
4917
4918     EXPECT_REF(vbsaxattr, 3);
4919     EXPECT_REF(mxattr, 3);
4920     EXPECT_REF(saxattr, 3);
4921
4922     hr = ISAXAttributes_QueryInterface(saxattr, &IID_IVBSAXAttributes, (void**)&vbsaxattr2);
4923     EXPECT_HR(hr, S_OK);
4924
4925     EXPECT_REF(vbsaxattr, 4);
4926     EXPECT_REF(mxattr, 4);
4927     EXPECT_REF(saxattr, 4);
4928
4929     IMXAttributes_Release(mxattr);
4930     ISAXAttributes_Release(saxattr);
4931     IVBSAXAttributes_Release(vbsaxattr);
4932     IVBSAXAttributes_Release(vbsaxattr2);
4933 }
4934
4935 static struct msxmlsupported_data_t saxattr_support_data[] =
4936 {
4937     { &CLSID_SAXAttributes,   "SAXAttributes"   },
4938     { &CLSID_SAXAttributes30, "SAXAttributes30" },
4939     { &CLSID_SAXAttributes40, "SAXAttributes40" },
4940     { &CLSID_SAXAttributes60, "SAXAttributes60" },
4941     { NULL }
4942 };
4943
4944 static void test_mxattr_localname(void)
4945 {
4946     static const WCHAR localname1W[] = {'l','o','c','a','l','n','a','m','e','1',0};
4947     static const WCHAR localnameW[] = {'l','o','c','a','l','n','a','m','e',0};
4948     static const WCHAR uri1W[] = {'u','r','i','1',0};
4949     static const WCHAR uriW[] = {'u','r','i',0};
4950
4951     const struct msxmlsupported_data_t *table = saxattr_support_data;
4952
4953     while (table->clsid)
4954     {
4955         ISAXAttributes *saxattr;
4956         IMXAttributes *mxattr;
4957         HRESULT hr;
4958         int index;
4959
4960         if (!is_clsid_supported(table->clsid, mxattributes_support_data))
4961         {
4962             table++;
4963             continue;
4964         }
4965
4966         hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
4967             &IID_IMXAttributes, (void**)&mxattr);
4968         EXPECT_HR(hr, S_OK);
4969
4970         hr = IMXAttributes_QueryInterface(mxattr, &IID_ISAXAttributes, (void**)&saxattr);
4971         EXPECT_HR(hr, S_OK);
4972
4973         hr = ISAXAttributes_getIndexFromName(saxattr, NULL, 0, NULL, 0, &index);
4974         EXPECT_HR(hr, E_INVALIDARG);
4975
4976         /* add some ambiguos attribute names */
4977         hr = IMXAttributes_addAttribute(mxattr, _bstr_("uri"), _bstr_("localname"),
4978             _bstr_("a:localname"), _bstr_(""), _bstr_("value"));
4979         EXPECT_HR(hr, S_OK);
4980         hr = IMXAttributes_addAttribute(mxattr, _bstr_("uri"), _bstr_("localname"),
4981             _bstr_("b:localname"), _bstr_(""), _bstr_("value"));
4982         EXPECT_HR(hr, S_OK);
4983
4984         index = -1;
4985         hr = ISAXAttributes_getIndexFromName(saxattr, uriW, lstrlenW(uriW), localnameW, lstrlenW(localnameW), &index);
4986         EXPECT_HR(hr, S_OK);
4987         ok(index == 0, "%s: got index %d\n", table->name, index);
4988
4989         index = -1;
4990         hr = ISAXAttributes_getIndexFromName(saxattr, uri1W, lstrlenW(uri1W), localnameW, lstrlenW(localnameW), &index);
4991         EXPECT_HR(hr, E_INVALIDARG);
4992         ok(index == -1, "%s: got index %d\n", table->name, index);
4993
4994         index = -1;
4995         hr = ISAXAttributes_getIndexFromName(saxattr, uriW, lstrlenW(uriW), localname1W, lstrlenW(localname1W), &index);
4996         EXPECT_HR(hr, E_INVALIDARG);
4997         ok(index == -1, "%s: got index %d\n", table->name, index);
4998
4999         if (IsEqualGUID(table->clsid, &CLSID_SAXAttributes) ||
5000             IsEqualGUID(table->clsid, &CLSID_SAXAttributes30))
5001         {
5002             hr = ISAXAttributes_getIndexFromName(saxattr, NULL, 0, NULL, 0, NULL);
5003             EXPECT_HR(hr, E_POINTER);
5004
5005             hr = ISAXAttributes_getIndexFromName(saxattr, uriW, lstrlenW(uriW), localname1W, lstrlenW(localname1W), NULL);
5006             EXPECT_HR(hr, E_POINTER);
5007         }
5008         else
5009         {
5010             hr = ISAXAttributes_getIndexFromName(saxattr, NULL, 0, NULL, 0, NULL);
5011             EXPECT_HR(hr, E_INVALIDARG);
5012
5013             hr = ISAXAttributes_getIndexFromName(saxattr, uriW, lstrlenW(uriW), localname1W, lstrlenW(localname1W), NULL);
5014             EXPECT_HR(hr, E_INVALIDARG);
5015         }
5016
5017         hr = ISAXAttributes_getIndexFromName(saxattr, uriW, lstrlenW(uriW), NULL, 0, &index);
5018         EXPECT_HR(hr, E_INVALIDARG);
5019
5020         hr = ISAXAttributes_getIndexFromName(saxattr, NULL, 0, localname1W, lstrlenW(localname1W), &index);
5021         EXPECT_HR(hr, E_INVALIDARG);
5022
5023         table++;
5024
5025         ISAXAttributes_Release(saxattr);
5026         IMXAttributes_Release(mxattr);
5027     }
5028 }
5029
5030 START_TEST(saxreader)
5031 {
5032     ISAXXMLReader *reader;
5033     HRESULT hr;
5034
5035     hr = CoInitialize(NULL);
5036     ok(hr == S_OK, "failed to init com\n");
5037
5038     hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
5039             &IID_ISAXXMLReader, (void**)&reader);
5040
5041     if(FAILED(hr))
5042     {
5043         skip("Failed to create SAXXMLReader instance\n");
5044         CoUninitialize();
5045         return;
5046     }
5047     ISAXXMLReader_Release(reader);
5048
5049     init_call_sequences(sequences, NUM_CALL_SEQUENCES);
5050
5051     get_class_support_data(reader_support_data, &IID_ISAXXMLReader);
5052
5053     test_saxreader();
5054     test_saxreader_properties();
5055     test_saxreader_features();
5056     test_saxreader_encoding();
5057     test_dispex();
5058
5059     /* MXXMLWriter tests */
5060     get_class_support_data(mxwriter_support_data, &IID_IMXWriter);
5061     if (is_clsid_supported(&CLSID_MXXMLWriter, mxwriter_support_data))
5062     {
5063         test_mxwriter_handlers();
5064         test_mxwriter_startenddocument();
5065         test_mxwriter_startendelement();
5066         test_mxwriter_characters();
5067         test_mxwriter_comment();
5068         test_mxwriter_cdata();
5069         test_mxwriter_pi();
5070         test_mxwriter_ignorablespaces();
5071         test_mxwriter_dtd();
5072         test_mxwriter_properties();
5073         test_mxwriter_flush();
5074         test_mxwriter_stream();
5075         test_mxwriter_encoding();
5076         test_mxwriter_dispex();
5077     }
5078     else
5079         win_skip("MXXMLWriter not supported\n");
5080
5081     /* SAXAttributes tests */
5082     get_class_support_data(mxattributes_support_data, &IID_IMXAttributes);
5083     if (is_clsid_supported(&CLSID_SAXAttributes, mxattributes_support_data))
5084     {
5085         test_mxattr_qi();
5086         test_mxattr_addAttribute();
5087         test_mxattr_clear();
5088         test_mxattr_localname();
5089         test_mxattr_dispex();
5090     }
5091     else
5092         skip("SAXAttributes not supported\n");
5093
5094     CoUninitialize();
5095 }