External/pugixml
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

normalization with .gitattributes

Browse Source
This commit is contained in:
d-led 2012-10-02 19:34:47 +02:00
parent dc0922d024
commit 135ff898e2
11 changed files with 850 additions and 828 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
.gitattributes vendored Normal file
View File

@ -0,0 +1,22 @@
# Auto detect text files and perform LF normalization
* text=auto
# Custom for Visual Studio
*.cs diff=csharp
*.sln merge=union
*.csproj merge=union
*.vbproj merge=union
*.fsproj merge=union
*.dbproj merge=union
# Standard to msysgit
*.doc diff=astextplain
*.DOC diff=astextplain
*.docx diff=astextplain
*.DOCX diff=astextplain
*.dot diff=astextplain
*.DOT diff=astextplain
*.pdf diff=astextplain
*.PDF diff=astextplain
*.rtf diff=astextplain
*.RTF diff=astextplain

54
docs/samples/save_declaration.cpp
View File

@ -1,27 +1,27 @@
#include "pugixml.hpp" #include "pugixml.hpp"
#include <iostream> #include <iostream>
int main() int main()
{ {
//[code_save_declaration //[code_save_declaration
// get a test document // get a test document
pugi::xml_document doc; pugi::xml_document doc;
doc.load("<foo bar='baz'><call>hey</call></foo>"); doc.load("<foo bar='baz'><call>hey</call></foo>");
// add a custom declaration node // add a custom declaration node
pugi::xml_node decl = doc.prepend_child(pugi::node_declaration); pugi::xml_node decl = doc.prepend_child(pugi::node_declaration);
decl.append_attribute("version") = "1.0"; decl.append_attribute("version") = "1.0";
decl.append_attribute("encoding") = "UTF-8"; decl.append_attribute("encoding") = "UTF-8";
decl.append_attribute("standalone") = "no"; decl.append_attribute("standalone") = "no";
// <?xml version="1.0" encoding="UTF-8" standalone="no"?> // <?xml version="1.0" encoding="UTF-8" standalone="no"?>
// <foo bar="baz"> // <foo bar="baz">
// <call>hey</call> // <call>hey</call>
// </foo> // </foo>
doc.save(std::cout); doc.save(std::cout);
std::cout << std::endl; std::cout << std::endl;
//] //]
} }
// vim:et // vim:et

70
docs/samples/text.cpp
View File

@ -1,35 +1,35 @@
#include "pugixml.hpp" #include "pugixml.hpp"
#include <iostream> #include <iostream>
int main() int main()
{ {
pugi::xml_document doc; pugi::xml_document doc;
// get a test document // get a test document
doc.load("<project><name>test</name><version>1.1</version><public>yes</public></project>"); doc.load("<project><name>test</name><version>1.1</version><public>yes</public></project>");
pugi::xml_node project = doc.child("project"); pugi::xml_node project = doc.child("project");
//[code_text_access //[code_text_access
std::cout << "Project name: " << project.child("name").text().get() << std::endl; std::cout << "Project name: " << project.child("name").text().get() << std::endl;
std::cout << "Project version: " << project.child("version").text().as_double() << std::endl; std::cout << "Project version: " << project.child("version").text().as_double() << std::endl;
std::cout << "Project visibility: " << (project.child("public").text().as_bool(/* def= */ true) ? "public" : "private") << std::endl; std::cout << "Project visibility: " << (project.child("public").text().as_bool(/* def= */ true) ? "public" : "private") << std::endl;
std::cout << "Project description: " << project.child("description").text().get() << std::endl; std::cout << "Project description: " << project.child("description").text().get() << std::endl;
//] //]
std::cout << std::endl; std::cout << std::endl;
//[code_text_modify //[code_text_modify
// change project version // change project version
project.child("version").text() = 1.2; project.child("version").text() = 1.2;
// add description element and set the contents // add description element and set the contents
// note that we do not have to explicitly add the node_pcdata child // note that we do not have to explicitly add the node_pcdata child
project.append_child("description").text().set("a test project"); project.append_child("description").text().set("a test project");
//] //]
doc.save(std::cout); doc.save(std::cout);
} }
// vim:et // vim:et

64
docs/samples/traverse_rangefor.cpp
View File

@ -1,32 +1,32 @@
#include "pugixml.hpp" #include "pugixml.hpp"
#include <iostream> #include <iostream>
int main() int main()
{ {
pugi::xml_document doc; pugi::xml_document doc;
if (!doc.load_file("xgconsole.xml")) return -1; if (!doc.load_file("xgconsole.xml")) return -1;
pugi::xml_node tools = doc.child("Profile").child("Tools"); pugi::xml_node tools = doc.child("Profile").child("Tools");
//[code_traverse_rangefor //[code_traverse_rangefor
for (pugi::xml_node tool: tools.children("Tool")) for (pugi::xml_node tool: tools.children("Tool"))
{ {
std::cout << "Tool:"; std::cout << "Tool:";
for (pugi::xml_attribute attr: tool.attributes()) for (pugi::xml_attribute attr: tool.attributes())
{ {
std::cout << " " << attr.name() << "=" << attr.value(); std::cout << " " << attr.name() << "=" << attr.value();
} }
for (pugi::xml_node child: tool.children()) for (pugi::xml_node child: tool.children())
{ {
std::cout << ", child " << child.name(); std::cout << ", child " << child.name();
} }
std::cout << std::endl; std::cout << std::endl;
} }
//] //]
} }
// vim:et // vim:et

76
docs/samples/xpath_variables.cpp
View File

@ -1,38 +1,38 @@
#include "pugixml.hpp" #include "pugixml.hpp"
#include <iostream> #include <iostream>
#include <string> #include <string>
int main() int main()
{ {
pugi::xml_document doc; pugi::xml_document doc;
if (!doc.load_file("xgconsole.xml")) return -1; if (!doc.load_file("xgconsole.xml")) return -1;
//[code_xpath_variables //[code_xpath_variables
// Select nodes via compiled query // Select nodes via compiled query
pugi::xpath_variable_set vars; pugi::xpath_variable_set vars;
vars.add("remote", pugi::xpath_type_boolean); vars.add("remote", pugi::xpath_type_boolean);
pugi::xpath_query query_remote_tools("/Profile/Tools/Tool[@AllowRemote = string($remote)]", &vars); pugi::xpath_query query_remote_tools("/Profile/Tools/Tool[@AllowRemote = string($remote)]", &vars);
vars.set("remote", true); vars.set("remote", true);
pugi::xpath_node_set tools_remote = query_remote_tools.evaluate_node_set(doc); pugi::xpath_node_set tools_remote = query_remote_tools.evaluate_node_set(doc);
vars.set("remote", false); vars.set("remote", false);
pugi::xpath_node_set tools_local = query_remote_tools.evaluate_node_set(doc); pugi::xpath_node_set tools_local = query_remote_tools.evaluate_node_set(doc);
std::cout << "Remote tool: "; std::cout << "Remote tool: ";
tools_remote[2].node().print(std::cout); tools_remote[2].node().print(std::cout);
std::cout << "Local tool: "; std::cout << "Local tool: ";
tools_local[0].node().print(std::cout); tools_local[0].node().print(std::cout);
// You can pass the context directly to select_nodes/select_single_node // You can pass the context directly to select_nodes/select_single_node
pugi::xpath_node_set tools_local_imm = doc.select_nodes("/Profile/Tools/Tool[@AllowRemote = string($remote)]", &vars); pugi::xpath_node_set tools_local_imm = doc.select_nodes("/Profile/Tools/Tool[@AllowRemote = string($remote)]", &vars);
std::cout << "Local tool imm: "; std::cout << "Local tool imm: ";
tools_local_imm[0].node().print(std::cout); tools_local_imm[0].node().print(std::cout);
//] //]
} }
// vim:et // vim:et

26
scripts/pugixml_airplay.mkf
View File

@ -1,13 +1,13 @@
includepaths includepaths
{ {
"../src" "../src"
} }
files files
{ {
("../src") ("../src")
pugiconfig.hpp pugiconfig.hpp
pugixml.cpp pugixml.cpp
pugixml.hpp pugixml.hpp
} }

38
tests/data/truncation.xml
View File

@ -1,19 +1,19 @@
<?xml version="1.0"?> <?xml version="1.0"?>
<!DOCTYPE é_+å + SYSTEM "weekly-utf-8.dtd"> <!DOCTYPE é_+å + SYSTEM "weekly-utf-8.dtd">
<!-- é_+å +ã'÷ã__ã_-ã_< --> <!-- é_+å +ã'÷ã__ã_-ã_< -->
<mesh name="mesh_root"> <mesh name="mesh_root">
<!-- here is a mesh node --> <!-- here is a mesh node -->
some text some text
<![CDATA[someothertext]]> <![CDATA[someothertext]]>
some more text some more text
<node attr1="value1" attr2="value2" /> <node attr1="value1" attr2="value2" />
<node attr1="value2"> <node attr1="value2">
<æ+%è¯- å__å--="name" ä>·å__="value">ä¸-ç_æ_%å__å¤_è¯-è¨_ð¤-¢</æ+%è¯-> <æ+%è¯- å__å--="name" ä>·å__="value">ä¸-ç_æ_%å__å¤_è¯-è¨_ð¤-¢</æ+%è¯->
<innernode/> <innernode/>
</node> </node>
<æ°_å__> <æ°_å__>
<æ°_>å++ç"°</æ°_> <æ°_>å++ç"°</æ°_>
<å__>太é__</å__> <å__>太é__</å__>
</æ°_å__> </æ°_å__>
<?include somedata?> <?include somedata?>
</mesh> </mesh>

504
tests/test_dom_text.cpp
View File

@ -1,252 +1,252 @@
#include "common.hpp" #include "common.hpp"
#include "helpers.hpp" #include "helpers.hpp"
TEST_XML_FLAGS(dom_text_empty, "<node><a>foo</a><b><![CDATA[bar]]></b><c><?pi value?></c><d/></node>", parse_default | parse_pi) TEST_XML_FLAGS(dom_text_empty, "<node><a>foo</a><b><![CDATA[bar]]></b><c><?pi value?></c><d/></node>", parse_default | parse_pi)
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
CHECK(node.child(STR("a")).text()); CHECK(node.child(STR("a")).text());
CHECK(node.child(STR("b")).text()); CHECK(node.child(STR("b")).text());
CHECK(!node.child(STR("c")).text()); CHECK(!node.child(STR("c")).text());
CHECK(!node.child(STR("d")).text()); CHECK(!node.child(STR("d")).text());
CHECK(!xml_node().text()); CHECK(!xml_node().text());
CHECK(!xml_text()); CHECK(!xml_text());
generic_empty_test(node.child(STR("a")).text()); generic_empty_test(node.child(STR("a")).text());
} }
TEST_XML(dom_text_bool_ops, "<node>foo</node>") TEST_XML(dom_text_bool_ops, "<node>foo</node>")
{ {
generic_bool_ops_test(doc.child(STR("node")).text()); generic_bool_ops_test(doc.child(STR("node")).text());
} }
TEST_XML_FLAGS(dom_text_get, "<node><a>foo</a><b><node/><![CDATA[bar]]></b><c><?pi value?></c><d/></node>", parse_default | parse_pi) TEST_XML_FLAGS(dom_text_get, "<node><a>foo</a><b><node/><![CDATA[bar]]></b><c><?pi value?></c><d/></node>", parse_default | parse_pi)
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
CHECK_STRING(node.child(STR("a")).text().get(), STR("foo")); CHECK_STRING(node.child(STR("a")).text().get(), STR("foo"));
CHECK_STRING(node.child(STR("a")).first_child().text().get(), STR("foo")); CHECK_STRING(node.child(STR("a")).first_child().text().get(), STR("foo"));
CHECK_STRING(node.child(STR("b")).text().get(), STR("bar")); CHECK_STRING(node.child(STR("b")).text().get(), STR("bar"));
CHECK_STRING(node.child(STR("b")).last_child().text().get(), STR("bar")); CHECK_STRING(node.child(STR("b")).last_child().text().get(), STR("bar"));
CHECK_STRING(node.child(STR("c")).text().get(), STR("")); CHECK_STRING(node.child(STR("c")).text().get(), STR(""));
CHECK_STRING(node.child(STR("c")).first_child().text().get(), STR("")); CHECK_STRING(node.child(STR("c")).first_child().text().get(), STR(""));
CHECK_STRING(node.child(STR("d")).text().get(), STR("")); CHECK_STRING(node.child(STR("d")).text().get(), STR(""));
CHECK_STRING(xml_node().text().get(), STR("")); CHECK_STRING(xml_node().text().get(), STR(""));
} }
TEST_XML_FLAGS(dom_text_as_string, "<node><a>foo</a><b><node/><![CDATA[bar]]></b><c><?pi value?></c><d/></node>", parse_default | parse_pi) TEST_XML_FLAGS(dom_text_as_string, "<node><a>foo</a><b><node/><![CDATA[bar]]></b><c><?pi value?></c><d/></node>", parse_default | parse_pi)
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
CHECK_STRING(node.child(STR("a")).text().as_string(), STR("foo")); CHECK_STRING(node.child(STR("a")).text().as_string(), STR("foo"));
CHECK_STRING(node.child(STR("a")).first_child().text().as_string(), STR("foo")); CHECK_STRING(node.child(STR("a")).first_child().text().as_string(), STR("foo"));
CHECK_STRING(node.child(STR("b")).text().as_string(), STR("bar")); CHECK_STRING(node.child(STR("b")).text().as_string(), STR("bar"));
CHECK_STRING(node.child(STR("b")).last_child().text().as_string(), STR("bar")); CHECK_STRING(node.child(STR("b")).last_child().text().as_string(), STR("bar"));
CHECK_STRING(node.child(STR("c")).text().as_string(), STR("")); CHECK_STRING(node.child(STR("c")).text().as_string(), STR(""));
CHECK_STRING(node.child(STR("c")).first_child().text().as_string(), STR("")); CHECK_STRING(node.child(STR("c")).first_child().text().as_string(), STR(""));
CHECK_STRING(node.child(STR("d")).text().as_string(), STR("")); CHECK_STRING(node.child(STR("d")).text().as_string(), STR(""));
CHECK_STRING(xml_node().text().as_string(), STR("")); CHECK_STRING(xml_node().text().as_string(), STR(""));
} }
TEST_XML(dom_text_as_int, "<node><text1>1</text1><text2>-1</text2><text3>-2147483648</text3><text4>2147483647</text4></node>") TEST_XML(dom_text_as_int, "<node><text1>1</text1><text2>-1</text2><text3>-2147483648</text3><text4>2147483647</text4></node>")
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
CHECK(xml_text().as_int() == 0); CHECK(xml_text().as_int() == 0);
CHECK(node.child(STR("text1")).text().as_int() == 1); CHECK(node.child(STR("text1")).text().as_int() == 1);
CHECK(node.child(STR("text2")).text().as_int() == -1); CHECK(node.child(STR("text2")).text().as_int() == -1);
CHECK(node.child(STR("text3")).text().as_int() == -2147483647 - 1); CHECK(node.child(STR("text3")).text().as_int() == -2147483647 - 1);
CHECK(node.child(STR("text4")).text().as_int() == 2147483647); CHECK(node.child(STR("text4")).text().as_int() == 2147483647);
} }
TEST_XML(dom_text_as_uint, "<node><text1>0</text1><text2>1</text2><text3>2147483647</text3><text4>4294967295</text4></node>") TEST_XML(dom_text_as_uint, "<node><text1>0</text1><text2>1</text2><text3>2147483647</text3><text4>4294967295</text4></node>")
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
CHECK(xml_text().as_uint() == 0); CHECK(xml_text().as_uint() == 0);
CHECK(node.child(STR("text1")).text().as_uint() == 0); CHECK(node.child(STR("text1")).text().as_uint() == 0);
CHECK(node.child(STR("text2")).text().as_uint() == 1); CHECK(node.child(STR("text2")).text().as_uint() == 1);
CHECK(node.child(STR("text3")).text().as_uint() == 2147483647); CHECK(node.child(STR("text3")).text().as_uint() == 2147483647);
CHECK(node.child(STR("text4")).text().as_uint() == 4294967295u); CHECK(node.child(STR("text4")).text().as_uint() == 4294967295u);
} }
TEST_XML(dom_text_as_float, "<node><text1>0</text1><text2>1</text2><text3>0.12</text3><text4>-5.1</text4><text5>3e-4</text5><text6>3.14159265358979323846</text6></node>") TEST_XML(dom_text_as_float, "<node><text1>0</text1><text2>1</text2><text3>0.12</text3><text4>-5.1</text4><text5>3e-4</text5><text6>3.14159265358979323846</text6></node>")
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
CHECK(xml_text().as_float() == 0); CHECK(xml_text().as_float() == 0);
CHECK_DOUBLE(node.child(STR("text1")).text().as_float(), 0); CHECK_DOUBLE(node.child(STR("text1")).text().as_float(), 0);
CHECK_DOUBLE(node.child(STR("text2")).text().as_float(), 1); CHECK_DOUBLE(node.child(STR("text2")).text().as_float(), 1);
CHECK_DOUBLE(node.child(STR("text3")).text().as_float(), 0.12); CHECK_DOUBLE(node.child(STR("text3")).text().as_float(), 0.12);
CHECK_DOUBLE(node.child(STR("text4")).text().as_float(), -5.1); CHECK_DOUBLE(node.child(STR("text4")).text().as_float(), -5.1);
CHECK_DOUBLE(node.child(STR("text5")).text().as_float(), 3e-4); CHECK_DOUBLE(node.child(STR("text5")).text().as_float(), 3e-4);
CHECK_DOUBLE(node.child(STR("text6")).text().as_float(), 3.14159265358979323846); CHECK_DOUBLE(node.child(STR("text6")).text().as_float(), 3.14159265358979323846);
} }
TEST_XML(dom_text_as_double, "<node><text1>0</text1><text2>1</text2><text3>0.12</text3><text4>-5.1</text4><text5>3e-4</text5><text6>3.14159265358979323846</text6></node>") TEST_XML(dom_text_as_double, "<node><text1>0</text1><text2>1</text2><text3>0.12</text3><text4>-5.1</text4><text5>3e-4</text5><text6>3.14159265358979323846</text6></node>")
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
CHECK(xml_text().as_double() == 0); CHECK(xml_text().as_double() == 0);
CHECK_DOUBLE(node.child(STR("text1")).text().as_double(), 0); CHECK_DOUBLE(node.child(STR("text1")).text().as_double(), 0);
CHECK_DOUBLE(node.child(STR("text2")).text().as_double(), 1); CHECK_DOUBLE(node.child(STR("text2")).text().as_double(), 1);
CHECK_DOUBLE(node.child(STR("text3")).text().as_double(), 0.12); CHECK_DOUBLE(node.child(STR("text3")).text().as_double(), 0.12);
CHECK_DOUBLE(node.child(STR("text4")).text().as_double(), -5.1); CHECK_DOUBLE(node.child(STR("text4")).text().as_double(), -5.1);
CHECK_DOUBLE(node.child(STR("text5")).text().as_double(), 3e-4); CHECK_DOUBLE(node.child(STR("text5")).text().as_double(), 3e-4);
CHECK_DOUBLE(node.child(STR("text6")).text().as_double(), 3.14159265358979323846); CHECK_DOUBLE(node.child(STR("text6")).text().as_double(), 3.14159265358979323846);
} }
TEST_XML(dom_text_as_bool, "<node><text1>0</text1><text2>1</text2><text3>true</text3><text4>True</text4><text5>Yes</text5><text6>yes</text6><text7>false</text7></node>") TEST_XML(dom_text_as_bool, "<node><text1>0</text1><text2>1</text2><text3>true</text3><text4>True</text4><text5>Yes</text5><text6>yes</text6><text7>false</text7></node>")
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
CHECK(!xml_text().as_bool()); CHECK(!xml_text().as_bool());
CHECK(!node.child(STR("text1")).text().as_bool()); CHECK(!node.child(STR("text1")).text().as_bool());
CHECK(node.child(STR("text2")).text().as_bool()); CHECK(node.child(STR("text2")).text().as_bool());
CHECK(node.child(STR("text3")).text().as_bool()); CHECK(node.child(STR("text3")).text().as_bool());
CHECK(node.child(STR("text4")).text().as_bool()); CHECK(node.child(STR("text4")).text().as_bool());
CHECK(node.child(STR("text5")).text().as_bool()); CHECK(node.child(STR("text5")).text().as_bool());
CHECK(node.child(STR("text6")).text().as_bool()); CHECK(node.child(STR("text6")).text().as_bool());
CHECK(!node.child(STR("text7")).text().as_bool()); CHECK(!node.child(STR("text7")).text().as_bool());
} }
TEST_XML(dom_text_get_no_state, "<node/>") TEST_XML(dom_text_get_no_state, "<node/>")
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
xml_text t = node.text(); xml_text t = node.text();
CHECK(!t); CHECK(!t);
CHECK(t.get() && *t.get() == 0); CHECK(t.get() && *t.get() == 0);
CHECK(!node.first_child()); CHECK(!node.first_child());
node.append_child(node_pcdata); node.append_child(node_pcdata);
CHECK(t); CHECK(t);
CHECK_STRING(t.get(), STR("")); CHECK_STRING(t.get(), STR(""));
node.first_child().set_value(STR("test")); node.first_child().set_value(STR("test"));
CHECK(t); CHECK(t);
CHECK_STRING(t.get(), STR("test")); CHECK_STRING(t.get(), STR("test"));
} }
TEST_XML(dom_text_set, "<node/>") TEST_XML(dom_text_set, "<node/>")
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
xml_text t = node.text(); xml_text t = node.text();
t.set(STR("")); t.set(STR(""));
CHECK(node.first_child().type() == node_pcdata); CHECK(node.first_child().type() == node_pcdata);
CHECK_NODE(node, STR("<node></node>")); CHECK_NODE(node, STR("<node></node>"));
t.set(STR("boo")); t.set(STR("boo"));
CHECK(node.first_child().type() == node_pcdata); CHECK(node.first_child().type() == node_pcdata);
CHECK(node.first_child() == node.last_child()); CHECK(node.first_child() == node.last_child());
CHECK_NODE(node, STR("<node>boo</node>")); CHECK_NODE(node, STR("<node>boo</node>"));
t.set(STR("foobarfoobar")); t.set(STR("foobarfoobar"));
CHECK(node.first_child().type() == node_pcdata); CHECK(node.first_child().type() == node_pcdata);
CHECK(node.first_child() == node.last_child()); CHECK(node.first_child() == node.last_child());
CHECK_NODE(node, STR("<node>foobarfoobar</node>")); CHECK_NODE(node, STR("<node>foobarfoobar</node>"));
} }
TEST_XML(dom_text_assign, "<node/>") TEST_XML(dom_text_assign, "<node/>")
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
node.append_child(STR("text1")).text() = STR("v1"); node.append_child(STR("text1")).text() = STR("v1");
xml_text() = STR("v1"); xml_text() = STR("v1");
node.append_child(STR("text2")).text() = -2147483647; node.append_child(STR("text2")).text() = -2147483647;
node.append_child(STR("text3")).text() = -2147483647 - 1; node.append_child(STR("text3")).text() = -2147483647 - 1;
xml_text() = -2147483647 - 1; xml_text() = -2147483647 - 1;
node.append_child(STR("text4")).text() = 4294967295u; node.append_child(STR("text4")).text() = 4294967295u;
node.append_child(STR("text5")).text() = 4294967294u; node.append_child(STR("text5")).text() = 4294967294u;
xml_text() = 2147483647; xml_text() = 2147483647;
node.append_child(STR("text6")).text() = 0.5; node.append_child(STR("text6")).text() = 0.5;
xml_text() = 0.5; xml_text() = 0.5;
node.append_child(STR("text7")).text() = true; node.append_child(STR("text7")).text() = true;
xml_text() = true; xml_text() = true;
CHECK_NODE(node, STR("<node><text1>v1</text1><text2>-2147483647</text2><text3>-2147483648</text3><text4>4294967295</text4><text5>4294967294</text5><text6>0.5</text6><text7>true</text7></node>")); CHECK_NODE(node, STR("<node><text1>v1</text1><text2>-2147483647</text2><text3>-2147483648</text3><text4>4294967295</text4><text5>4294967294</text5><text6>0.5</text6><text7>true</text7></node>"));
} }
TEST_XML(dom_text_set_value, "<node/>") TEST_XML(dom_text_set_value, "<node/>")
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
CHECK(node.append_child(STR("text1")).text().set(STR("v1"))); CHECK(node.append_child(STR("text1")).text().set(STR("v1")));
CHECK(!xml_text().set(STR("v1"))); CHECK(!xml_text().set(STR("v1")));
CHECK(node.append_child(STR("text2")).text().set(-2147483647)); CHECK(node.append_child(STR("text2")).text().set(-2147483647));
CHECK(node.append_child(STR("text3")).text().set(-2147483647 - 1)); CHECK(node.append_child(STR("text3")).text().set(-2147483647 - 1));
CHECK(!xml_text().set(-2147483647 - 1)); CHECK(!xml_text().set(-2147483647 - 1));
CHECK(node.append_child(STR("text4")).text().set(4294967295u)); CHECK(node.append_child(STR("text4")).text().set(4294967295u));
CHECK(node.append_child(STR("text5")).text().set(4294967294u)); CHECK(node.append_child(STR("text5")).text().set(4294967294u));
CHECK(!xml_text().set(2147483647)); CHECK(!xml_text().set(2147483647));
CHECK(node.append_child(STR("text6")).text().set(0.5)); CHECK(node.append_child(STR("text6")).text().set(0.5));
CHECK(!xml_text().set(0.5)); CHECK(!xml_text().set(0.5));
CHECK(node.append_child(STR("text7")).text().set(true)); CHECK(node.append_child(STR("text7")).text().set(true));
CHECK(!xml_text().set(true)); CHECK(!xml_text().set(true));
CHECK_NODE(node, STR("<node><text1>v1</text1><text2>-2147483647</text2><text3>-2147483648</text3><text4>4294967295</text4><text5>4294967294</text5><text6>0.5</text6><text7>true</text7></node>")); CHECK_NODE(node, STR("<node><text1>v1</text1><text2>-2147483647</text2><text3>-2147483648</text3><text4>4294967295</text4><text5>4294967294</text5><text6>0.5</text6><text7>true</text7></node>"));
} }
TEST_XML(dom_text_middle, "<node><c1>notthisone</c1>text<c2/></node>") TEST_XML(dom_text_middle, "<node><c1>notthisone</c1>text<c2/></node>")
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
xml_text t = node.text(); xml_text t = node.text();
CHECK_STRING(t.get(), STR("text")); CHECK_STRING(t.get(), STR("text"));
t.set(STR("notext")); t.set(STR("notext"));
CHECK_NODE(node, STR("<node><c1>notthisone</c1>notext<c2 /></node>")); CHECK_NODE(node, STR("<node><c1>notthisone</c1>notext<c2 /></node>"));
CHECK(node.remove_child(t.data())); CHECK(node.remove_child(t.data()));
CHECK(!t); CHECK(!t);
CHECK_NODE(node, STR("<node><c1>notthisone</c1><c2 /></node>")); CHECK_NODE(node, STR("<node><c1>notthisone</c1><c2 /></node>"));
t.set(STR("yestext")); t.set(STR("yestext"));
CHECK(t); CHECK(t);
CHECK_NODE(node, STR("<node><c1>notthisone</c1><c2 />yestext</node>")); CHECK_NODE(node, STR("<node><c1>notthisone</c1><c2 />yestext</node>"));
CHECK(t.data() == node.last_child()); CHECK(t.data() == node.last_child());
} }
TEST_XML_FLAGS(dom_text_data, "<node><a>foo</a><b><![CDATA[bar]]></b><c><?pi value?></c><d/></node>", parse_default | parse_pi) TEST_XML_FLAGS(dom_text_data, "<node><a>foo</a><b><![CDATA[bar]]></b><c><?pi value?></c><d/></node>", parse_default | parse_pi)
{ {
xml_node node = doc.child(STR("node")); xml_node node = doc.child(STR("node"));
CHECK(node.child(STR("a")).text().data() == node.child(STR("a")).first_child()); CHECK(node.child(STR("a")).text().data() == node.child(STR("a")).first_child());
CHECK(node.child(STR("b")).text().data() == node.child(STR("b")).first_child()); CHECK(node.child(STR("b")).text().data() == node.child(STR("b")).first_child());
CHECK(!node.child(STR("c")).text().data()); CHECK(!node.child(STR("c")).text().data());
CHECK(!node.child(STR("d")).text().data()); CHECK(!node.child(STR("d")).text().data());
CHECK(!xml_text().data()); CHECK(!xml_text().data());
} }
TEST(dom_text_defaults) TEST(dom_text_defaults)
{ {
xml_text text; xml_text text;
CHECK_STRING(text.as_string(STR("foo")), STR("foo")); CHECK_STRING(text.as_string(STR("foo")), STR("foo"));
CHECK(text.as_int(42) == 42); CHECK(text.as_int(42) == 42);
CHECK(text.as_uint(42) == 42); CHECK(text.as_uint(42) == 42);
CHECK(text.as_double(42) == 42); CHECK(text.as_double(42) == 42);
CHECK(text.as_float(42) == 42); CHECK(text.as_float(42) == 42);
CHECK(text.as_bool(true) == true); CHECK(text.as_bool(true) == true);
} }

10
tests/test_header_string_iostream.cpp
View File

@ -1,5 +1,5 @@
// Tests compatibility with string/iostream // Tests compatibility with string/iostream
#include <string> #include <string>
#include "../src/pugixml.hpp" #include "../src/pugixml.hpp"
#include <istream> #include <istream>
#include <ostream> #include <ostream>

10
tests/test_version.cpp
View File

@ -1,5 +1,5 @@
#include "../src/pugixml.hpp" #include "../src/pugixml.hpp"
#if PUGIXML_VERSION != 120 #if PUGIXML_VERSION != 120
#error Unexpected pugixml version #error Unexpected pugixml version
#endif #endif

804
tests/test_xpath_variables.cpp
View File

@ -1,402 +1,402 @@
#ifndef PUGIXML_NO_XPATH #ifndef PUGIXML_NO_XPATH
#include "common.hpp" #include "common.hpp"
#include <string> #include <string>
TEST(xpath_variables_type_none) TEST(xpath_variables_type_none)
{ {
xpath_variable_set set; xpath_variable_set set;
xpath_variable* var = set.add(STR("target"), xpath_type_none); xpath_variable* var = set.add(STR("target"), xpath_type_none);
CHECK(!var); CHECK(!var);
} }
TEST(xpath_variables_type_boolean) TEST(xpath_variables_type_boolean)
{ {
xpath_variable_set set; xpath_variable_set set;
xpath_variable* var = set.add(STR("target"), xpath_type_boolean); xpath_variable* var = set.add(STR("target"), xpath_type_boolean);
CHECK(var); CHECK(var);
CHECK(var->type() == xpath_type_boolean); CHECK(var->type() == xpath_type_boolean);
CHECK_STRING(var->name(), STR("target")); CHECK_STRING(var->name(), STR("target"));
CHECK(var->get_boolean() == false); CHECK(var->get_boolean() == false);
CHECK_DOUBLE_NAN(var->get_number()); CHECK_DOUBLE_NAN(var->get_number());
CHECK_STRING(var->get_string(), STR("")); CHECK_STRING(var->get_string(), STR(""));
CHECK(var->get_node_set().empty()); CHECK(var->get_node_set().empty());
CHECK(var->set(true)); CHECK(var->set(true));
CHECK(!var->set(1.0)); CHECK(!var->set(1.0));
CHECK(!var->set(STR("abc"))); CHECK(!var->set(STR("abc")));
CHECK(!var->set(xpath_node_set())); CHECK(!var->set(xpath_node_set()));
CHECK(var->get_boolean() == true); CHECK(var->get_boolean() == true);
CHECK_DOUBLE_NAN(var->get_number()); CHECK_DOUBLE_NAN(var->get_number());
CHECK_STRING(var->get_string(), STR("")); CHECK_STRING(var->get_string(), STR(""));
CHECK(var->get_node_set().empty()); CHECK(var->get_node_set().empty());
} }
TEST(xpath_variables_type_number) TEST(xpath_variables_type_number)
{ {
xpath_variable_set set; xpath_variable_set set;
xpath_variable* var = set.add(STR("target"), xpath_type_number); xpath_variable* var = set.add(STR("target"), xpath_type_number);
CHECK(var); CHECK(var);
CHECK(var->type() == xpath_type_number); CHECK(var->type() == xpath_type_number);
CHECK_STRING(var->name(), STR("target")); CHECK_STRING(var->name(), STR("target"));
CHECK(var->get_boolean() == false); CHECK(var->get_boolean() == false);
CHECK_DOUBLE(var->get_number(), 0); CHECK_DOUBLE(var->get_number(), 0);
CHECK_STRING(var->get_string(), STR("")); CHECK_STRING(var->get_string(), STR(""));
CHECK(var->get_node_set().empty()); CHECK(var->get_node_set().empty());
CHECK(!var->set(true)); CHECK(!var->set(true));
CHECK(var->set(1.0)); CHECK(var->set(1.0));
CHECK(!var->set(STR("abc"))); CHECK(!var->set(STR("abc")));
CHECK(!var->set(xpath_node_set())); CHECK(!var->set(xpath_node_set()));
CHECK(var->get_boolean() == false); CHECK(var->get_boolean() == false);
CHECK_DOUBLE(var->get_number(), 1); CHECK_DOUBLE(var->get_number(), 1);
CHECK_STRING(var->get_string(), STR("")); CHECK_STRING(var->get_string(), STR(""));
CHECK(var->get_node_set().empty()); CHECK(var->get_node_set().empty());
} }
TEST(xpath_variables_type_string) TEST(xpath_variables_type_string)
{ {
xpath_variable_set set; xpath_variable_set set;
xpath_variable* var = set.add(STR("target"), xpath_type_string); xpath_variable* var = set.add(STR("target"), xpath_type_string);
CHECK(var); CHECK(var);
CHECK(var->type() == xpath_type_string); CHECK(var->type() == xpath_type_string);
CHECK_STRING(var->name(), STR("target")); CHECK_STRING(var->name(), STR("target"));
CHECK(var->get_boolean() == false); CHECK(var->get_boolean() == false);
CHECK_DOUBLE_NAN(var->get_number()); CHECK_DOUBLE_NAN(var->get_number());
CHECK_STRING(var->get_string(), STR("")); CHECK_STRING(var->get_string(), STR(""));
CHECK(var->get_node_set().empty()); CHECK(var->get_node_set().empty());
CHECK(!var->set(true)); CHECK(!var->set(true));
CHECK(!var->set(1.0)); CHECK(!var->set(1.0));
CHECK(var->set(STR("abc"))); CHECK(var->set(STR("abc")));
CHECK(!var->set(xpath_node_set())); CHECK(!var->set(xpath_node_set()));
CHECK(var->get_boolean() == false); CHECK(var->get_boolean() == false);
CHECK_DOUBLE_NAN(var->get_number()); CHECK_DOUBLE_NAN(var->get_number());
CHECK_STRING(var->get_string(), STR("abc")); CHECK_STRING(var->get_string(), STR("abc"));
CHECK(var->get_node_set().empty()); CHECK(var->get_node_set().empty());
} }
TEST_XML(xpath_variables_type_node_set, "<node/>") TEST_XML(xpath_variables_type_node_set, "<node/>")
{ {
xpath_variable_set set; xpath_variable_set set;
xpath_variable* var = set.add(STR("target"), xpath_type_node_set); xpath_variable* var = set.add(STR("target"), xpath_type_node_set);
CHECK(var); CHECK(var);
CHECK(var->type() == xpath_type_node_set); CHECK(var->type() == xpath_type_node_set);
CHECK_STRING(var->name(), STR("target")); CHECK_STRING(var->name(), STR("target"));
CHECK(var->get_boolean() == false); CHECK(var->get_boolean() == false);
CHECK_DOUBLE_NAN(var->get_number()); CHECK_DOUBLE_NAN(var->get_number());
CHECK_STRING(var->get_string(), STR("")); CHECK_STRING(var->get_string(), STR(""));
CHECK(var->get_node_set().empty()); CHECK(var->get_node_set().empty());
CHECK(!var->set(true)); CHECK(!var->set(true));
CHECK(!var->set(1.0)); CHECK(!var->set(1.0));
CHECK(!var->set(STR("abc"))); CHECK(!var->set(STR("abc")));
CHECK(var->set(doc.select_nodes(STR("*")))); CHECK(var->set(doc.select_nodes(STR("*"))));
CHECK(var->get_boolean() == false); CHECK(var->get_boolean() == false);
CHECK_DOUBLE_NAN(var->get_number()); CHECK_DOUBLE_NAN(var->get_number());
CHECK_STRING(var->get_string(), STR("")); CHECK_STRING(var->get_string(), STR(""));
CHECK(var->get_node_set().size() == 1 && var->get_node_set()[0] == doc.first_child()); CHECK(var->get_node_set().size() == 1 && var->get_node_set()[0] == doc.first_child());
} }
TEST(xpath_variables_set_operations) TEST(xpath_variables_set_operations)
{ {
xpath_variable_set set; xpath_variable_set set;
xpath_variable* v1 = set.add(STR("var1"), xpath_type_number); xpath_variable* v1 = set.add(STR("var1"), xpath_type_number);
CHECK(v1); CHECK(v1);
xpath_variable* v2 = set.add(STR("var2"), xpath_type_string); xpath_variable* v2 = set.add(STR("var2"), xpath_type_string);
CHECK(v2); CHECK(v2);
CHECK(v1 != v2); CHECK(v1 != v2);
CHECK(set.add(STR("var1"), xpath_type_number) == v1); CHECK(set.add(STR("var1"), xpath_type_number) == v1);
CHECK(set.add(STR("var2"), xpath_type_string) == v2); CHECK(set.add(STR("var2"), xpath_type_string) == v2);
CHECK(set.add(STR("var2"), xpath_type_node_set) == 0); CHECK(set.add(STR("var2"), xpath_type_node_set) == 0);
CHECK(set.get(STR("var1")) == v1); CHECK(set.get(STR("var1")) == v1);
CHECK(set.get(STR("var2")) == v2); CHECK(set.get(STR("var2")) == v2);
CHECK(set.get(STR("var")) == 0); CHECK(set.get(STR("var")) == 0);
CHECK(set.get(STR("var11")) == 0); CHECK(set.get(STR("var11")) == 0);
CHECK(static_cast<const xpath_variable_set&>(set).get(STR("var1")) == v1); CHECK(static_cast<const xpath_variable_set&>(set).get(STR("var1")) == v1);
CHECK(static_cast<const xpath_variable_set&>(set).get(STR("var3")) == 0); CHECK(static_cast<const xpath_variable_set&>(set).get(STR("var3")) == 0);
} }
TEST_XML(xpath_variables_set_operations_set, "<node/>") TEST_XML(xpath_variables_set_operations_set, "<node/>")
{ {
xpath_variable_set set; xpath_variable_set set;
xpath_variable* v1 = set.add(STR("var1"), xpath_type_number); xpath_variable* v1 = set.add(STR("var1"), xpath_type_number);
CHECK(v1); CHECK(v1);
xpath_variable* v2 = set.add(STR("var2"), xpath_type_string); xpath_variable* v2 = set.add(STR("var2"), xpath_type_string);
CHECK(v2); CHECK(v2);
CHECK(set.set(STR("var1"), 1.0)); CHECK(set.set(STR("var1"), 1.0));
CHECK_DOUBLE(v1->get_number(), 1.0); CHECK_DOUBLE(v1->get_number(), 1.0);
CHECK(set.set(STR("var2"), STR("value"))); CHECK(set.set(STR("var2"), STR("value")));
CHECK_STRING(v2->get_string(), STR("value")); CHECK_STRING(v2->get_string(), STR("value"));
CHECK(!set.set(STR("var1"), true)); CHECK(!set.set(STR("var1"), true));
CHECK(set.set(STR("var3"), doc.select_nodes(STR("*")))); CHECK(set.set(STR("var3"), doc.select_nodes(STR("*"))));
xpath_variable* v3 = set.get(STR("var3")); xpath_variable* v3 = set.get(STR("var3"));
CHECK(v3); CHECK(v3);
CHECK(v3->type() == xpath_type_node_set); CHECK(v3->type() == xpath_type_node_set);
CHECK(v3->get_node_set().size() == 1); CHECK(v3->get_node_set().size() == 1);
} }
TEST(xpath_variables_set_out_of_memory) TEST(xpath_variables_set_out_of_memory)
{ {
test_runner::_memory_fail_threshold = 1; test_runner::_memory_fail_threshold = 1;
xpath_variable_set set; xpath_variable_set set;
xpath_variable* var = set.add(STR("target"), xpath_type_number); xpath_variable* var = set.add(STR("target"), xpath_type_number);
CHECK(!var); CHECK(!var);
} }
TEST(xpath_variables_out_of_memory) TEST(xpath_variables_out_of_memory)
{ {
test_runner::_memory_fail_threshold = 64; test_runner::_memory_fail_threshold = 64;
xpath_variable_set set; xpath_variable_set set;
xpath_variable* var = set.add(STR("target"), xpath_type_string); xpath_variable* var = set.add(STR("target"), xpath_type_string);
CHECK(var); CHECK(var);
CHECK(!var->set(STR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"))); CHECK(!var->set(STR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")));
} }
TEST_XML(xpath_variables_evaluate, "<node/>") TEST_XML(xpath_variables_evaluate, "<node/>")
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("var1"), true); set.set(STR("var1"), true);
set.set(STR("var2"), 0.5); set.set(STR("var2"), 0.5);
set.set(STR("var3"), STR("value")); set.set(STR("var3"), STR("value"));
set.set(STR("var4"), doc.select_nodes(STR("*"))); set.set(STR("var4"), doc.select_nodes(STR("*")));
CHECK_XPATH_BOOLEAN_VAR(doc, STR("$var1"), &set, true); CHECK_XPATH_BOOLEAN_VAR(doc, STR("$var1"), &set, true);
CHECK_XPATH_NUMBER_VAR(doc, STR("$var2"), &set, 0.5); CHECK_XPATH_NUMBER_VAR(doc, STR("$var2"), &set, 0.5);
CHECK_XPATH_STRING_VAR(doc, STR("$var3"), &set, STR("value")); CHECK_XPATH_STRING_VAR(doc, STR("$var3"), &set, STR("value"));
CHECK_XPATH_NODESET_VAR(doc, STR("$var4"), &set) % 2; CHECK_XPATH_NODESET_VAR(doc, STR("$var4"), &set) % 2;
} }
TEST_XML(xpath_variables_evaluate_conversion, "<node>3</node>") TEST_XML(xpath_variables_evaluate_conversion, "<node>3</node>")
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("var"), doc.select_nodes(STR("*"))); set.set(STR("var"), doc.select_nodes(STR("*")));
CHECK_XPATH_BOOLEAN_VAR(doc, STR("$var"), &set, true); CHECK_XPATH_BOOLEAN_VAR(doc, STR("$var"), &set, true);
CHECK_XPATH_NUMBER_VAR(doc, STR("$var"), &set, 3); CHECK_XPATH_NUMBER_VAR(doc, STR("$var"), &set, 3);
CHECK_XPATH_STRING_VAR(doc, STR("$var"), &set, STR("3")); CHECK_XPATH_STRING_VAR(doc, STR("$var"), &set, STR("3"));
CHECK_XPATH_NODESET_VAR(doc, STR("$var"), &set) % 2; CHECK_XPATH_NODESET_VAR(doc, STR("$var"), &set) % 2;
} }
TEST(xpath_variables_evaluate_node_set_fail) TEST(xpath_variables_evaluate_node_set_fail)
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("var"), false); set.set(STR("var"), false);
xpath_query q(STR("$var"), &set); xpath_query q(STR("$var"), &set);
#ifdef PUGIXML_NO_EXCEPTIONS #ifdef PUGIXML_NO_EXCEPTIONS
CHECK(q.evaluate_node_set(xml_node()).empty()); CHECK(q.evaluate_node_set(xml_node()).empty());
#else #else
try try
{ {
q.evaluate_node_set(xml_node()); q.evaluate_node_set(xml_node());
CHECK_FORCE_FAIL("Expected exception"); CHECK_FORCE_FAIL("Expected exception");
} }
catch (const xpath_exception&) catch (const xpath_exception&)
{ {
} }
#endif #endif
} }
TEST(xpath_variables_multiple_documents) TEST(xpath_variables_multiple_documents)
{ {
xml_document doc; xml_document doc;
doc.append_child().set_name(STR("node")); doc.append_child().set_name(STR("node"));
xml_document doc1; xml_document doc1;
doc1.append_child().set_name(STR("node")); doc1.append_child().set_name(STR("node"));
xml_document doc2; xml_document doc2;
doc2.append_child().set_name(STR("node")); doc2.append_child().set_name(STR("node"));
xpath_variable_set set; xpath_variable_set set;
set.set(STR("var1"), doc1.select_nodes(STR("*"))); set.set(STR("var1"), doc1.select_nodes(STR("*")));
set.set(STR("var2"), doc2.select_nodes(STR("*"))); set.set(STR("var2"), doc2.select_nodes(STR("*")));
xpath_node_set ns = doc.select_nodes(STR("$var1 | $var2 | node"), &set); xpath_node_set ns = doc.select_nodes(STR("$var1 | $var2 | node"), &set);
ns.sort(); ns.sort();
CHECK(ns.size() == 3); CHECK(ns.size() == 3);
CHECK(ns[0] != ns[1] && ns[0] != ns[2]); CHECK(ns[0] != ns[1] && ns[0] != ns[2]);
xml_node n0 = doc.child(STR("node")), n1 = doc1.child(STR("node")), n2 = doc2.child(STR("node")); xml_node n0 = doc.child(STR("node")), n1 = doc1.child(STR("node")), n2 = doc2.child(STR("node"));
CHECK(n0 == ns[0].node() || n0 == ns[1].node() || n0 == ns[2].node()); CHECK(n0 == ns[0].node() || n0 == ns[1].node() || n0 == ns[2].node());
CHECK(n1 == ns[0].node() || n1 == ns[1].node() || n1 == ns[2].node()); CHECK(n1 == ns[0].node() || n1 == ns[1].node() || n1 == ns[2].node());
CHECK(n2 == ns[0].node() || n2 == ns[1].node() || n2 == ns[2].node()); CHECK(n2 == ns[0].node() || n2 == ns[1].node() || n2 == ns[2].node());
} }
TEST(xpath_variables_long_name) TEST(xpath_variables_long_name)
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), true); set.set(STR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), true);
CHECK_XPATH_BOOLEAN_VAR(xml_node(), STR("$abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), &set, true); CHECK_XPATH_BOOLEAN_VAR(xml_node(), STR("$abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), &set, true);
} }
TEST_XML(xpath_variables_select, "<node attr='1'/><node attr='2'/>") TEST_XML(xpath_variables_select, "<node attr='1'/><node attr='2'/>")
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("one"), 1.0); set.set(STR("one"), 1.0);
xpath_node_set ns = doc.select_nodes(STR("node[@attr=$one+1]"), &set); xpath_node_set ns = doc.select_nodes(STR("node[@attr=$one+1]"), &set);
CHECK(ns.size() == 1 && ns[0].node() == doc.last_child()); CHECK(ns.size() == 1 && ns[0].node() == doc.last_child());
xpath_node n = doc.select_single_node(STR("node[@attr=$one+1]"), &set); xpath_node n = doc.select_single_node(STR("node[@attr=$one+1]"), &set);
CHECK(n == ns[0]); CHECK(n == ns[0]);
} }
TEST(xpath_variables_empty_name) TEST(xpath_variables_empty_name)
{ {
xpath_variable_set set; xpath_variable_set set;
CHECK(!set.add(STR(""), xpath_type_number)); CHECK(!set.add(STR(""), xpath_type_number));
} }
TEST_XML(xpath_variables_inside_filter, "<node key='1' value='2'/><node key='2' value='1'/><node key='1' value='1'/>") TEST_XML(xpath_variables_inside_filter, "<node key='1' value='2'/><node key='2' value='1'/><node key='1' value='1'/>")
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("one"), 1.0); set.set(STR("one"), 1.0);
xpath_node_set ns = doc.select_nodes(STR("(node[@key = $one])[@value = $one]"), &set); xpath_node_set ns = doc.select_nodes(STR("(node[@key = $one])[@value = $one]"), &set);
CHECK(ns.size() == 1 && ns[0].node() == doc.last_child()); CHECK(ns.size() == 1 && ns[0].node() == doc.last_child());
} }
TEST_XML(xpath_variables_step, "<node><child/><child/><child><child/></child></node>") TEST_XML(xpath_variables_step, "<node><child/><child/><child><child/></child></node>")
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("root"), doc.select_nodes(STR("node"))); set.set(STR("root"), doc.select_nodes(STR("node")));
CHECK_XPATH_NODESET_VAR(xml_node(), STR("$root/child"), &set) % 3 % 4 % 5; CHECK_XPATH_NODESET_VAR(xml_node(), STR("$root/child"), &set) % 3 % 4 % 5;
CHECK_XPATH_NODESET_VAR(xml_node(), STR("$root//child"), &set) % 3 % 4 % 5 % 6; CHECK_XPATH_NODESET_VAR(xml_node(), STR("$root//child"), &set) % 3 % 4 % 5 % 6;
} }
TEST_XML(xpath_variables_index, "<node><child/><child/><child><child/></child></node>") TEST_XML(xpath_variables_index, "<node><child/><child/><child><child/></child></node>")
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("index"), 2.0); set.set(STR("index"), 2.0);
CHECK_XPATH_NODESET_VAR(doc, STR("node/child[$index]"), &set) % 4; CHECK_XPATH_NODESET_VAR(doc, STR("node/child[$index]"), &set) % 4;
CHECK_XPATH_NODESET_VAR(doc, STR("node/child[position()=$index]"), &set) % 4; CHECK_XPATH_NODESET_VAR(doc, STR("node/child[position()=$index]"), &set) % 4;
} }
TEST(xpath_variables_qname) TEST(xpath_variables_qname)
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("foo:bar"), true); set.set(STR("foo:bar"), true);
CHECK_XPATH_BOOLEAN_VAR(xml_node(), STR("$foo:bar"), &set, true); CHECK_XPATH_BOOLEAN_VAR(xml_node(), STR("$foo:bar"), &set, true);
} }
TEST(xpath_variables_name_error) TEST(xpath_variables_name_error)
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("foo:"), true); set.set(STR("foo:"), true);
set.set(STR(":bar"), true); set.set(STR(":bar"), true);
set.set(STR("foo:*"), true); set.set(STR("foo:*"), true);
set.set(STR("foo"), true); set.set(STR("foo"), true);
set.set(STR("3"), true); set.set(STR("3"), true);
CHECK_XPATH_FAIL_VAR(STR("$foo:"), &set); CHECK_XPATH_FAIL_VAR(STR("$foo:"), &set);
CHECK_XPATH_FAIL_VAR(STR("$:bar"), &set); CHECK_XPATH_FAIL_VAR(STR("$:bar"), &set);
CHECK_XPATH_FAIL_VAR(STR("$foo:*"), &set); CHECK_XPATH_FAIL_VAR(STR("$foo:*"), &set);
CHECK_XPATH_FAIL_VAR(STR("$foo:bar:baz"), &set); CHECK_XPATH_FAIL_VAR(STR("$foo:bar:baz"), &set);
CHECK_XPATH_FAIL_VAR(STR("$ foo"), &set); CHECK_XPATH_FAIL_VAR(STR("$ foo"), &set);
CHECK_XPATH_FAIL_VAR(STR("$3"), &set); CHECK_XPATH_FAIL_VAR(STR("$3"), &set);
} }
TEST(xpath_variables_empty_string) TEST(xpath_variables_empty_string)
{ {
xpath_variable_set set; xpath_variable_set set;
set.add(STR("empty"), xpath_type_string); set.add(STR("empty"), xpath_type_string);
CHECK_XPATH_BOOLEAN_VAR(xml_node(), STR("$empty = substring-before('a', 'z')"), &set, true); CHECK_XPATH_BOOLEAN_VAR(xml_node(), STR("$empty = substring-before('a', 'z')"), &set, true);
} }
TEST(xpath_variables_name_underscore) TEST(xpath_variables_name_underscore)
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("_foo_bar"), true); set.set(STR("_foo_bar"), true);
CHECK_XPATH_BOOLEAN_VAR(xml_node(), STR("$_foo_bar"), &set, true); CHECK_XPATH_BOOLEAN_VAR(xml_node(), STR("$_foo_bar"), &set, true);
} }
TEST(xpath_variables_name_case) TEST(xpath_variables_name_case)
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("i"), 5.0); set.set(STR("i"), 5.0);
set.set(STR("I"), 2.0); set.set(STR("I"), 2.0);
CHECK_XPATH_NUMBER_VAR(xml_node(), STR("$i div $I"), &set, 2.5); CHECK_XPATH_NUMBER_VAR(xml_node(), STR("$i div $I"), &set, 2.5);
} }
TEST(xpath_variables_name_unicode) TEST(xpath_variables_name_unicode)
{ {
#ifdef PUGIXML_WCHAR_MODE #ifdef PUGIXML_WCHAR_MODE
#ifdef U_LITERALS #ifdef U_LITERALS
const char_t* name = L"\u0400\u203D"; const char_t* name = L"\u0400\u203D";
#else #else
const char_t* name = L"\x0400\x203D"; const char_t* name = L"\x0400\x203D";
#endif #endif
#else #else
const char_t* name = "\xd0\x80\xe2\x80\xbd"; const char_t* name = "\xd0\x80\xe2\x80\xbd";
#endif #endif
xpath_variable_set set; xpath_variable_set set;
set.set(name, STR("value")); set.set(name, STR("value"));
std::basic_string<char_t> var = STR("$"); std::basic_string<char_t> var = STR("$");
var += name; var += name;
CHECK_XPATH_STRING_VAR(xml_node(), var.c_str(), &set, STR("value")); CHECK_XPATH_STRING_VAR(xml_node(), var.c_str(), &set, STR("value"));
} }
TEST_XML(xpath_variables_count_sum, "<node><c1>12</c1><c2>23</c2><c3>34</c3></node>") TEST_XML(xpath_variables_count_sum, "<node><c1>12</c1><c2>23</c2><c3>34</c3></node>")
{ {
xpath_variable_set set; xpath_variable_set set;
set.set(STR("c12"), doc.select_nodes(STR("node/c1 | node/c2"))); set.set(STR("c12"), doc.select_nodes(STR("node/c1 | node/c2")));
set.set(STR("c3"), doc.select_nodes(STR("node/c3"))); set.set(STR("c3"), doc.select_nodes(STR("node/c3")));
set.set(STR("c"), doc.select_nodes(STR("node/*"))); set.set(STR("c"), doc.select_nodes(STR("node/*")));
CHECK_XPATH_NUMBER_VAR(xml_node(), STR("sum($c12) * count($c) - sum($c3)"), &set, 71); CHECK_XPATH_NUMBER_VAR(xml_node(), STR("sum($c12) * count($c) - sum($c3)"), &set, 71);
} }
#endif #endif