END_TEST
START_TEST(test_osgetattributecontent)
{
char xml_file_name[256];
create_xml_file("<root attr=\"value\" attr2=\"value1\"></root>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
const char *xml_path1[] = { "root", NULL };
const char *xml_path2[] = { NULL };
char *content1, *content2, *content3, *content4;
ck_assert_str_eq(content1 = OS_GetAttributeContent(&xml, xml_path1, "attr"), "value");
ck_assert_str_eq(content2 = OS_GetAttributeContent(&xml, xml_path1, "attr2"), "value1");
ck_assert_str_eq(content3 = OS_GetAttributeContent(&xml, xml_path1, "attr3"), "");
ck_assert_str_eq(content4 = OS_GetAttributeContent(&xml, xml_path1, NULL), "");
ck_assert_ptr_eq(OS_GetAttributeContent(&xml, xml_path2, NULL), NULL);
free(content1);
free(content2);
free(content3);
free(content4);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_oswritexml_failures)
{
char xml_in_file_name[256];
create_xml_file("<root><child>test</child></root>", xml_in_file_name, 256);
char xml_out_file_name[256];
create_xml_file("", xml_out_file_name, 256);
const char *xml_path[] = { "root", "child", NULL };
ck_assert_int_eq(OS_WriteXML("invalid", xml_out_file_name, xml_path, "test", "test_new"), XMLW_NOIN);
ck_assert_int_eq(OS_WriteXML(xml_in_file_name, "??invalid<<!!\"\"//\\\\", xml_path, "test", "test_new"), XMLW_NOOUT);
unlink(xml_in_file_name);
unlink(xml_out_file_name);
}
END_TEST
START_TEST(test_osgetelements)
{
char xml_file_name[256];
create_xml_file("<root><child1/><child2/></root>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
const char *xml_path[] = { "root", NULL };
char **content1, **content2;
ck_assert_ptr_ne(content1 = OS_GetElements(&xml, xml_path), NULL);
ck_assert_str_eq(content1[0], "child1");
ck_assert_str_eq(content1[1], "child2");
ck_assert_ptr_eq(content1[2], NULL);
ck_assert_ptr_ne(content2 = OS_GetElements(&xml, NULL), NULL);
ck_assert_str_eq(content2[0], "root");
ck_assert_ptr_eq(content2[1], NULL);
const char *xml_path2[] = { NULL };
ck_assert_ptr_eq(OS_GetElements(&xml, xml_path2), NULL);
int i = 0;
while (content1[i]) {
free(content1[i++]);
}
free(content1);
i = 0;
while (content2[i]) {
free(content2[i++]);
}
free(content2);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
//TODO
/*START_TEST(test_unknownvariable)
{
char xml_file_name[256];
create_xml_file("<root>$var</root>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_int_ne(OS_ApplyVariables(&xml), 0);
ck_assert_str_eq(xml.err, "XML_ERR: Unknown variable: var");
ck_assert_int_eq(xml.err_line, 0);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST*/
START_TEST(test_oselementsexists)
{
char xml_file_name[256];
create_xml_file("<root></root><root1/><root/>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
ck_assert_int_eq(OS_RootElementExist(&xml, "root"), 2);
ck_assert_int_eq(OS_RootElementExist(&xml, "root1"), 1);
ck_assert_int_eq(OS_RootElementExist(&xml, "root2"), 0);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
static void assert_ox_xml_write_eq(const char *xml_str_old, const char *xml_str_new, const char **xml_path, const char *oldval, const char *newval)
{
char xml_in_file_name[256];
create_xml_file(xml_str_old, xml_in_file_name, 256);
char xml_out_file_name[256];
create_xml_file("", xml_out_file_name, 256);
ck_assert_int_eq(OS_WriteXML(xml_in_file_name, xml_out_file_name, xml_path, oldval, newval), 0);
OS_XML xml;
ck_assert_int_eq(OS_ReadXML(xml_out_file_name, &xml), 0);
ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
assert_os_xml_eq_str(&xml, xml_str_new);
OS_ClearXML(&xml);
unlink(xml_in_file_name);
unlink(xml_out_file_name);
}
END_TEST
START_TEST(test_invalidattributeclosing2)
{
char xml_file_name[256];
create_xml_file("<root attr='test'test/>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: Bad attribute closing for 'attr'='test'.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_invalidattributestart)
{
char xml_file_name[256];
create_xml_file("<root attr= test\"test\"/>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: Attribute 'attr' not followed by a \" or '.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_unclosedattribute)
{
char xml_file_name[256];
create_xml_file("<root attr=\"attribute></root>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: Attribute 'attr' not closed.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_nodenotopened)
{
char xml_file_name[256];
create_xml_file("</root>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: Element not opened.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_unclosedcomment)
{
char xml_file_name[256];
create_xml_file("<!-- comment", xml_file_name, 256);
OS_XML xml;
ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: Comment not closed.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_unclosednode)
{
char xml_file_name[256];
create_xml_file("<root>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: End of file and some elements were not closed.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_infiniteattribute3)
{
char xml_file_name[256];
create_xml_file("<root attr='", xml_file_name, 256);
OS_XML xml;
ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: End of file while reading an attribute.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_duplicateattribute)
{
char xml_file_name[256];
create_xml_file("<root attr='test' attr2='test' attr='test123'></root>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: Attribute 'attr' already defined.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_noattributevalue2)
{
char xml_file_name[256];
create_xml_file("<root attr attr2='test'></root>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: Attribute 'attr' has no value.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_invalidvariablename)
{
char xml_file_name[256];
create_xml_file("<var test=\"test\"></var>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_int_ne(OS_ApplyVariables(&xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: Only \"name\" is allowed as an attribute for a variable.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_unknownvariable1)
{
char xml_file_name[256];
create_xml_file("<var name=\"test\">content</var><root>$var</root>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_int_ne(OS_ApplyVariables(&xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: Unknown variable: 'var'.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_linecounter)
{
char xml_file_name[256];
create_xml_file("<root1/>\n<root2/>\n<root3/>" , xml_file_name, 256);
OS_XML xml;
XML_NODE node;
ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
ck_assert_ptr_ne(node = OS_GetElementsbyNode(&xml, NULL), NULL);
ck_assert_int_eq(xml.ln[0], 1);
ck_assert_int_eq(xml.ln[1], 2);
ck_assert_int_eq(xml.ln[2], 3);
OS_ClearNode(node);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_stringoverflow4)
{
char xml_file_name[256];
char overflow_string[XML_MAXSIZE + 10];
memset(overflow_string, 'c', XML_MAXSIZE + 9);
overflow_string[XML_MAXSIZE + 9] = '\0';
char xml_string[2 * XML_MAXSIZE];
snprintf(xml_string, 2 * XML_MAXSIZE - 1, "<test test=\"%s\">test</test>", overflow_string);
create_xml_file(xml_string, xml_file_name, 256);
OS_XML xml;
ck_assert_int_ne(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: Overflow attempt at attribute 'test'.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_invalidvariable2)
{
char xml_file_name[256];
char overflow_string[XML_VARIABLE_MAXSIZE + 10];
memset(overflow_string, 'c', XML_VARIABLE_MAXSIZE + 9);
overflow_string[XML_VARIABLE_MAXSIZE + 9] = '\0';
char xml_string[3 * XML_VARIABLE_MAXSIZE];
snprintf(xml_string, 3 * XML_VARIABLE_MAXSIZE - 1, "<var name=\"%s\">test</var><test>$%s</test>", overflow_string, overflow_string);
create_xml_file(xml_string, xml_file_name, 256);
OS_XML xml;
ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_int_ne(OS_ApplyVariables(&xml), 0);
ck_assert_str_eq(xml.err, "XMLERR: Invalid variable name size.");
ck_assert_int_eq(xml.err_line, 1);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_osgetonecontentforelement)
{
char xml_file_name[256];
create_xml_file("<root><child>test</child><child>test2</child><child2>test</child2></root>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
const char *xml_path1[] = { "root", "child", NULL };
const char *xml_path2[] = { "root", "child2", NULL };
const char *xml_path3[] = { "root", "child3", NULL };
char *content1, *content2;
ck_assert_str_eq(content1 = OS_GetOneContentforElement(&xml, xml_path1), "test");
ck_assert_str_eq(content2 = OS_GetOneContentforElement(&xml, xml_path2), "test");
ck_assert_ptr_eq(OS_GetOneContentforElement(&xml, xml_path3), NULL);
free(content1);
free(content2);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_osgetelementcontent)
{
char xml_file_name[256];
create_xml_file("<root>value</root>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
const char *xml_path[] = { "root", NULL };
char **content;
ck_assert_ptr_ne(content = OS_GetElementContent(&xml, xml_path), NULL);
ck_assert_str_eq(content[0], "value");
ck_assert_ptr_eq(content[1], NULL);
int i = 0;
while (content[i]) {
free(content[i++]);
}
free(content);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
END_TEST
START_TEST(test_osgetattributes)
{
char xml_file_name[256];
create_xml_file("<root attr1=\"1\" attr2=\"2\"></root>", xml_file_name, 256);
OS_XML xml;
ck_assert_int_eq(OS_ReadXML(xml_file_name, &xml), 0);
ck_assert_int_eq(OS_ApplyVariables(&xml), 0);
const char *xml_path[] = { "root", NULL };
char **content;
ck_assert_ptr_ne(content = OS_GetAttributes(&xml, xml_path), NULL);
ck_assert_str_eq(content[0], "attr1");
ck_assert_str_eq(content[1], "attr2");
ck_assert_ptr_eq(content[2], NULL);
int i = 0;
while (content[i]) {
free(content[i++]);
}
free(content);
OS_ClearXML(&xml);
unlink(xml_file_name);
}
static void test_xmlelem_collection(void)
{
HRESULT hr;
IUnknown *unk = NULL;
IXMLDocument *doc = NULL;
IXMLElement *element = NULL, *child;
IXMLElementCollection *collection = NULL;
IEnumVARIANT *enumVar = NULL;
WCHAR path[MAX_PATH];
long length, type;
ULONG num_vars;
VARIANT var, vIndex, vName;
BSTR url, str;
static const WCHAR szBankXML[] = {'b','a','n','k','.','x','m','l',0};
static const WCHAR szNumber[] = {'N','U','M','B','E','R',0};
static const WCHAR szName[] = {'N','A','M','E',0};
hr = CoCreateInstance(&CLSID_XMLDocument, NULL, CLSCTX_INPROC_SERVER,
&IID_IXMLDocument, (LPVOID*)&doc);
if (FAILED(hr))
{
skip("Failed to create XMLDocument instance\n");
return;
}
create_xml_file("bank.xml");
GetFullPathNameW(szBankXML, MAX_PATH, path, NULL);
url = SysAllocString(path);
hr = IXMLDocument_put_URL(doc, url);
/* Win98 returns ERROR_URL_NOT_FOUND */
ok(hr == S_OK || hr == ERROR_URL_NOT_FOUND, "Expected S_OK, got 0x%08x\n", hr);
SysFreeString(url);
if(hr != S_OK)
goto cleanup;
hr = IXMLDocument_get_root(doc, &element);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(element != NULL, "Expected non-NULL element\n");
hr = IXMLElement_get_children(element, &collection);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(collection != NULL, "Expected non-NULL collection\n");
hr = IXMLElementCollection_get_length(collection, NULL);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %d\n", hr);
hr = IXMLElementCollection_get_length(collection, &length);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(length == 2, "Expected 2, got %ld\n", length);
/* IXMLElementCollection:put_length does nothing */
hr = IXMLElementCollection_put_length(collection, -1);
ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
hr = IXMLElementCollection_put_length(collection, 0);
ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
hr = IXMLElementCollection_put_length(collection, 1);
ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
hr = IXMLElementCollection_put_length(collection, 2);
ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
hr = IXMLElementCollection_put_length(collection, 3);
ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
hr = IXMLElementCollection_put_length(collection, 50);
ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
/* make sure the length hasn't changed */
hr = IXMLElementCollection_get_length(collection, &length);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(length == 2, "Expected 2, got %ld\n", length);
/* IXMLElementCollection implements IEnumVARIANT */
hr = IXMLElementCollection_QueryInterface(collection, &IID_IEnumVARIANT, (LPVOID *)&enumVar);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(enumVar != NULL, "Expected non-NULL enumVar\n");
IEnumVARIANT_Release(enumVar);
hr = IXMLElementCollection_get__newEnum(collection, &unk);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(unk != NULL, "Expected non-NULL unk\n");
hr = IUnknown_QueryInterface(unk, &IID_IEnumVARIANT, (LPVOID *)&enumVar);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(enumVar != NULL, "Expected non-NULL enumVar\n");
IUnknown_Release(unk);
/* <Number>1234</Number> */
hr = IEnumVARIANT_Next(enumVar, 1, &var, &num_vars);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(V_VT(&var) == VT_DISPATCH, "Expected VT_DISPATCH, got %d\n", V_VT(&var));
ok(num_vars == 1, "Expected 1, got %d\n", 1);
hr = IUnknown_QueryInterface(V_DISPATCH(&var), &IID_IXMLElement, (LPVOID *)&child);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(child != NULL, "Expected non-NULL child\n");
VariantClear(&var);
hr = IXMLElement_get_type(child, &type);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %ld\n", type);
hr = IXMLElement_get_tagName(child, &str);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(!lstrcmpW(str, szNumber), "Expected NUMBER\n");
SysFreeString(str);
IXMLElement_Release(child);
/* <Name>Captain Ahab</Name> */
hr = IEnumVARIANT_Next(enumVar, 1, &var, &num_vars);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(V_VT(&var) == VT_DISPATCH, "Expected VT_DISPATCH, got %d\n", V_VT(&var));
ok(num_vars == 1, "Expected 1, got %d\n", 1);
hr = IUnknown_QueryInterface(V_DISPATCH(&var), &IID_IXMLElement, (LPVOID *)&child);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(child != NULL, "Expected non-NULL child\n");
VariantClear(&var);
hr = IXMLElement_get_type(child, &type);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %ld\n", type);
hr = IXMLElement_get_tagName(child, &str);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(!lstrcmpW(str, szName), "Expected NAME\n");
SysFreeString(str);
IXMLElement_Release(child);
/* <Number>1234</Number> */
V_VT(&vIndex) = VT_I4;
V_I4(&vIndex) = 0;
V_VT(&vName) = VT_ERROR;
V_ERROR(&vName) = DISP_E_PARAMNOTFOUND;
hr = IXMLElementCollection_item(collection, vIndex, vName, (IDispatch **)&child);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(child != NULL, "Expected non-NULL child\n");
hr = IXMLElement_get_type(child, &type);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %ld\n", type);
hr = IXMLElement_get_tagName(child, &str);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(!lstrcmpW(str, szNumber), "Expected NUMBER\n");
SysFreeString(str);
IXMLElement_Release(child);
/* <Name>Captain Ahab</Name> */
V_VT(&vIndex) = VT_I4;
V_I4(&vIndex) = 1;
V_VT(&vName) = VT_ERROR;
V_ERROR(&vName) = DISP_E_PARAMNOTFOUND;
hr = IXMLElementCollection_item(collection, vIndex, vName, (IDispatch **)&child);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(child != NULL, "Expected non-NULL child\n");
hr = IXMLElement_get_type(child, &type);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %ld\n", type);
hr = IXMLElement_get_tagName(child, &str);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(!lstrcmpW(str, szName), "Expected NAME\n");
SysFreeString(str);
IXMLElement_Release(child);
V_I4(&vIndex) = 100;
hr = IXMLElementCollection_item(collection, vIndex, vName, (IDispatch **)&child);
ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
ok(child == NULL, "Expected NULL child\n");
V_I4(&vIndex) = -1;
child = (IXMLElement *)0xdeadbeef;
hr = IXMLElementCollection_item(collection, vIndex, vName, (IDispatch **)&child);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %d\n", hr);
ok(child == NULL, "Expected NULL child\n");
IEnumVARIANT_Release(enumVar);
IXMLElement_Release(element);
IXMLElementCollection_Release(collection);
cleanup:
IXMLDocument_Release(doc);
DeleteFileA("bank.xml");
}
static void test_xmldoc(void)
{
IXMLElement *element = NULL, *child = NULL, *value = NULL;
IXMLElementCollection *collection = NULL, *inner = NULL;
IPersistStreamInit *psi = NULL;
IXMLDocument *doc = NULL;
IStream *stream = NULL;
VARIANT vIndex, vName;
LONG type, num_child;
CHAR path[MAX_PATH];
IDispatch *disp;
ITypeInfo *ti;
HRESULT hr;
BSTR name;
static const WCHAR szBankAccount[] = {'B','A','N','K','A','C','C','O','U','N','T',0};
static const WCHAR szNumber[] = {'N','U','M','B','E','R',0};
static const WCHAR szNumVal[] = {'1','2','3','4',0};
static const WCHAR szName[] = {'N','A','M','E',0};
static const WCHAR szNameVal[] = {'C','a','p','t','a','i','n',' ','A','h','a','b',0};
static const WCHAR szVersion[] = {'1','.','0',0};
static const WCHAR rootW[] = {'r','o','o','t',0};
hr = CoCreateInstance(&CLSID_XMLDocument, NULL, CLSCTX_INPROC_SERVER,
&IID_IXMLDocument, (void**)&doc);
EXPECT_HR(hr, S_OK);
/* IDispatch */
hr = IXMLDocument_QueryInterface(doc, &IID_IDispatch, (void**)&disp);
EXPECT_HR(hr, S_OK);
/* just to make sure we're on right type data */
hr = IDispatch_GetTypeInfo(disp, 0, 0, &ti);
EXPECT_HR(hr, S_OK);
name = NULL;
hr = ITypeInfo_GetDocumentation(ti, DISPID_XMLDOCUMENT_ROOT, &name, NULL, NULL, NULL);
EXPECT_HR(hr, S_OK);
ok(!lstrcmpW(name, rootW), "got name %s\n", wine_dbgstr_w(name));
SysFreeString(name);
ITypeInfo_Release(ti);
IDispatch_Release(disp);
hr = IXMLDocument_QueryInterface(doc, &IID_IXMLDOMDocument, (void**)&disp);
EXPECT_HR(hr, E_NOINTERFACE);
create_xml_file("bank.xml");
GetFullPathNameA("bank.xml", MAX_PATH, path, NULL);
create_stream_on_file(&stream, path);
hr = IXMLDocument_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&psi);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(psi != NULL, "Expected non-NULL psi\n");
hr = IXMLDocument_get_root(doc, &element);
ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
ok(element == NULL, "Expected NULL element\n");
hr = IPersistStreamInit_Load(psi, stream);
ok(hr == S_OK || hr == XML_E_INVALIDATROOTLEVEL, "Expected S_OK, got %08x\n", hr);
if(hr == XML_E_INVALIDATROOTLEVEL)
goto cleanup;
ok(stream != NULL, "Expected non-NULL stream\n");
/* version field */
hr = IXMLDocument_get_version(doc, NULL);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
name = NULL;
hr = IXMLDocument_get_version(doc, &name);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(!lstrcmpW(name, szVersion), "Expected 1.0, got %s\n", wine_dbgstr_w(name));
SysFreeString(name);
/* doctype */
hr = IXMLDocument_get_doctype(doc, NULL);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
hr = IXMLDocument_get_doctype(doc, &name);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(!lstrcmpW(name, szBankAccount), "Expected BANKACCOUNT, got %s\n", wine_dbgstr_w(name));
SysFreeString(name);
hr = IXMLDocument_get_root(doc, &element);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(element != NULL, "Expected non-NULL element\n");
/* ::root() returns new instance each time */
hr = IXMLDocument_get_root(doc, &child);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(child != NULL, "Expected non-NULL element\n");
ok(child != element, "Expected new element instance\n");
IXMLElement_Release(child);
hr = IXMLElement_get_type(element, &type);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %d\n", type);
hr = IXMLElement_get_tagName(element, &name);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(!lstrcmpW(name, szBankAccount), "Expected BANKACCOUNT\n");
SysFreeString(name);
hr = IXMLElement_get_children(element, &collection);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(collection != NULL, "Expected non-NULL collection\n");
hr = IXMLElementCollection_get_length(collection, &num_child);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(num_child == 2, "Expected 2, got %d\n", num_child);
V_VT(&vIndex) = VT_I4;
V_I4(&vIndex) = 0;
V_VT(&vName) = VT_ERROR;
V_ERROR(&vName) = DISP_E_PARAMNOTFOUND;
hr = IXMLElementCollection_item(collection, vIndex, vName, (IDispatch **)&child);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(child != NULL, "Expected non-NULL child\n");
hr = IXMLElement_get_type(child, &type);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %d\n", type);
hr = IXMLElement_get_tagName(child, &name);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(!lstrcmpW(name, szNumber), "Expected NUMBER\n");
SysFreeString(name);
hr = IXMLElement_get_children(child, &inner);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(inner != NULL, "Expected non-NULL inner\n");
hr = IXMLElementCollection_get_length(inner, &num_child);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(num_child == 1, "Expected 1, got %d\n", num_child);
hr = IXMLElementCollection_item(inner, vIndex, vName, (IDispatch **)&value);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(value != NULL, "Expected non-NULL value\n");
hr = IXMLElement_get_type(value, &type);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(type == XMLELEMTYPE_TEXT, "Expected XMLELEMTYPE_TEXT, got %d\n", type);
hr = IXMLElement_get_text(value, &name);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(!lstrcmpW(name, szNumVal), "Expected '1234'\n");
SysFreeString(name);
IXMLElementCollection_Release(inner);
inner = (IXMLElementCollection *)0xdeadbeef;
hr = IXMLElement_get_children(value, &inner);
ok(hr == 1, "Expected 1, got %08x\n", hr);
ok(inner == NULL, "Expected NULL inner, got %p\n", inner);
IXMLElement_Release(value);
IXMLElement_Release(child);
value = NULL;
child = NULL;
V_I4(&vIndex) = 1;
hr = IXMLElementCollection_item(collection, vIndex, vName, (IDispatch **)&child);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(child != NULL, "Expected non-NULL child\n");
hr = IXMLElement_get_type(child, &type);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %d\n", type);
hr = IXMLElement_get_tagName(child, &name);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(!lstrcmpW(name, szName), "Expected NAME\n");
SysFreeString(name);
hr = IXMLElement_get_children(child, &inner);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(inner != NULL, "Expected non-NULL inner\n");
hr = IXMLElementCollection_get_length(inner, &num_child);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(num_child == 1, "Expected 1, got %d\n", num_child);
V_I4(&vIndex) = 0;
hr = IXMLElementCollection_item(inner, vIndex, vName, (IDispatch **)&value);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(value != NULL, "Expected non-NULL value\n");
hr = IXMLElement_get_type(value, &type);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(type == XMLELEMTYPE_TEXT, "Expected XMLELEMTYPE_TEXT, got %d\n", type);
hr = IXMLElement_get_text(value, &name);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(!lstrcmpW(name, szNameVal), "Expected 'Captain Ahab'\n");
SysFreeString(name);
IXMLElementCollection_Release(inner);
inner = (IXMLElementCollection *)0xdeadbeef;
hr = IXMLElement_get_children(value, &inner);
ok(hr == 1, "Expected 1, got %08x\n", hr);
ok(inner == NULL, "Expected NULL inner, got %p\n", inner);
IXMLElement_Release(value);
IXMLElement_Release(child);
IXMLElementCollection_Release(collection);
IXMLElement_Release(element);
cleanup:
IStream_Release(stream);
IPersistStreamInit_Release(psi);
IXMLDocument_Release(doc);
DeleteFileA("bank.xml");
}
static void test_createconfigstream(void)
{
IStream *stream = NULL;
WCHAR file[] = {'c', 'o', 'n', 'f', '.', 'x', 'm', 'l', 0};
WCHAR nonexistent[] = {'n', 'o', 'n', 'e', 'x', 'i', 's', 't', '.', 'x', 'm', 'l', 0};
WCHAR path[MAX_PATH];
HRESULT hr;
char buffer[256] = {0};
if (!pCreateConfigStream)
{
win_skip("CreateConfigStream not available\n");
return;
}
create_xml_file(file);
GetFullPathNameW(file, MAX_PATH, path, NULL);
hr = pCreateConfigStream(NULL, &stream);
ok(hr == E_FAIL ||
broken(hr == HRESULT_FROM_WIN32(ERROR_PROC_NOT_FOUND)) || /* some WinXP, Win2K3 and Win7 */
broken(hr == S_OK && !stream), /* some Win2K3 */
"CreateConfigStream returned %x\n", hr);
hr = pCreateConfigStream(path, NULL);
ok(hr == COR_E_NULLREFERENCE, "CreateConfigStream returned %x\n", hr);
hr = pCreateConfigStream(NULL, NULL);
ok(hr == COR_E_NULLREFERENCE, "CreateConfigStream returned %x\n", hr);
hr = pCreateConfigStream(nonexistent, &stream);
ok(hr == COR_E_FILENOTFOUND, "CreateConfigStream returned %x\n", hr);
ok(stream == NULL, "Expected stream to be NULL\n");
hr = pCreateConfigStream(path, &stream);
ok(hr == S_OK, "CreateConfigStream failed, hr=%x\n", hr);
ok(stream != NULL, "Expected non-NULL stream\n");
if (stream)
{
DWORD count;
LARGE_INTEGER pos;
ULARGE_INTEGER size;
IStream *stream2 = NULL;
ULONG ref;
hr = IStream_Read(stream, buffer, strlen(xmldata), &count);
ok(hr == S_OK, "IStream_Read failed, hr=%x\n", hr);
ok(count == strlen(xmldata), "wrong count: %u\n", count);
ok(!strcmp(buffer, xmldata), "Strings do not match\n");
hr = IStream_Read(stream, buffer, sizeof(buffer), &count);
ok(hr == S_OK, "IStream_Read failed, hr=%x\n", hr);
ok(!count, "wrong count: %u\n", count);
hr = IStream_Write(stream, xmldata, strlen(xmldata), &count);
ok(hr == E_FAIL, "IStream_Write returned hr=%x\n", hr);
pos.QuadPart = strlen(xmldata);
hr = IStream_Seek(stream, pos, STREAM_SEEK_SET, NULL);
ok(hr == E_NOTIMPL, "IStream_Seek returned hr=%x\n", hr);
size.QuadPart = strlen(xmldata);
hr = IStream_SetSize(stream, size);
ok(hr == E_NOTIMPL, "IStream_SetSize returned hr=%x\n", hr);
hr = IStream_Clone(stream, &stream2);
ok(hr == E_NOTIMPL, "IStream_Clone returned hr=%x\n", hr);
hr = IStream_Commit(stream, STGC_DEFAULT);
ok(hr == E_NOTIMPL, "IStream_Commit returned hr=%x\n", hr);
hr = IStream_Revert(stream);
ok(hr == E_NOTIMPL, "IStream_Revert returned hr=%x\n", hr);
ref = IStream_Release(stream);
ok(!ref, "IStream_Release returned %u\n", ref);
}
DeleteFileW(file);
}
static void test_persiststreaminit(void)
{
IXMLDocument *doc = NULL;
IXMLElement *element = NULL;
IPersistStreamInit *psi = NULL;
IStream *stream = NULL;
STATSTG stat;
HRESULT hr;
ULARGE_INTEGER size;
CHAR path[MAX_PATH];
CLSID id;
BSTR str;
static const WCHAR testW[] = {'t','e','s','t',0};
hr = CoCreateInstance(&CLSID_XMLDocument, NULL, CLSCTX_INPROC_SERVER,
&IID_IXMLDocument, (LPVOID*)&doc);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = IXMLDocument_QueryInterface(doc, &IID_IPersistStreamInit, (LPVOID *)&psi);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(psi != NULL, "Expected non-NULL psi\n");
/* null arguments */
hr = IPersistStreamInit_GetSizeMax(psi, NULL);
ok(hr == E_NOTIMPL, "Expected E_NOTIMPL, got %08x\n", hr);
hr = IPersistStreamInit_Load(psi, NULL);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
hr = IPersistStreamInit_Save(psi, NULL, FALSE);
todo_wine ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
hr = IPersistStreamInit_GetClassID(psi, NULL);
ok(hr == E_POINTER, "Expected E_POINTER, got %08x\n", hr);
hr = IPersistStreamInit_IsDirty(psi);
todo_wine ok(hr == S_FALSE, "Expected S_FALSE, got %08x\n", hr);
create_xml_file("bank.xml");
GetFullPathNameA("bank.xml", MAX_PATH, path, NULL);
create_stream_on_file(&stream, path);
/* GetSizeMax not implemented */
size.QuadPart = 0;
hr = IPersistStreamInit_GetSizeMax(psi, &size);
ok(hr == E_NOTIMPL, "Expected E_NOTIMPL, got %08x\n", hr);
ok(size.QuadPart == 0, "Expected 0\n");
hr = IPersistStreamInit_Load(psi, stream);
IStream_Release(stream);
ok(hr == S_OK || hr == XML_E_INVALIDATROOTLEVEL, "Expected S_OK, got %08x\n", hr);
if(hr == XML_E_INVALIDATROOTLEVEL)
goto cleanup;
hr = IPersistStreamInit_IsDirty(psi);
todo_wine ok(hr == S_FALSE, "Expected S_FALSE, got %08x\n", hr);
/* try to save document */
stream = NULL;
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = IPersistStreamInit_Save(psi, stream, FALSE);
todo_wine ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
stat.cbSize.QuadPart = 0;
hr = IStream_Stat(stream, &stat, 0);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
todo_wine ok(stat.cbSize.QuadPart > 0, "Expected >0\n");
IStream_Release(stream);
str = SysAllocString(testW);
hr = IXMLDocument_get_root(doc, &element);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = IXMLElement_put_text(element, str);
ok(hr == E_NOTIMPL, "Expected E_NOTIMPL, got %08x\n", hr);
IXMLElement_Release(element);
SysFreeString(str);
hr = IPersistStreamInit_IsDirty(psi);
todo_wine ok(hr == S_FALSE, "Expected S_FALSE, got %08x\n", hr);
create_stream_on_file(&stream, path);
hr = IPersistStreamInit_Load(psi, stream);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
IStream_Release(stream);
hr = IPersistStreamInit_IsDirty(psi);
todo_wine ok(hr == S_FALSE, "Expected S_FALSE, got %08x\n", hr);
/* reset internal stream */
hr = IPersistStreamInit_InitNew(psi);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = IPersistStreamInit_IsDirty(psi);
todo_wine ok(hr == S_FALSE, "Expected S_FALSE, got %08x\n", hr);
stream = NULL;
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = IPersistStreamInit_Save(psi, stream, FALSE);
todo_wine ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
stat.cbSize.QuadPart = 0;
hr = IStream_Stat(stream, &stat, 0);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
todo_wine ok(stat.cbSize.QuadPart > 0, "Expected >0\n");
IStream_Release(stream);
memset(&id, 0, sizeof(id));
hr = IPersistStreamInit_GetClassID(psi, &id);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(IsEqualCLSID(&id, &CLSID_XMLDocument), "Expected CLSID_XMLDocument\n");
cleanup:
IPersistStreamInit_Release(psi);
IXMLDocument_Release(doc);
DeleteFileA("bank.xml");
}
