Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1 | #if defined( _MSC_VER )
|
| 2 | #if !defined( _CRT_SECURE_NO_WARNINGS )
|
| 3 | #define _CRT_SECURE_NO_WARNINGS // This test file is not intended to be secure.
|
| 4 | #endif
|
| 5 | #endif
|
| 6 |
|
| 7 | #include "tinyxml2.h"
|
| 8 | #include <cerrno>
|
| 9 | #include <cstdlib>
|
| 10 | #include <cstring>
|
| 11 | #include <ctime>
|
| 12 |
|
| 13 | #if defined( _MSC_VER ) || defined (WIN32)
|
| 14 | #include <crtdbg.h>
|
| 15 | #define WIN32_LEAN_AND_MEAN
|
| 16 | #include <windows.h>
|
| 17 | _CrtMemState startMemState;
|
| 18 | _CrtMemState endMemState;
|
| 19 | #else
|
| 20 | #include <sys/stat.h>
|
| 21 | #include <sys/types.h>
|
| 22 | #endif
|
| 23 |
|
| 24 | using namespace tinyxml2;
|
| 25 | using namespace std;
|
| 26 | int gPass = 0;
|
| 27 | int gFail = 0;
|
| 28 |
|
| 29 |
|
| 30 | bool XMLTest (const char* testString, const char* expected, const char* found, bool echo=true, bool extraNL=false )
|
| 31 | {
|
| 32 | bool pass;
|
| 33 | if ( !expected && !found )
|
| 34 | pass = true;
|
| 35 | else if ( !expected || !found )
|
| 36 | pass = false;
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 37 | else
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 38 | pass = !strcmp( expected, found );
|
| 39 | if ( pass )
|
| 40 | printf ("[pass]");
|
| 41 | else
|
| 42 | printf ("[fail]");
|
| 43 |
|
| 44 | if ( !echo ) {
|
| 45 | printf (" %s\n", testString);
|
| 46 | }
|
| 47 | else {
|
| 48 | if ( extraNL ) {
|
| 49 | printf( " %s\n", testString );
|
| 50 | printf( "%s\n", expected );
|
| 51 | printf( "%s\n", found );
|
| 52 | }
|
| 53 | else {
|
| 54 | printf (" %s [%s][%s]\n", testString, expected, found);
|
| 55 | }
|
| 56 | }
|
| 57 |
|
| 58 | if ( pass )
|
| 59 | ++gPass;
|
| 60 | else
|
| 61 | ++gFail;
|
| 62 | return pass;
|
| 63 | }
|
| 64 |
|
| 65 | bool XMLTest(const char* testString, XMLError expected, XMLError found, bool echo = true, bool extraNL = false)
|
| 66 | {
|
| 67 | return XMLTest(testString, XMLDocument::ErrorIDToName(expected), XMLDocument::ErrorIDToName(found), echo, extraNL);
|
| 68 | }
|
| 69 |
|
| 70 | bool XMLTest(const char* testString, bool expected, bool found, bool echo = true, bool extraNL = false)
|
| 71 | {
|
| 72 | return XMLTest(testString, expected ? "true" : "false", found ? "true" : "false", echo, extraNL);
|
| 73 | }
|
| 74 |
|
| 75 | template< class T > bool XMLTest( const char* testString, T expected, T found, bool echo=true )
|
| 76 | {
|
| 77 | bool pass = ( expected == found );
|
| 78 | if ( pass )
|
| 79 | printf ("[pass]");
|
| 80 | else
|
| 81 | printf ("[fail]");
|
| 82 |
|
| 83 | if ( !echo )
|
| 84 | printf (" %s\n", testString);
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 85 | else {
|
| 86 | char expectedAsString[64];
|
| 87 | XMLUtil::ToStr(expected, expectedAsString, sizeof(expectedAsString));
|
| 88 |
|
| 89 | char foundAsString[64];
|
| 90 | XMLUtil::ToStr(found, foundAsString, sizeof(foundAsString));
|
| 91 |
|
| 92 | printf (" %s [%s][%s]\n", testString, expectedAsString, foundAsString );
|
| 93 | }
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 94 |
|
| 95 | if ( pass )
|
| 96 | ++gPass;
|
| 97 | else
|
| 98 | ++gFail;
|
| 99 | return pass;
|
| 100 | }
|
| 101 |
|
| 102 |
|
| 103 | void NullLineEndings( char* p )
|
| 104 | {
|
| 105 | while( p && *p ) {
|
| 106 | if ( *p == '\n' || *p == '\r' ) {
|
| 107 | *p = 0;
|
| 108 | return;
|
| 109 | }
|
| 110 | ++p;
|
| 111 | }
|
| 112 | }
|
| 113 |
|
| 114 |
|
| 115 | int example_1()
|
| 116 | {
|
| 117 | XMLDocument doc;
|
| 118 | doc.LoadFile( "resources/dream.xml" );
|
| 119 |
|
| 120 | return doc.ErrorID();
|
| 121 | }
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 122 | /** @page Example_1 Load an XML File
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 123 | * @dontinclude ./xmltest.cpp
|
| 124 | * Basic XML file loading.
|
| 125 | * The basic syntax to load an XML file from
|
| 126 | * disk and check for an error. (ErrorID()
|
| 127 | * will return 0 for no error.)
|
| 128 | * @skip example_1()
|
| 129 | * @until }
|
| 130 | */
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 131 |
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 132 |
|
| 133 | int example_2()
|
| 134 | {
|
| 135 | static const char* xml = "<element/>";
|
| 136 | XMLDocument doc;
|
| 137 | doc.Parse( xml );
|
| 138 |
|
| 139 | return doc.ErrorID();
|
| 140 | }
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 141 | /** @page Example_2 Parse an XML from char buffer
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 142 | * @dontinclude ./xmltest.cpp
|
| 143 | * Basic XML string parsing.
|
| 144 | * The basic syntax to parse an XML for
|
| 145 | * a char* and check for an error. (ErrorID()
|
| 146 | * will return 0 for no error.)
|
| 147 | * @skip example_2()
|
| 148 | * @until }
|
| 149 | */
|
| 150 |
|
| 151 |
|
| 152 | int example_3()
|
| 153 | {
|
| 154 | static const char* xml =
|
| 155 | "<?xml version=\"1.0\"?>"
|
| 156 | "<!DOCTYPE PLAY SYSTEM \"play.dtd\">"
|
| 157 | "<PLAY>"
|
| 158 | "<TITLE>A Midsummer Night's Dream</TITLE>"
|
| 159 | "</PLAY>";
|
| 160 |
|
| 161 | XMLDocument doc;
|
| 162 | doc.Parse( xml );
|
| 163 |
|
| 164 | XMLElement* titleElement = doc.FirstChildElement( "PLAY" )->FirstChildElement( "TITLE" );
|
| 165 | const char* title = titleElement->GetText();
|
| 166 | printf( "Name of play (1): %s\n", title );
|
| 167 |
|
| 168 | XMLText* textNode = titleElement->FirstChild()->ToText();
|
| 169 | title = textNode->Value();
|
| 170 | printf( "Name of play (2): %s\n", title );
|
| 171 |
|
| 172 | return doc.ErrorID();
|
| 173 | }
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 174 | /** @page Example_3 Get information out of XML
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 175 | @dontinclude ./xmltest.cpp
|
| 176 | In this example, we navigate a simple XML
|
| 177 | file, and read some interesting text. Note
|
| 178 | that this example doesn't use error
|
| 179 | checking; working code should check for null
|
| 180 | pointers when walking an XML tree, or use
|
| 181 | XMLHandle.
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 182 |
|
| 183 | (The XML is an excerpt from "dream.xml").
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 184 |
|
| 185 | @skip example_3()
|
| 186 | @until </PLAY>";
|
| 187 |
|
| 188 | The structure of the XML file is:
|
| 189 |
|
| 190 | <ul>
|
| 191 | <li>(declaration)</li>
|
| 192 | <li>(dtd stuff)</li>
|
| 193 | <li>Element "PLAY"</li>
|
| 194 | <ul>
|
| 195 | <li>Element "TITLE"</li>
|
| 196 | <ul>
|
| 197 | <li>Text "A Midsummer Night's Dream"</li>
|
| 198 | </ul>
|
| 199 | </ul>
|
| 200 | </ul>
|
| 201 |
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 202 | For this example, we want to print out the
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 203 | title of the play. The text of the title (what
|
| 204 | we want) is child of the "TITLE" element which
|
| 205 | is a child of the "PLAY" element.
|
| 206 |
|
| 207 | We want to skip the declaration and dtd, so the
|
| 208 | method FirstChildElement() is a good choice. The
|
| 209 | FirstChildElement() of the Document is the "PLAY"
|
| 210 | Element, the FirstChildElement() of the "PLAY" Element
|
| 211 | is the "TITLE" Element.
|
| 212 |
|
| 213 | @until ( "TITLE" );
|
| 214 |
|
| 215 | We can then use the convenience function GetText()
|
| 216 | to get the title of the play.
|
| 217 |
|
| 218 | @until title );
|
| 219 |
|
| 220 | Text is just another Node in the XML DOM. And in
|
| 221 | fact you should be a little cautious with it, as
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 222 | text nodes can contain elements.
|
| 223 |
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 224 | @verbatim
|
| 225 | Consider: A Midsummer Night's <b>Dream</b>
|
| 226 | @endverbatim
|
| 227 |
|
| 228 | It is more correct to actually query the Text Node
|
| 229 | if in doubt:
|
| 230 |
|
| 231 | @until title );
|
| 232 |
|
| 233 | Noting that here we use FirstChild() since we are
|
| 234 | looking for XMLText, not an element, and ToText()
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 235 | is a cast from a Node to a XMLText.
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 236 | */
|
| 237 |
|
| 238 |
|
| 239 | bool example_4()
|
| 240 | {
|
| 241 | static const char* xml =
|
| 242 | "<information>"
|
| 243 | " <attributeApproach v='2' />"
|
| 244 | " <textApproach>"
|
| 245 | " <v>2</v>"
|
| 246 | " </textApproach>"
|
| 247 | "</information>";
|
| 248 |
|
| 249 | XMLDocument doc;
|
| 250 | doc.Parse( xml );
|
| 251 |
|
| 252 | int v0 = 0;
|
| 253 | int v1 = 0;
|
| 254 |
|
| 255 | XMLElement* attributeApproachElement = doc.FirstChildElement()->FirstChildElement( "attributeApproach" );
|
| 256 | attributeApproachElement->QueryIntAttribute( "v", &v0 );
|
| 257 |
|
| 258 | XMLElement* textApproachElement = doc.FirstChildElement()->FirstChildElement( "textApproach" );
|
| 259 | textApproachElement->FirstChildElement( "v" )->QueryIntText( &v1 );
|
| 260 |
|
| 261 | printf( "Both values are the same: %d and %d\n", v0, v1 );
|
| 262 |
|
| 263 | return !doc.Error() && ( v0 == v1 );
|
| 264 | }
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 265 | /** @page Example_4 Read attributes and text information.
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 266 | @dontinclude ./xmltest.cpp
|
| 267 |
|
| 268 | There are fundamentally 2 ways of writing a key-value
|
| 269 | pair into an XML file. (Something that's always annoyed
|
| 270 | me about XML.) Either by using attributes, or by writing
|
| 271 | the key name into an element and the value into
|
| 272 | the text node wrapped by the element. Both approaches
|
| 273 | are illustrated in this example, which shows two ways
|
| 274 | to encode the value "2" into the key "v":
|
| 275 |
|
| 276 | @skip example_4()
|
| 277 | @until "</information>";
|
| 278 |
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 279 | TinyXML-2 has accessors for both approaches.
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 280 |
|
| 281 | When using an attribute, you navigate to the XMLElement
|
| 282 | with that attribute and use the QueryIntAttribute()
|
| 283 | group of methods. (Also QueryFloatAttribute(), etc.)
|
| 284 |
|
| 285 | @skip XMLElement* attributeApproachElement
|
| 286 | @until &v0 );
|
| 287 |
|
| 288 | When using the text approach, you need to navigate
|
| 289 | down one more step to the XMLElement that contains
|
| 290 | the text. Note the extra FirstChildElement( "v" )
|
| 291 | in the code below. The value of the text can then
|
| 292 | be safely queried with the QueryIntText() group
|
| 293 | of methods. (Also QueryFloatText(), etc.)
|
| 294 |
|
| 295 | @skip XMLElement* textApproachElement
|
| 296 | @until &v1 );
|
| 297 | */
|
| 298 |
|
| 299 |
|
| 300 | int main( int argc, const char ** argv )
|
| 301 | {
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 302 | #if defined( _MSC_VER ) && defined( TINYXML2_DEBUG )
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 303 | _CrtMemCheckpoint( &startMemState );
|
| 304 | // Enable MS Visual C++ debug heap memory leaks dump on exit
|
| 305 | _CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
|
| 306 | {
|
| 307 | int leaksOnStart = _CrtDumpMemoryLeaks();
|
| 308 | XMLTest( "No leaks on start?", FALSE, leaksOnStart );
|
| 309 | }
|
| 310 | #endif
|
| 311 |
|
| 312 | {
|
| 313 | TIXMLASSERT( true );
|
| 314 | }
|
| 315 |
|
| 316 | if ( argc > 1 ) {
|
| 317 | XMLDocument* doc = new XMLDocument();
|
| 318 | clock_t startTime = clock();
|
| 319 | doc->LoadFile( argv[1] );
|
| 320 | clock_t loadTime = clock();
|
| 321 | int errorID = doc->ErrorID();
|
| 322 | delete doc; doc = 0;
|
| 323 | clock_t deleteTime = clock();
|
| 324 |
|
| 325 | printf( "Test file '%s' loaded. ErrorID=%d\n", argv[1], errorID );
|
| 326 | if ( !errorID ) {
|
| 327 | printf( "Load time=%u\n", (unsigned)(loadTime - startTime) );
|
| 328 | printf( "Delete time=%u\n", (unsigned)(deleteTime - loadTime) );
|
| 329 | printf( "Total time=%u\n", (unsigned)(deleteTime - startTime) );
|
| 330 | }
|
| 331 | exit(0);
|
| 332 | }
|
| 333 |
|
| 334 | FILE* fp = fopen( "resources/dream.xml", "r" );
|
| 335 | if ( !fp ) {
|
| 336 | printf( "Error opening test file 'dream.xml'.\n"
|
| 337 | "Is your working directory the same as where \n"
|
| 338 | "the xmltest.cpp and dream.xml file are?\n\n"
|
| 339 | #if defined( _MSC_VER )
|
| 340 | "In windows Visual Studio you may need to set\n"
|
| 341 | "Properties->Debugging->Working Directory to '..'\n"
|
| 342 | #endif
|
| 343 | );
|
| 344 | exit( 1 );
|
| 345 | }
|
| 346 | fclose( fp );
|
| 347 |
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 348 | XMLTest( "Example_1", 0, example_1() );
|
| 349 | XMLTest( "Example_2", 0, example_2() );
|
| 350 | XMLTest( "Example_3", 0, example_3() );
|
| 351 | XMLTest( "Example_4", true, example_4() );
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 352 |
|
| 353 | /* ------ Example 2: Lookup information. ---- */
|
| 354 |
|
| 355 | {
|
| 356 | static const char* test[] = { "<element />",
|
| 357 | "<element></element>",
|
| 358 | "<element><subelement/></element>",
|
| 359 | "<element><subelement></subelement></element>",
|
| 360 | "<element><subelement><subsub/></subelement></element>",
|
| 361 | "<!--comment beside elements--><element><subelement></subelement></element>",
|
| 362 | "<!--comment beside elements, this time with spaces--> \n <element> <subelement> \n </subelement> </element>",
|
| 363 | "<element attrib1='foo' attrib2=\"bar\" ></element>",
|
| 364 | "<element attrib1='foo' attrib2=\"bar\" ><subelement attrib3='yeehaa' /></element>",
|
| 365 | "<element>Text inside element.</element>",
|
| 366 | "<element><b></b></element>",
|
| 367 | "<element>Text inside and <b>bolded</b> in the element.</element>",
|
| 368 | "<outer><element>Text inside and <b>bolded</b> in the element.</element></outer>",
|
| 369 | "<element>This & That.</element>",
|
| 370 | "<element attrib='This<That' />",
|
| 371 | 0
|
| 372 | };
|
| 373 | for( int i=0; test[i]; ++i ) {
|
| 374 | XMLDocument doc;
|
| 375 | doc.Parse( test[i] );
|
| 376 | XMLTest( "Element test", false, doc.Error() );
|
| 377 | doc.Print();
|
| 378 | printf( "----------------------------------------------\n" );
|
| 379 | }
|
| 380 | }
|
| 381 | #if 1
|
| 382 | {
|
| 383 | static const char* test = "<!--hello world\n"
|
| 384 | " line 2\r"
|
| 385 | " line 3\r\n"
|
| 386 | " line 4\n\r"
|
| 387 | " line 5\r-->";
|
| 388 |
|
| 389 | XMLDocument doc;
|
| 390 | doc.Parse( test );
|
| 391 | XMLTest( "Hello world declaration", false, doc.Error() );
|
| 392 | doc.Print();
|
| 393 | }
|
| 394 |
|
| 395 | {
|
| 396 | // This test is pre-test for the next one
|
| 397 | // (where Element1 is inserted "after itself".
|
| 398 | // This code didn't use to crash.
|
| 399 | XMLDocument doc;
|
| 400 | XMLElement* element1 = doc.NewElement("Element1");
|
| 401 | XMLElement* element2 = doc.NewElement("Element2");
|
| 402 | doc.InsertEndChild(element1);
|
| 403 | doc.InsertEndChild(element2);
|
| 404 | doc.InsertAfterChild(element2, element2);
|
| 405 | doc.InsertAfterChild(element2, element2);
|
| 406 | }
|
| 407 |
|
| 408 | {
|
| 409 | XMLDocument doc;
|
| 410 | XMLElement* element1 = doc.NewElement("Element1");
|
| 411 | XMLElement* element2 = doc.NewElement("Element2");
|
| 412 | doc.InsertEndChild(element1);
|
| 413 | doc.InsertEndChild(element2);
|
| 414 |
|
| 415 | // This insertion "after itself"
|
| 416 | // used to cause invalid memory access and crash
|
| 417 | doc.InsertAfterChild(element1, element1);
|
| 418 | doc.InsertAfterChild(element1, element1);
|
| 419 | doc.InsertAfterChild(element2, element2);
|
| 420 | doc.InsertAfterChild(element2, element2);
|
| 421 | }
|
| 422 |
|
| 423 | {
|
| 424 | static const char* test = "<element>Text before.</element>";
|
| 425 | XMLDocument doc;
|
| 426 | doc.Parse( test );
|
| 427 | XMLTest( "Element text before", false, doc.Error() );
|
| 428 | XMLElement* root = doc.FirstChildElement();
|
| 429 | XMLElement* newElement = doc.NewElement( "Subelement" );
|
| 430 | root->InsertEndChild( newElement );
|
| 431 | doc.Print();
|
| 432 | }
|
| 433 | {
|
| 434 | XMLDocument* doc = new XMLDocument();
|
| 435 | static const char* test = "<element><sub/></element>";
|
| 436 | doc->Parse( test );
|
| 437 | XMLTest( "Element with sub element", false, doc->Error() );
|
| 438 | delete doc;
|
| 439 | }
|
| 440 | {
|
| 441 | // Test: Programmatic DOM nodes insertion return values
|
| 442 | XMLDocument doc;
|
| 443 |
|
| 444 | XMLNode* first = doc.NewElement( "firstElement" );
|
| 445 | XMLTest( "New element", true, first != 0 );
|
| 446 | XMLNode* firstAfterInsertion = doc.InsertFirstChild( first );
|
| 447 | XMLTest( "New element inserted first", true, firstAfterInsertion == first );
|
| 448 |
|
| 449 | XMLNode* last = doc.NewElement( "lastElement" );
|
| 450 | XMLTest( "New element", true, last != 0 );
|
| 451 | XMLNode* lastAfterInsertion = doc.InsertEndChild( last );
|
| 452 | XMLTest( "New element inserted last", true, lastAfterInsertion == last );
|
| 453 |
|
| 454 | XMLNode* middle = doc.NewElement( "middleElement" );
|
| 455 | XMLTest( "New element", true, middle != 0 );
|
| 456 | XMLNode* middleAfterInsertion = doc.InsertAfterChild( first, middle );
|
| 457 | XMLTest( "New element inserted middle", true, middleAfterInsertion == middle );
|
| 458 | }
|
| 459 | {
|
| 460 | // Test: Programmatic DOM
|
| 461 | // Build:
|
| 462 | // <element>
|
| 463 | // <!--comment-->
|
| 464 | // <sub attrib="1" />
|
| 465 | // <sub attrib="2" />
|
| 466 | // <sub attrib="3" >& Text!</sub>
|
| 467 | // <element>
|
| 468 |
|
| 469 | XMLDocument* doc = new XMLDocument();
|
| 470 | XMLNode* element = doc->InsertEndChild( doc->NewElement( "element" ) );
|
| 471 |
|
| 472 | XMLElement* sub[3] = { doc->NewElement( "sub" ), doc->NewElement( "sub" ), doc->NewElement( "sub" ) };
|
| 473 | for( int i=0; i<3; ++i ) {
|
| 474 | sub[i]->SetAttribute( "attrib", i );
|
| 475 | }
|
| 476 | element->InsertEndChild( sub[2] );
|
| 477 |
|
| 478 | const int dummyInitialValue = 1000;
|
| 479 | int dummyValue = dummyInitialValue;
|
| 480 |
|
| 481 | XMLNode* comment = element->InsertFirstChild( doc->NewComment( "comment" ) );
|
| 482 | comment->SetUserData(&dummyValue);
|
| 483 | element->InsertAfterChild( comment, sub[0] );
|
| 484 | element->InsertAfterChild( sub[0], sub[1] );
|
| 485 | sub[2]->InsertFirstChild( doc->NewText( "& Text!" ));
|
| 486 | doc->Print();
|
| 487 | XMLTest( "Programmatic DOM", "comment", doc->FirstChildElement( "element" )->FirstChild()->Value() );
|
| 488 | XMLTest( "Programmatic DOM", "0", doc->FirstChildElement( "element" )->FirstChildElement()->Attribute( "attrib" ) );
|
| 489 | XMLTest( "Programmatic DOM", 2, doc->FirstChildElement()->LastChildElement( "sub" )->IntAttribute( "attrib" ) );
|
| 490 | XMLTest( "Programmatic DOM", "& Text!",
|
| 491 | doc->FirstChildElement()->LastChildElement( "sub" )->FirstChild()->ToText()->Value() );
|
| 492 | XMLTest("User data - pointer", true, &dummyValue == comment->GetUserData(), false);
|
| 493 | XMLTest("User data - value behind pointer", dummyInitialValue, dummyValue, false);
|
| 494 |
|
| 495 | // And now deletion:
|
| 496 | element->DeleteChild( sub[2] );
|
| 497 | doc->DeleteNode( comment );
|
| 498 |
|
| 499 | element->FirstChildElement()->SetAttribute( "attrib", true );
|
| 500 | element->LastChildElement()->DeleteAttribute( "attrib" );
|
| 501 |
|
| 502 | XMLTest( "Programmatic DOM", true, doc->FirstChildElement()->FirstChildElement()->BoolAttribute( "attrib" ) );
|
| 503 | const int defaultIntValue = 10;
|
| 504 | const int replacementIntValue = 20;
|
| 505 | int value1 = defaultIntValue;
|
| 506 | int value2 = doc->FirstChildElement()->LastChildElement()->IntAttribute( "attrib", replacementIntValue );
|
| 507 | XMLError result = doc->FirstChildElement()->LastChildElement()->QueryIntAttribute( "attrib", &value1 );
|
| 508 | XMLTest( "Programmatic DOM", XML_NO_ATTRIBUTE, result );
|
| 509 | XMLTest( "Programmatic DOM", defaultIntValue, value1 );
|
| 510 | XMLTest( "Programmatic DOM", replacementIntValue, value2 );
|
| 511 |
|
| 512 | doc->Print();
|
| 513 |
|
| 514 | {
|
| 515 | XMLPrinter streamer;
|
| 516 | doc->Print( &streamer );
|
| 517 | printf( "%s", streamer.CStr() );
|
| 518 | }
|
| 519 | {
|
| 520 | XMLPrinter streamer( 0, true );
|
| 521 | doc->Print( &streamer );
|
| 522 | XMLTest( "Compact mode", "<element><sub attrib=\"true\"/><sub/></element>", streamer.CStr(), false );
|
| 523 | }
|
| 524 | doc->SaveFile( "./resources/out/pretty.xml" );
|
| 525 | XMLTest( "Save pretty.xml", false, doc->Error() );
|
| 526 | doc->SaveFile( "./resources/out/compact.xml", true );
|
| 527 | XMLTest( "Save compact.xml", false, doc->Error() );
|
| 528 | delete doc;
|
| 529 | }
|
| 530 | {
|
| 531 | // Test: Dream
|
| 532 | // XML1 : 1,187,569 bytes in 31,209 allocations
|
| 533 | // XML2 : 469,073 bytes in 323 allocations
|
| 534 | //int newStart = gNew;
|
| 535 | XMLDocument doc;
|
| 536 | doc.LoadFile( "resources/dream.xml" );
|
| 537 | XMLTest( "Load dream.xml", false, doc.Error() );
|
| 538 |
|
| 539 | doc.SaveFile( "resources/out/dreamout.xml" );
|
| 540 | XMLTest( "Save dreamout.xml", false, doc.Error() );
|
| 541 | doc.PrintError();
|
| 542 |
|
| 543 | XMLTest( "Dream", "xml version=\"1.0\"",
|
| 544 | doc.FirstChild()->ToDeclaration()->Value() );
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 545 | XMLTest( "Dream", true, doc.FirstChild()->NextSibling()->ToUnknown() != 0 );
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 546 | XMLTest( "Dream", "DOCTYPE PLAY SYSTEM \"play.dtd\"",
|
| 547 | doc.FirstChild()->NextSibling()->ToUnknown()->Value() );
|
| 548 | XMLTest( "Dream", "And Robin shall restore amends.",
|
| 549 | doc.LastChild()->LastChild()->LastChild()->LastChild()->LastChildElement()->GetText() );
|
| 550 | XMLTest( "Dream", "And Robin shall restore amends.",
|
| 551 | doc.LastChild()->LastChild()->LastChild()->LastChild()->LastChildElement()->GetText() );
|
| 552 |
|
| 553 | XMLDocument doc2;
|
| 554 | doc2.LoadFile( "resources/out/dreamout.xml" );
|
| 555 | XMLTest( "Load dreamout.xml", false, doc2.Error() );
|
| 556 | XMLTest( "Dream-out", "xml version=\"1.0\"",
|
| 557 | doc2.FirstChild()->ToDeclaration()->Value() );
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 558 | XMLTest( "Dream-out", true, doc2.FirstChild()->NextSibling()->ToUnknown() != 0 );
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 559 | XMLTest( "Dream-out", "DOCTYPE PLAY SYSTEM \"play.dtd\"",
|
| 560 | doc2.FirstChild()->NextSibling()->ToUnknown()->Value() );
|
| 561 | XMLTest( "Dream-out", "And Robin shall restore amends.",
|
| 562 | doc2.LastChild()->LastChild()->LastChild()->LastChild()->LastChildElement()->GetText() );
|
| 563 |
|
| 564 | //gNewTotal = gNew - newStart;
|
| 565 | }
|
| 566 |
|
| 567 |
|
| 568 | {
|
| 569 | const char* error = "<?xml version=\"1.0\" standalone=\"no\" ?>\n"
|
| 570 | "<passages count=\"006\" formatversion=\"20020620\">\n"
|
| 571 | " <wrong error>\n"
|
| 572 | "</passages>";
|
| 573 |
|
| 574 | XMLDocument doc;
|
| 575 | doc.Parse( error );
|
| 576 | XMLTest( "Bad XML", XML_ERROR_PARSING_ATTRIBUTE, doc.ErrorID() );
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 577 | const char* errorStr = doc.ErrorStr();
|
| 578 | XMLTest("Formatted error string",
|
| 579 | "Error=XML_ERROR_PARSING_ATTRIBUTE ErrorID=7 (0x7) Line number=3: XMLElement name=wrong",
|
| 580 | errorStr);
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 581 | }
|
| 582 |
|
| 583 | {
|
| 584 | const char* str = "<doc attr0='1' attr1='2.0' attr2='foo' />";
|
| 585 |
|
| 586 | XMLDocument doc;
|
| 587 | doc.Parse( str );
|
| 588 | XMLTest( "Top level attributes", false, doc.Error() );
|
| 589 |
|
| 590 | XMLElement* ele = doc.FirstChildElement();
|
| 591 |
|
| 592 | int iVal;
|
| 593 | XMLError result;
|
| 594 | double dVal;
|
| 595 |
|
| 596 | result = ele->QueryDoubleAttribute( "attr0", &dVal );
|
| 597 | XMLTest( "Query attribute: int as double", XML_SUCCESS, result);
|
| 598 | XMLTest( "Query attribute: int as double", 1, (int)dVal );
|
| 599 | XMLTest( "Query attribute: int as double", 1, (int)ele->DoubleAttribute("attr0"));
|
| 600 |
|
| 601 | result = ele->QueryDoubleAttribute( "attr1", &dVal );
|
| 602 | XMLTest( "Query attribute: double as double", XML_SUCCESS, result);
|
| 603 | XMLTest( "Query attribute: double as double", 2.0, dVal );
|
| 604 | XMLTest( "Query attribute: double as double", 2.0, ele->DoubleAttribute("attr1") );
|
| 605 |
|
| 606 | result = ele->QueryIntAttribute( "attr1", &iVal );
|
| 607 | XMLTest( "Query attribute: double as int", XML_SUCCESS, result);
|
| 608 | XMLTest( "Query attribute: double as int", 2, iVal );
|
| 609 |
|
| 610 | result = ele->QueryIntAttribute( "attr2", &iVal );
|
| 611 | XMLTest( "Query attribute: not a number", XML_WRONG_ATTRIBUTE_TYPE, result );
|
| 612 | XMLTest( "Query attribute: not a number", 4.0, ele->DoubleAttribute("attr2", 4.0) );
|
| 613 |
|
| 614 | result = ele->QueryIntAttribute( "bar", &iVal );
|
| 615 | XMLTest( "Query attribute: does not exist", XML_NO_ATTRIBUTE, result );
|
| 616 | XMLTest( "Query attribute: does not exist", true, ele->BoolAttribute("bar", true) );
|
| 617 | }
|
| 618 |
|
| 619 | {
|
| 620 | const char* str = "<doc/>";
|
| 621 |
|
| 622 | XMLDocument doc;
|
| 623 | doc.Parse( str );
|
| 624 | XMLTest( "Empty top element", false, doc.Error() );
|
| 625 |
|
| 626 | XMLElement* ele = doc.FirstChildElement();
|
| 627 |
|
| 628 | int iVal, iVal2;
|
| 629 | double dVal, dVal2;
|
| 630 |
|
| 631 | ele->SetAttribute( "str", "strValue" );
|
| 632 | ele->SetAttribute( "int", 1 );
|
| 633 | ele->SetAttribute( "double", -1.0 );
|
| 634 |
|
| 635 | const char* cStr = ele->Attribute( "str" );
|
| 636 | {
|
| 637 | XMLError queryResult = ele->QueryIntAttribute( "int", &iVal );
|
| 638 | XMLTest( "Query int attribute", XML_SUCCESS, queryResult);
|
| 639 | }
|
| 640 | {
|
| 641 | XMLError queryResult = ele->QueryDoubleAttribute( "double", &dVal );
|
| 642 | XMLTest( "Query double attribute", XML_SUCCESS, queryResult);
|
| 643 | }
|
| 644 |
|
| 645 | {
|
| 646 | int queryResult = ele->QueryAttribute( "int", &iVal2 );
|
| 647 | XMLTest( "Query int attribute generic", (int)XML_SUCCESS, queryResult);
|
| 648 | }
|
| 649 | {
|
| 650 | int queryResult = ele->QueryAttribute( "double", &dVal2 );
|
| 651 | XMLTest( "Query double attribute generic", (int)XML_SUCCESS, queryResult);
|
| 652 | }
|
| 653 |
|
| 654 | XMLTest( "Attribute match test", "strValue", ele->Attribute( "str", "strValue" ) );
|
| 655 | XMLTest( "Attribute round trip. c-string.", "strValue", cStr );
|
| 656 | XMLTest( "Attribute round trip. int.", 1, iVal );
|
| 657 | XMLTest( "Attribute round trip. double.", -1, (int)dVal );
|
| 658 | XMLTest( "Alternate query", true, iVal == iVal2 );
|
| 659 | XMLTest( "Alternate query", true, dVal == dVal2 );
|
| 660 | XMLTest( "Alternate query", true, iVal == ele->IntAttribute("int") );
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 661 | XMLTest( "Alternate query", true, dVal == ele->DoubleAttribute("double") );
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 662 | }
|
| 663 |
|
| 664 | {
|
| 665 | XMLDocument doc;
|
| 666 | doc.LoadFile( "resources/utf8test.xml" );
|
| 667 | XMLTest( "Load utf8test.xml", false, doc.Error() );
|
| 668 |
|
| 669 | // Get the attribute "value" from the "Russian" element and check it.
|
| 670 | XMLElement* element = doc.FirstChildElement( "document" )->FirstChildElement( "Russian" );
|
| 671 | const unsigned char correctValue[] = { 0xd1U, 0x86U, 0xd0U, 0xb5U, 0xd0U, 0xbdU, 0xd0U, 0xbdU,
|
| 672 | 0xd0U, 0xbeU, 0xd1U, 0x81U, 0xd1U, 0x82U, 0xd1U, 0x8cU, 0 };
|
| 673 |
|
| 674 | XMLTest( "UTF-8: Russian value.", (const char*)correctValue, element->Attribute( "value" ) );
|
| 675 |
|
| 676 | const unsigned char russianElementName[] = { 0xd0U, 0xa0U, 0xd1U, 0x83U,
|
| 677 | 0xd1U, 0x81U, 0xd1U, 0x81U,
|
| 678 | 0xd0U, 0xbaU, 0xd0U, 0xb8U,
|
| 679 | 0xd0U, 0xb9U, 0 };
|
| 680 | const char russianText[] = "<\xD0\xB8\xD0\xBC\xD0\xB5\xD0\xB5\xD1\x82>";
|
| 681 |
|
| 682 | XMLText* text = doc.FirstChildElement( "document" )->FirstChildElement( (const char*) russianElementName )->FirstChild()->ToText();
|
| 683 | XMLTest( "UTF-8: Browsing russian element name.",
|
| 684 | russianText,
|
| 685 | text->Value() );
|
| 686 |
|
| 687 | // Now try for a round trip.
|
| 688 | doc.SaveFile( "resources/out/utf8testout.xml" );
|
| 689 | XMLTest( "UTF-8: Save testout.xml", false, doc.Error() );
|
| 690 |
|
| 691 | // Check the round trip.
|
| 692 | bool roundTripOkay = false;
|
| 693 |
|
| 694 | FILE* saved = fopen( "resources/out/utf8testout.xml", "r" );
|
| 695 | XMLTest( "UTF-8: Open utf8testout.xml", true, saved != 0 );
|
| 696 |
|
| 697 | FILE* verify = fopen( "resources/utf8testverify.xml", "r" );
|
| 698 | XMLTest( "UTF-8: Open utf8testverify.xml", true, verify != 0 );
|
| 699 |
|
| 700 | if ( saved && verify )
|
| 701 | {
|
| 702 | roundTripOkay = true;
|
| 703 | char verifyBuf[256];
|
| 704 | while ( fgets( verifyBuf, 256, verify ) )
|
| 705 | {
|
| 706 | char savedBuf[256];
|
| 707 | fgets( savedBuf, 256, saved );
|
| 708 | NullLineEndings( verifyBuf );
|
| 709 | NullLineEndings( savedBuf );
|
| 710 |
|
| 711 | if ( strcmp( verifyBuf, savedBuf ) )
|
| 712 | {
|
| 713 | printf( "verify:%s<\n", verifyBuf );
|
| 714 | printf( "saved :%s<\n", savedBuf );
|
| 715 | roundTripOkay = false;
|
| 716 | break;
|
| 717 | }
|
| 718 | }
|
| 719 | }
|
| 720 | if ( saved )
|
| 721 | fclose( saved );
|
| 722 | if ( verify )
|
| 723 | fclose( verify );
|
| 724 | XMLTest( "UTF-8: Verified multi-language round trip.", true, roundTripOkay );
|
| 725 | }
|
| 726 |
|
| 727 | // --------GetText()-----------
|
| 728 | {
|
| 729 | const char* str = "<foo>This is text</foo>";
|
| 730 | XMLDocument doc;
|
| 731 | doc.Parse( str );
|
| 732 | XMLTest( "Double whitespace", false, doc.Error() );
|
| 733 | const XMLElement* element = doc.RootElement();
|
| 734 |
|
| 735 | XMLTest( "GetText() normal use.", "This is text", element->GetText() );
|
| 736 |
|
| 737 | str = "<foo><b>This is text</b></foo>";
|
| 738 | doc.Parse( str );
|
| 739 | XMLTest( "Bold text simulation", false, doc.Error() );
|
| 740 | element = doc.RootElement();
|
| 741 |
|
| 742 | XMLTest( "GetText() contained element.", element->GetText() == 0, true );
|
| 743 | }
|
| 744 |
|
| 745 |
|
| 746 | // --------SetText()-----------
|
| 747 | {
|
| 748 | const char* str = "<foo></foo>";
|
| 749 | XMLDocument doc;
|
| 750 | doc.Parse( str );
|
| 751 | XMLTest( "Empty closed element", false, doc.Error() );
|
| 752 | XMLElement* element = doc.RootElement();
|
| 753 |
|
| 754 | element->SetText("darkness.");
|
| 755 | XMLTest( "SetText() normal use (open/close).", "darkness.", element->GetText() );
|
| 756 |
|
| 757 | element->SetText("blue flame.");
|
| 758 | XMLTest( "SetText() replace.", "blue flame.", element->GetText() );
|
| 759 |
|
| 760 | str = "<foo/>";
|
| 761 | doc.Parse( str );
|
| 762 | XMLTest( "Empty self-closed element", false, doc.Error() );
|
| 763 | element = doc.RootElement();
|
| 764 |
|
| 765 | element->SetText("The driver");
|
| 766 | XMLTest( "SetText() normal use. (self-closing)", "The driver", element->GetText() );
|
| 767 |
|
| 768 | element->SetText("<b>horses</b>");
|
| 769 | XMLTest( "SetText() replace with tag-like text.", "<b>horses</b>", element->GetText() );
|
| 770 | //doc.Print();
|
| 771 |
|
| 772 | str = "<foo><bar>Text in nested element</bar></foo>";
|
| 773 | doc.Parse( str );
|
| 774 | XMLTest( "Text in nested element", false, doc.Error() );
|
| 775 | element = doc.RootElement();
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 776 |
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 777 | element->SetText("wolves");
|
| 778 | XMLTest( "SetText() prefix to nested non-text children.", "wolves", element->GetText() );
|
| 779 |
|
| 780 | str = "<foo/>";
|
| 781 | doc.Parse( str );
|
| 782 | XMLTest( "Empty self-closed element round 2", false, doc.Error() );
|
| 783 | element = doc.RootElement();
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 784 |
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 785 | element->SetText( "str" );
|
| 786 | XMLTest( "SetText types", "str", element->GetText() );
|
| 787 |
|
| 788 | element->SetText( 1 );
|
| 789 | XMLTest( "SetText types", "1", element->GetText() );
|
| 790 |
|
| 791 | element->SetText( 1U );
|
| 792 | XMLTest( "SetText types", "1", element->GetText() );
|
| 793 |
|
| 794 | element->SetText( true );
|
| 795 | XMLTest( "SetText types", "true", element->GetText() );
|
| 796 |
|
| 797 | element->SetText( 1.5f );
|
| 798 | XMLTest( "SetText types", "1.5", element->GetText() );
|
| 799 |
|
| 800 | element->SetText( 1.5 );
|
| 801 | XMLTest( "SetText types", "1.5", element->GetText() );
|
| 802 | }
|
| 803 |
|
| 804 | // ---------- Attributes ---------
|
| 805 | {
|
| 806 | static const int64_t BIG = -123456789012345678;
|
| 807 | XMLDocument doc;
|
| 808 | XMLElement* element = doc.NewElement("element");
|
| 809 | doc.InsertFirstChild(element);
|
| 810 |
|
| 811 | {
|
| 812 | element->SetAttribute("attrib", int(-100));
|
| 813 | {
|
| 814 | int v = 0;
|
| 815 | XMLError queryResult = element->QueryIntAttribute("attrib", &v);
|
| 816 | XMLTest("Attribute: int", XML_SUCCESS, queryResult, true);
|
| 817 | XMLTest("Attribute: int", -100, v, true);
|
| 818 | }
|
| 819 | {
|
| 820 | int v = 0;
|
| 821 | int queryResult = element->QueryAttribute("attrib", &v);
|
| 822 | XMLTest("Attribute: int", (int)XML_SUCCESS, queryResult, true);
|
| 823 | XMLTest("Attribute: int", -100, v, true);
|
| 824 | }
|
| 825 | XMLTest("Attribute: int", -100, element->IntAttribute("attrib"), true);
|
| 826 | }
|
| 827 | {
|
| 828 | element->SetAttribute("attrib", unsigned(100));
|
| 829 | {
|
| 830 | unsigned v = 0;
|
| 831 | XMLError queryResult = element->QueryUnsignedAttribute("attrib", &v);
|
| 832 | XMLTest("Attribute: unsigned", XML_SUCCESS, queryResult, true);
|
| 833 | XMLTest("Attribute: unsigned", unsigned(100), v, true);
|
| 834 | }
|
| 835 | {
|
| 836 | unsigned v = 0;
|
| 837 | int queryResult = element->QueryAttribute("attrib", &v);
|
| 838 | XMLTest("Attribute: unsigned", (int)XML_SUCCESS, queryResult, true);
|
| 839 | XMLTest("Attribute: unsigned", unsigned(100), v, true);
|
| 840 | }
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 841 | {
|
| 842 | const char* v = "failed";
|
| 843 | XMLError queryResult = element->QueryStringAttribute("not-attrib", &v);
|
| 844 | XMLTest("Attribute: string default", false, queryResult == XML_SUCCESS);
|
| 845 | queryResult = element->QueryStringAttribute("attrib", &v);
|
| 846 | XMLTest("Attribute: string", XML_SUCCESS, queryResult, true);
|
| 847 | XMLTest("Attribute: string", "100", v);
|
| 848 | }
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 849 | XMLTest("Attribute: unsigned", unsigned(100), element->UnsignedAttribute("attrib"), true);
|
| 850 | }
|
| 851 | {
|
| 852 | element->SetAttribute("attrib", BIG);
|
| 853 | {
|
| 854 | int64_t v = 0;
|
| 855 | XMLError queryResult = element->QueryInt64Attribute("attrib", &v);
|
| 856 | XMLTest("Attribute: int64_t", XML_SUCCESS, queryResult, true);
|
| 857 | XMLTest("Attribute: int64_t", BIG, v, true);
|
| 858 | }
|
| 859 | {
|
| 860 | int64_t v = 0;
|
| 861 | int queryResult = element->QueryAttribute("attrib", &v);
|
| 862 | XMLTest("Attribute: int64_t", (int)XML_SUCCESS, queryResult, true);
|
| 863 | XMLTest("Attribute: int64_t", BIG, v, true);
|
| 864 | }
|
| 865 | XMLTest("Attribute: int64_t", BIG, element->Int64Attribute("attrib"), true);
|
| 866 | }
|
| 867 | {
|
| 868 | element->SetAttribute("attrib", true);
|
| 869 | {
|
| 870 | bool v = false;
|
| 871 | XMLError queryResult = element->QueryBoolAttribute("attrib", &v);
|
| 872 | XMLTest("Attribute: bool", XML_SUCCESS, queryResult, true);
|
| 873 | XMLTest("Attribute: bool", true, v, true);
|
| 874 | }
|
| 875 | {
|
| 876 | bool v = false;
|
| 877 | int queryResult = element->QueryAttribute("attrib", &v);
|
| 878 | XMLTest("Attribute: bool", (int)XML_SUCCESS, queryResult, true);
|
| 879 | XMLTest("Attribute: bool", true, v, true);
|
| 880 | }
|
| 881 | XMLTest("Attribute: bool", true, element->BoolAttribute("attrib"), true);
|
| 882 | }
|
| 883 | {
|
| 884 | element->SetAttribute("attrib", true);
|
| 885 | const char* result = element->Attribute("attrib");
|
| 886 | XMLTest("Bool true is 'true'", "true", result);
|
| 887 |
|
| 888 | XMLUtil::SetBoolSerialization("1", "0");
|
| 889 | element->SetAttribute("attrib", true);
|
| 890 | result = element->Attribute("attrib");
|
| 891 | XMLTest("Bool true is '1'", "1", result);
|
| 892 |
|
| 893 | XMLUtil::SetBoolSerialization(0, 0);
|
| 894 | }
|
| 895 | {
|
| 896 | element->SetAttribute("attrib", 100.0);
|
| 897 | {
|
| 898 | double v = 0;
|
| 899 | XMLError queryResult = element->QueryDoubleAttribute("attrib", &v);
|
| 900 | XMLTest("Attribute: double", XML_SUCCESS, queryResult, true);
|
| 901 | XMLTest("Attribute: double", 100.0, v, true);
|
| 902 | }
|
| 903 | {
|
| 904 | double v = 0;
|
| 905 | int queryResult = element->QueryAttribute("attrib", &v);
|
| 906 | XMLTest("Attribute: bool", (int)XML_SUCCESS, queryResult, true);
|
| 907 | XMLTest("Attribute: double", 100.0, v, true);
|
| 908 | }
|
| 909 | XMLTest("Attribute: double", 100.0, element->DoubleAttribute("attrib"), true);
|
| 910 | }
|
| 911 | {
|
| 912 | element->SetAttribute("attrib", 100.0f);
|
| 913 | {
|
| 914 | float v = 0;
|
| 915 | XMLError queryResult = element->QueryFloatAttribute("attrib", &v);
|
| 916 | XMLTest("Attribute: float", XML_SUCCESS, queryResult, true);
|
| 917 | XMLTest("Attribute: float", 100.0f, v, true);
|
| 918 | }
|
| 919 | {
|
| 920 | float v = 0;
|
| 921 | int queryResult = element->QueryAttribute("attrib", &v);
|
| 922 | XMLTest("Attribute: float", (int)XML_SUCCESS, queryResult, true);
|
| 923 | XMLTest("Attribute: float", 100.0f, v, true);
|
| 924 | }
|
| 925 | XMLTest("Attribute: float", 100.0f, element->FloatAttribute("attrib"), true);
|
| 926 | }
|
| 927 | {
|
| 928 | element->SetText(BIG);
|
| 929 | int64_t v = 0;
|
| 930 | XMLError queryResult = element->QueryInt64Text(&v);
|
| 931 | XMLTest("Element: int64_t", XML_SUCCESS, queryResult, true);
|
| 932 | XMLTest("Element: int64_t", BIG, v, true);
|
| 933 | }
|
| 934 | }
|
| 935 |
|
| 936 | // ---------- XMLPrinter stream mode ------
|
| 937 | {
|
| 938 | {
|
| 939 | FILE* printerfp = fopen("resources/out/printer.xml", "w");
|
| 940 | XMLTest("Open printer.xml", true, printerfp != 0);
|
| 941 | XMLPrinter printer(printerfp);
|
| 942 | printer.OpenElement("foo");
|
| 943 | printer.PushAttribute("attrib-text", "text");
|
| 944 | printer.PushAttribute("attrib-int", int(1));
|
| 945 | printer.PushAttribute("attrib-unsigned", unsigned(2));
|
| 946 | printer.PushAttribute("attrib-int64", int64_t(3));
|
| 947 | printer.PushAttribute("attrib-bool", true);
|
| 948 | printer.PushAttribute("attrib-double", 4.0);
|
| 949 | printer.CloseElement();
|
| 950 | fclose(printerfp);
|
| 951 | }
|
| 952 | {
|
| 953 | XMLDocument doc;
|
| 954 | doc.LoadFile("resources/out/printer.xml");
|
| 955 | XMLTest("XMLPrinter Stream mode: load", XML_SUCCESS, doc.ErrorID(), true);
|
| 956 |
|
| 957 | const XMLDocument& cdoc = doc;
|
| 958 |
|
| 959 | const XMLAttribute* attrib = cdoc.FirstChildElement("foo")->FindAttribute("attrib-text");
|
| 960 | XMLTest("attrib-text", "text", attrib->Value(), true);
|
| 961 | attrib = cdoc.FirstChildElement("foo")->FindAttribute("attrib-int");
|
| 962 | XMLTest("attrib-int", int(1), attrib->IntValue(), true);
|
| 963 | attrib = cdoc.FirstChildElement("foo")->FindAttribute("attrib-unsigned");
|
| 964 | XMLTest("attrib-unsigned", unsigned(2), attrib->UnsignedValue(), true);
|
| 965 | attrib = cdoc.FirstChildElement("foo")->FindAttribute("attrib-int64");
|
| 966 | XMLTest("attrib-int64", int64_t(3), attrib->Int64Value(), true);
|
| 967 | attrib = cdoc.FirstChildElement("foo")->FindAttribute("attrib-bool");
|
| 968 | XMLTest("attrib-bool", true, attrib->BoolValue(), true);
|
| 969 | attrib = cdoc.FirstChildElement("foo")->FindAttribute("attrib-double");
|
| 970 | XMLTest("attrib-double", 4.0, attrib->DoubleValue(), true);
|
| 971 | }
|
| 972 |
|
| 973 | }
|
| 974 |
|
| 975 |
|
| 976 | // ---------- CDATA ---------------
|
| 977 | {
|
| 978 | const char* str = "<xmlElement>"
|
| 979 | "<![CDATA["
|
| 980 | "I am > the rules!\n"
|
| 981 | "...since I make symbolic puns"
|
| 982 | "]]>"
|
| 983 | "</xmlElement>";
|
| 984 | XMLDocument doc;
|
| 985 | doc.Parse( str );
|
| 986 | XMLTest( "CDATA symbolic puns round 1", false, doc.Error() );
|
| 987 | doc.Print();
|
| 988 |
|
| 989 | XMLTest( "CDATA parse.", "I am > the rules!\n...since I make symbolic puns",
|
| 990 | doc.FirstChildElement()->FirstChild()->Value(),
|
| 991 | false );
|
| 992 | }
|
| 993 |
|
| 994 | // ----------- CDATA -------------
|
| 995 | {
|
| 996 | const char* str = "<xmlElement>"
|
| 997 | "<![CDATA["
|
| 998 | "<b>I am > the rules!</b>\n"
|
| 999 | "...since I make symbolic puns"
|
| 1000 | "]]>"
|
| 1001 | "</xmlElement>";
|
| 1002 | XMLDocument doc;
|
| 1003 | doc.Parse( str );
|
| 1004 | XMLTest( "CDATA symbolic puns round 2", false, doc.Error() );
|
| 1005 | doc.Print();
|
| 1006 |
|
| 1007 | XMLTest( "CDATA parse. [ tixml1:1480107 ]",
|
| 1008 | "<b>I am > the rules!</b>\n...since I make symbolic puns",
|
| 1009 | doc.FirstChildElement()->FirstChild()->Value(),
|
| 1010 | false );
|
| 1011 | }
|
| 1012 |
|
| 1013 | // InsertAfterChild causes crash.
|
| 1014 | {
|
| 1015 | // InsertBeforeChild and InsertAfterChild causes crash.
|
| 1016 | XMLDocument doc;
|
| 1017 | XMLElement* parent = doc.NewElement( "Parent" );
|
| 1018 | doc.InsertFirstChild( parent );
|
| 1019 |
|
| 1020 | XMLElement* childText0 = doc.NewElement( "childText0" );
|
| 1021 | XMLElement* childText1 = doc.NewElement( "childText1" );
|
| 1022 |
|
| 1023 | XMLNode* childNode0 = parent->InsertEndChild( childText0 );
|
| 1024 | XMLTest( "InsertEndChild() return", true, childNode0 == childText0 );
|
| 1025 | XMLNode* childNode1 = parent->InsertAfterChild( childNode0, childText1 );
|
| 1026 | XMLTest( "InsertAfterChild() return", true, childNode1 == childText1 );
|
| 1027 |
|
| 1028 | XMLTest( "Test InsertAfterChild on empty node. ", true, ( childNode1 == parent->LastChild() ) );
|
| 1029 | }
|
| 1030 |
|
| 1031 | {
|
| 1032 | // Entities not being written correctly.
|
| 1033 | // From Lynn Allen
|
| 1034 |
|
| 1035 | const char* passages =
|
| 1036 | "<?xml version=\"1.0\" standalone=\"no\" ?>"
|
| 1037 | "<passages count=\"006\" formatversion=\"20020620\">"
|
| 1038 | "<psg context=\"Line 5 has "quotation marks" and 'apostrophe marks'."
|
| 1039 | " It also has <, >, and &, as well as a fake copyright ©.\"> </psg>"
|
| 1040 | "</passages>";
|
| 1041 |
|
| 1042 | XMLDocument doc;
|
| 1043 | doc.Parse( passages );
|
| 1044 | XMLTest( "Entity transformation parse round 1", false, doc.Error() );
|
| 1045 | XMLElement* psg = doc.RootElement()->FirstChildElement();
|
| 1046 | const char* context = psg->Attribute( "context" );
|
| 1047 | const char* expected = "Line 5 has \"quotation marks\" and 'apostrophe marks'. It also has <, >, and &, as well as a fake copyright \xC2\xA9.";
|
| 1048 |
|
| 1049 | XMLTest( "Entity transformation: read. ", expected, context, true );
|
| 1050 |
|
| 1051 | const char* textFilePath = "resources/out/textfile.txt";
|
| 1052 | FILE* textfile = fopen( textFilePath, "w" );
|
| 1053 | XMLTest( "Entity transformation: open text file for writing", true, textfile != 0, true );
|
| 1054 | if ( textfile )
|
| 1055 | {
|
| 1056 | XMLPrinter streamer( textfile );
|
| 1057 | bool acceptResult = psg->Accept( &streamer );
|
| 1058 | fclose( textfile );
|
| 1059 | XMLTest( "Entity transformation: Accept", true, acceptResult );
|
| 1060 | }
|
| 1061 |
|
| 1062 | textfile = fopen( textFilePath, "r" );
|
| 1063 | XMLTest( "Entity transformation: open text file for reading", true, textfile != 0, true );
|
| 1064 | if ( textfile )
|
| 1065 | {
|
| 1066 | char buf[ 1024 ];
|
| 1067 | fgets( buf, 1024, textfile );
|
| 1068 | XMLTest( "Entity transformation: write. ",
|
| 1069 | "<psg context=\"Line 5 has "quotation marks" and 'apostrophe marks'."
|
| 1070 | " It also has <, >, and &, as well as a fake copyright \xC2\xA9.\"/>\n",
|
| 1071 | buf, false );
|
| 1072 | fclose( textfile );
|
| 1073 | }
|
| 1074 | }
|
| 1075 |
|
| 1076 | {
|
| 1077 | // Suppress entities.
|
| 1078 | const char* passages =
|
| 1079 | "<?xml version=\"1.0\" standalone=\"no\" ?>"
|
| 1080 | "<passages count=\"006\" formatversion=\"20020620\">"
|
| 1081 | "<psg context=\"Line 5 has "quotation marks" and 'apostrophe marks'.\">Crazy &ttk;</psg>"
|
| 1082 | "</passages>";
|
| 1083 |
|
| 1084 | XMLDocument doc( false );
|
| 1085 | doc.Parse( passages );
|
| 1086 | XMLTest( "Entity transformation parse round 2", false, doc.Error() );
|
| 1087 |
|
| 1088 | XMLTest( "No entity parsing.",
|
| 1089 | "Line 5 has "quotation marks" and 'apostrophe marks'.",
|
| 1090 | doc.FirstChildElement()->FirstChildElement()->Attribute( "context" ) );
|
| 1091 | XMLTest( "No entity parsing.", "Crazy &ttk;",
|
| 1092 | doc.FirstChildElement()->FirstChildElement()->FirstChild()->Value() );
|
| 1093 | doc.Print();
|
| 1094 | }
|
| 1095 |
|
| 1096 | {
|
| 1097 | const char* test = "<?xml version='1.0'?><a.elem xmi.version='2.0'/>";
|
| 1098 |
|
| 1099 | XMLDocument doc;
|
| 1100 | doc.Parse( test );
|
| 1101 | XMLTest( "dot in names", false, doc.Error() );
|
| 1102 | XMLTest( "dot in names", "a.elem", doc.FirstChildElement()->Name() );
|
| 1103 | XMLTest( "dot in names", "2.0", doc.FirstChildElement()->Attribute( "xmi.version" ) );
|
| 1104 | }
|
| 1105 |
|
| 1106 | {
|
| 1107 | const char* test = "<element><Name>1.1 Start easy ignore fin thickness
</Name></element>";
|
| 1108 |
|
| 1109 | XMLDocument doc;
|
| 1110 | doc.Parse( test );
|
| 1111 | XMLTest( "fin thickness", false, doc.Error() );
|
| 1112 |
|
| 1113 | XMLText* text = doc.FirstChildElement()->FirstChildElement()->FirstChild()->ToText();
|
| 1114 | XMLTest( "Entity with one digit.",
|
| 1115 | "1.1 Start easy ignore fin thickness\n", text->Value(),
|
| 1116 | false );
|
| 1117 | }
|
| 1118 |
|
| 1119 | {
|
| 1120 | // DOCTYPE not preserved (950171)
|
| 1121 | //
|
| 1122 | const char* doctype =
|
| 1123 | "<?xml version=\"1.0\" ?>"
|
| 1124 | "<!DOCTYPE PLAY SYSTEM 'play.dtd'>"
|
| 1125 | "<!ELEMENT title (#PCDATA)>"
|
| 1126 | "<!ELEMENT books (title,authors)>"
|
| 1127 | "<element />";
|
| 1128 |
|
| 1129 | XMLDocument doc;
|
| 1130 | doc.Parse( doctype );
|
| 1131 | XMLTest( "PLAY SYSTEM parse", false, doc.Error() );
|
| 1132 | doc.SaveFile( "resources/out/test7.xml" );
|
| 1133 | XMLTest( "PLAY SYSTEM save", false, doc.Error() );
|
| 1134 | doc.DeleteChild( doc.RootElement() );
|
| 1135 | doc.LoadFile( "resources/out/test7.xml" );
|
| 1136 | XMLTest( "PLAY SYSTEM load", false, doc.Error() );
|
| 1137 | doc.Print();
|
| 1138 |
|
| 1139 | const XMLUnknown* decl = doc.FirstChild()->NextSibling()->ToUnknown();
|
| 1140 | XMLTest( "Correct value of unknown.", "DOCTYPE PLAY SYSTEM 'play.dtd'", decl->Value() );
|
| 1141 |
|
| 1142 | }
|
| 1143 |
|
| 1144 | {
|
| 1145 | // Comments do not stream out correctly.
|
| 1146 | const char* doctype =
|
| 1147 | "<!-- Somewhat<evil> -->";
|
| 1148 | XMLDocument doc;
|
| 1149 | doc.Parse( doctype );
|
| 1150 | XMLTest( "Comment somewhat evil", false, doc.Error() );
|
| 1151 |
|
| 1152 | XMLComment* comment = doc.FirstChild()->ToComment();
|
| 1153 |
|
| 1154 | XMLTest( "Comment formatting.", " Somewhat<evil> ", comment->Value() );
|
| 1155 | }
|
| 1156 | {
|
| 1157 | // Double attributes
|
| 1158 | const char* doctype = "<element attr='red' attr='blue' />";
|
| 1159 |
|
| 1160 | XMLDocument doc;
|
| 1161 | doc.Parse( doctype );
|
| 1162 |
|
| 1163 | XMLTest( "Parsing repeated attributes.", XML_ERROR_PARSING_ATTRIBUTE, doc.ErrorID() ); // is an error to tinyxml (didn't use to be, but caused issues)
|
| 1164 | doc.PrintError();
|
| 1165 | }
|
| 1166 |
|
| 1167 | {
|
| 1168 | // Embedded null in stream.
|
| 1169 | const char* doctype = "<element att\0r='red' attr='blue' />";
|
| 1170 |
|
| 1171 | XMLDocument doc;
|
| 1172 | doc.Parse( doctype );
|
| 1173 | XMLTest( "Embedded null throws error.", true, doc.Error() );
|
| 1174 | }
|
| 1175 |
|
| 1176 | {
|
| 1177 | // Empty documents should return TIXML_XML_ERROR_PARSING_EMPTY, bug 1070717
|
| 1178 | const char* str = "";
|
| 1179 | XMLDocument doc;
|
| 1180 | doc.Parse( str );
|
| 1181 | XMLTest( "Empty document error", XML_ERROR_EMPTY_DOCUMENT, doc.ErrorID() );
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1182 |
|
| 1183 | // But be sure there is an error string!
|
| 1184 | const char* errorStr = doc.ErrorStr();
|
| 1185 | XMLTest("Error string should be set",
|
| 1186 | "Error=XML_ERROR_EMPTY_DOCUMENT ErrorID=13 (0xd) Line number=0",
|
| 1187 | errorStr);
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1188 | }
|
| 1189 |
|
| 1190 | {
|
| 1191 | // Documents with all whitespaces should return TIXML_XML_ERROR_PARSING_EMPTY, bug 1070717
|
| 1192 | const char* str = " ";
|
| 1193 | XMLDocument doc;
|
| 1194 | doc.Parse( str );
|
| 1195 | XMLTest( "All whitespaces document error", XML_ERROR_EMPTY_DOCUMENT, doc.ErrorID() );
|
| 1196 | }
|
| 1197 |
|
| 1198 | {
|
| 1199 | // Low entities
|
| 1200 | XMLDocument doc;
|
| 1201 | doc.Parse( "<test></test>" );
|
| 1202 | XMLTest( "Hex values", false, doc.Error() );
|
| 1203 | const char result[] = { 0x0e, 0 };
|
| 1204 | XMLTest( "Low entities.", result, doc.FirstChildElement()->GetText() );
|
| 1205 | doc.Print();
|
| 1206 | }
|
| 1207 |
|
| 1208 | {
|
| 1209 | // Attribute values with trailing quotes not handled correctly
|
| 1210 | XMLDocument doc;
|
| 1211 | doc.Parse( "<foo attribute=bar\" />" );
|
| 1212 | XMLTest( "Throw error with bad end quotes.", true, doc.Error() );
|
| 1213 | }
|
| 1214 |
|
| 1215 | {
|
| 1216 | // [ 1663758 ] Failure to report error on bad XML
|
| 1217 | XMLDocument xml;
|
| 1218 | xml.Parse("<x>");
|
| 1219 | XMLTest("Missing end tag at end of input", true, xml.Error());
|
| 1220 | xml.Parse("<x> ");
|
| 1221 | XMLTest("Missing end tag with trailing whitespace", true, xml.Error());
|
| 1222 | xml.Parse("<x></y>");
|
| 1223 | XMLTest("Mismatched tags", XML_ERROR_MISMATCHED_ELEMENT, xml.ErrorID() );
|
| 1224 | }
|
| 1225 |
|
| 1226 |
|
| 1227 | {
|
| 1228 | // [ 1475201 ] TinyXML parses entities in comments
|
| 1229 | XMLDocument xml;
|
| 1230 | xml.Parse("<!-- declarations for <head> & <body> -->"
|
| 1231 | "<!-- far & away -->" );
|
| 1232 | XMLTest( "Declarations for head and body", false, xml.Error() );
|
| 1233 |
|
| 1234 | XMLNode* e0 = xml.FirstChild();
|
| 1235 | XMLNode* e1 = e0->NextSibling();
|
| 1236 | XMLComment* c0 = e0->ToComment();
|
| 1237 | XMLComment* c1 = e1->ToComment();
|
| 1238 |
|
| 1239 | XMLTest( "Comments ignore entities.", " declarations for <head> & <body> ", c0->Value(), true );
|
| 1240 | XMLTest( "Comments ignore entities.", " far & away ", c1->Value(), true );
|
| 1241 | }
|
| 1242 |
|
| 1243 | {
|
| 1244 | XMLDocument xml;
|
| 1245 | xml.Parse( "<Parent>"
|
| 1246 | "<child1 att=''/>"
|
| 1247 | "<!-- With this comment, child2 will not be parsed! -->"
|
| 1248 | "<child2 att=''/>"
|
| 1249 | "</Parent>" );
|
| 1250 | XMLTest( "Comments iteration", false, xml.Error() );
|
| 1251 | xml.Print();
|
| 1252 |
|
| 1253 | int count = 0;
|
| 1254 |
|
| 1255 | for( XMLNode* ele = xml.FirstChildElement( "Parent" )->FirstChild();
|
| 1256 | ele;
|
| 1257 | ele = ele->NextSibling() )
|
| 1258 | {
|
| 1259 | ++count;
|
| 1260 | }
|
| 1261 |
|
| 1262 | XMLTest( "Comments iterate correctly.", 3, count );
|
| 1263 | }
|
| 1264 |
|
| 1265 | {
|
| 1266 | // trying to repro ]1874301]. If it doesn't go into an infinite loop, all is well.
|
| 1267 | unsigned char buf[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?><feed><![CDATA[Test XMLblablablalblbl";
|
| 1268 | buf[60] = 239;
|
| 1269 | buf[61] = 0;
|
| 1270 |
|
| 1271 | XMLDocument doc;
|
| 1272 | doc.Parse( (const char*)buf);
|
| 1273 | XMLTest( "Broken CDATA", true, doc.Error() );
|
| 1274 | }
|
| 1275 |
|
| 1276 |
|
| 1277 | {
|
| 1278 | // bug 1827248 Error while parsing a little bit malformed file
|
| 1279 | // Actually not malformed - should work.
|
| 1280 | XMLDocument xml;
|
| 1281 | xml.Parse( "<attributelist> </attributelist >" );
|
| 1282 | XMLTest( "Handle end tag whitespace", false, xml.Error() );
|
| 1283 | }
|
| 1284 |
|
| 1285 | {
|
| 1286 | // This one must not result in an infinite loop
|
| 1287 | XMLDocument xml;
|
| 1288 | xml.Parse( "<infinite>loop" );
|
| 1289 | XMLTest( "No closing element", true, xml.Error() );
|
| 1290 | XMLTest( "Infinite loop test.", true, true );
|
| 1291 | }
|
| 1292 | #endif
|
| 1293 | {
|
| 1294 | const char* pub = "<?xml version='1.0'?> <element><sub/></element> <!--comment--> <!DOCTYPE>";
|
| 1295 | XMLDocument doc;
|
| 1296 | doc.Parse( pub );
|
| 1297 | XMLTest( "Trailing DOCTYPE", false, doc.Error() );
|
| 1298 |
|
| 1299 | XMLDocument clone;
|
| 1300 | for( const XMLNode* node=doc.FirstChild(); node; node=node->NextSibling() ) {
|
| 1301 | XMLNode* copy = node->ShallowClone( &clone );
|
| 1302 | clone.InsertEndChild( copy );
|
| 1303 | }
|
| 1304 |
|
| 1305 | clone.Print();
|
| 1306 |
|
| 1307 | int count=0;
|
| 1308 | const XMLNode* a=clone.FirstChild();
|
| 1309 | const XMLNode* b=doc.FirstChild();
|
| 1310 | for( ; a && b; a=a->NextSibling(), b=b->NextSibling() ) {
|
| 1311 | ++count;
|
| 1312 | XMLTest( "Clone and Equal", true, a->ShallowEqual( b ));
|
| 1313 | }
|
| 1314 | XMLTest( "Clone and Equal", 4, count );
|
| 1315 | }
|
| 1316 |
|
| 1317 | {
|
| 1318 | // Deep Cloning of root element.
|
| 1319 | XMLDocument doc2;
|
| 1320 | XMLPrinter printer1;
|
| 1321 | {
|
| 1322 | // Make sure doc1 is deleted before we test doc2
|
| 1323 | const char* xml =
|
| 1324 | "<root>"
|
| 1325 | " <child1 foo='bar'/>"
|
| 1326 | " <!-- comment thing -->"
|
| 1327 | " <child2 val='1'>Text</child2>"
|
| 1328 | "</root>";
|
| 1329 | XMLDocument doc;
|
| 1330 | doc.Parse(xml);
|
| 1331 | XMLTest( "Parse before deep cloning root element", false, doc.Error() );
|
| 1332 |
|
| 1333 | doc.Print(&printer1);
|
| 1334 | XMLNode* root = doc.RootElement()->DeepClone(&doc2);
|
| 1335 | doc2.InsertFirstChild(root);
|
| 1336 | }
|
| 1337 | XMLPrinter printer2;
|
| 1338 | doc2.Print(&printer2);
|
| 1339 |
|
| 1340 | XMLTest("Deep clone of element.", printer1.CStr(), printer2.CStr(), true);
|
| 1341 | }
|
| 1342 |
|
| 1343 | {
|
| 1344 | // Deep Cloning of sub element.
|
| 1345 | XMLDocument doc2;
|
| 1346 | XMLPrinter printer1;
|
| 1347 | {
|
| 1348 | // Make sure doc1 is deleted before we test doc2
|
| 1349 | const char* xml =
|
| 1350 | "<?xml version ='1.0'?>"
|
| 1351 | "<root>"
|
| 1352 | " <child1 foo='bar'/>"
|
| 1353 | " <!-- comment thing -->"
|
| 1354 | " <child2 val='1'>Text</child2>"
|
| 1355 | "</root>";
|
| 1356 | XMLDocument doc;
|
| 1357 | doc.Parse(xml);
|
| 1358 | XMLTest( "Parse before deep cloning sub element", false, doc.Error() );
|
| 1359 |
|
| 1360 | const XMLElement* subElement = doc.FirstChildElement("root")->FirstChildElement("child2");
|
| 1361 | bool acceptResult = subElement->Accept(&printer1);
|
| 1362 | XMLTest( "Accept before deep cloning", true, acceptResult );
|
| 1363 |
|
| 1364 | XMLNode* clonedSubElement = subElement->DeepClone(&doc2);
|
| 1365 | doc2.InsertFirstChild(clonedSubElement);
|
| 1366 | }
|
| 1367 | XMLPrinter printer2;
|
| 1368 | doc2.Print(&printer2);
|
| 1369 |
|
| 1370 | XMLTest("Deep clone of sub-element.", printer1.CStr(), printer2.CStr(), true);
|
| 1371 | }
|
| 1372 |
|
| 1373 | {
|
| 1374 | // Deep cloning of document.
|
| 1375 | XMLDocument doc2;
|
| 1376 | XMLPrinter printer1;
|
| 1377 | {
|
| 1378 | // Make sure doc1 is deleted before we test doc2
|
| 1379 | const char* xml =
|
| 1380 | "<?xml version ='1.0'?>"
|
| 1381 | "<!-- Top level comment. -->"
|
| 1382 | "<root>"
|
| 1383 | " <child1 foo='bar'/>"
|
| 1384 | " <!-- comment thing -->"
|
| 1385 | " <child2 val='1'>Text</child2>"
|
| 1386 | "</root>";
|
| 1387 | XMLDocument doc;
|
| 1388 | doc.Parse(xml);
|
| 1389 | XMLTest( "Parse before deep cloning document", false, doc.Error() );
|
| 1390 | doc.Print(&printer1);
|
| 1391 |
|
| 1392 | doc.DeepCopy(&doc2);
|
| 1393 | }
|
| 1394 | XMLPrinter printer2;
|
| 1395 | doc2.Print(&printer2);
|
| 1396 |
|
| 1397 | XMLTest("DeepCopy of document.", printer1.CStr(), printer2.CStr(), true);
|
| 1398 | }
|
| 1399 |
|
| 1400 |
|
| 1401 | {
|
| 1402 | // This shouldn't crash.
|
| 1403 | XMLDocument doc;
|
| 1404 | if(XML_SUCCESS != doc.LoadFile( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" ))
|
| 1405 | {
|
| 1406 | doc.PrintError();
|
| 1407 | }
|
| 1408 | XMLTest( "Error in snprinf handling.", true, doc.Error() );
|
| 1409 | }
|
| 1410 |
|
| 1411 | {
|
| 1412 | // Attribute ordering.
|
| 1413 | static const char* xml = "<element attrib1=\"1\" attrib2=\"2\" attrib3=\"3\" />";
|
| 1414 | XMLDocument doc;
|
| 1415 | doc.Parse( xml );
|
| 1416 | XMLTest( "Parse for attribute ordering", false, doc.Error() );
|
| 1417 | XMLElement* ele = doc.FirstChildElement();
|
| 1418 |
|
| 1419 | const XMLAttribute* a = ele->FirstAttribute();
|
| 1420 | XMLTest( "Attribute order", "1", a->Value() );
|
| 1421 | a = a->Next();
|
| 1422 | XMLTest( "Attribute order", "2", a->Value() );
|
| 1423 | a = a->Next();
|
| 1424 | XMLTest( "Attribute order", "3", a->Value() );
|
| 1425 | XMLTest( "Attribute order", "attrib3", a->Name() );
|
| 1426 |
|
| 1427 | ele->DeleteAttribute( "attrib2" );
|
| 1428 | a = ele->FirstAttribute();
|
| 1429 | XMLTest( "Attribute order", "1", a->Value() );
|
| 1430 | a = a->Next();
|
| 1431 | XMLTest( "Attribute order", "3", a->Value() );
|
| 1432 |
|
| 1433 | ele->DeleteAttribute( "attrib1" );
|
| 1434 | ele->DeleteAttribute( "attrib3" );
|
| 1435 | XMLTest( "Attribute order (empty)", true, ele->FirstAttribute() == 0 );
|
| 1436 | }
|
| 1437 |
|
| 1438 | {
|
| 1439 | // Make sure an attribute with a space in it succeeds.
|
| 1440 | static const char* xml0 = "<element attribute1= \"Test Attribute\"/>";
|
| 1441 | static const char* xml1 = "<element attribute1 =\"Test Attribute\"/>";
|
| 1442 | static const char* xml2 = "<element attribute1 = \"Test Attribute\"/>";
|
| 1443 | XMLDocument doc0;
|
| 1444 | doc0.Parse( xml0 );
|
| 1445 | XMLTest( "Parse attribute with space 1", false, doc0.Error() );
|
| 1446 | XMLDocument doc1;
|
| 1447 | doc1.Parse( xml1 );
|
| 1448 | XMLTest( "Parse attribute with space 2", false, doc1.Error() );
|
| 1449 | XMLDocument doc2;
|
| 1450 | doc2.Parse( xml2 );
|
| 1451 | XMLTest( "Parse attribute with space 3", false, doc2.Error() );
|
| 1452 |
|
| 1453 | XMLElement* ele = 0;
|
| 1454 | ele = doc0.FirstChildElement();
|
| 1455 | XMLTest( "Attribute with space #1", "Test Attribute", ele->Attribute( "attribute1" ) );
|
| 1456 | ele = doc1.FirstChildElement();
|
| 1457 | XMLTest( "Attribute with space #2", "Test Attribute", ele->Attribute( "attribute1" ) );
|
| 1458 | ele = doc2.FirstChildElement();
|
| 1459 | XMLTest( "Attribute with space #3", "Test Attribute", ele->Attribute( "attribute1" ) );
|
| 1460 | }
|
| 1461 |
|
| 1462 | {
|
| 1463 | // Make sure we don't go into an infinite loop.
|
| 1464 | static const char* xml = "<doc><element attribute='attribute'/><element attribute='attribute'/></doc>";
|
| 1465 | XMLDocument doc;
|
| 1466 | doc.Parse( xml );
|
| 1467 | XMLTest( "Parse two elements with attribute", false, doc.Error() );
|
| 1468 | XMLElement* ele0 = doc.FirstChildElement()->FirstChildElement();
|
| 1469 | XMLElement* ele1 = ele0->NextSiblingElement();
|
| 1470 | bool equal = ele0->ShallowEqual( ele1 );
|
| 1471 |
|
| 1472 | XMLTest( "Infinite loop in shallow equal.", true, equal );
|
| 1473 | }
|
| 1474 |
|
| 1475 | // -------- Handles ------------
|
| 1476 | {
|
| 1477 | static const char* xml = "<element attrib='bar'><sub>Text</sub></element>";
|
| 1478 | XMLDocument doc;
|
| 1479 | doc.Parse( xml );
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1480 | XMLTest( "Handle, parse element with attribute and nested element", false, doc.Error() );
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1481 |
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1482 | {
|
| 1483 | XMLElement* ele = XMLHandle( doc ).FirstChildElement( "element" ).FirstChild().ToElement();
|
| 1484 | XMLTest( "Handle, non-const, element is found", true, ele != 0 );
|
| 1485 | XMLTest( "Handle, non-const, element name matches", "sub", ele->Value() );
|
| 1486 | }
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1487 |
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1488 | {
|
| 1489 | XMLHandle docH( doc );
|
| 1490 | XMLElement* ele = docH.FirstChildElement( "noSuchElement" ).FirstChildElement( "element" ).ToElement();
|
| 1491 | XMLTest( "Handle, non-const, element not found", true, ele == 0 );
|
| 1492 | }
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1493 |
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1494 | {
|
| 1495 | const XMLElement* ele = XMLConstHandle( doc ).FirstChildElement( "element" ).FirstChild().ToElement();
|
| 1496 | XMLTest( "Handle, const, element is found", true, ele != 0 );
|
| 1497 | XMLTest( "Handle, const, element name matches", "sub", ele->Value() );
|
| 1498 | }
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1499 |
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1500 | {
|
| 1501 | XMLConstHandle docH( doc );
|
| 1502 | const XMLElement* ele = docH.FirstChildElement( "noSuchElement" ).FirstChildElement( "element" ).ToElement();
|
| 1503 | XMLTest( "Handle, const, element not found", true, ele == 0 );
|
| 1504 | }
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1505 | }
|
| 1506 | {
|
| 1507 | // Default Declaration & BOM
|
| 1508 | XMLDocument doc;
|
| 1509 | doc.InsertEndChild( doc.NewDeclaration() );
|
| 1510 | doc.SetBOM( true );
|
| 1511 |
|
| 1512 | XMLPrinter printer;
|
| 1513 | doc.Print( &printer );
|
| 1514 |
|
| 1515 | static const char* result = "\xef\xbb\xbf<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
|
| 1516 | XMLTest( "BOM and default declaration", result, printer.CStr(), false );
|
| 1517 | XMLTest( "CStrSize", 42, printer.CStrSize(), false );
|
| 1518 | }
|
| 1519 | {
|
| 1520 | const char* xml = "<ipxml ws='1'><info bla=' /></ipxml>";
|
| 1521 | XMLDocument doc;
|
| 1522 | doc.Parse( xml );
|
| 1523 | XMLTest( "Ill formed XML", true, doc.Error() );
|
| 1524 | }
|
| 1525 |
|
| 1526 | // QueryXYZText
|
| 1527 | {
|
| 1528 | const char* xml = "<point> <x>1.2</x> <y>1</y> <z>38</z> <valid>true</valid> </point>";
|
| 1529 | XMLDocument doc;
|
| 1530 | doc.Parse( xml );
|
| 1531 | XMLTest( "Parse points", false, doc.Error() );
|
| 1532 |
|
| 1533 | const XMLElement* pointElement = doc.RootElement();
|
| 1534 |
|
| 1535 | {
|
| 1536 | int intValue = 0;
|
| 1537 | XMLError queryResult = pointElement->FirstChildElement( "y" )->QueryIntText( &intValue );
|
| 1538 | XMLTest( "QueryIntText result", XML_SUCCESS, queryResult, false );
|
| 1539 | XMLTest( "QueryIntText", 1, intValue, false );
|
| 1540 | }
|
| 1541 |
|
| 1542 | {
|
| 1543 | unsigned unsignedValue = 0;
|
| 1544 | XMLError queryResult = pointElement->FirstChildElement( "y" )->QueryUnsignedText( &unsignedValue );
|
| 1545 | XMLTest( "QueryUnsignedText result", XML_SUCCESS, queryResult, false );
|
| 1546 | XMLTest( "QueryUnsignedText", (unsigned)1, unsignedValue, false );
|
| 1547 | }
|
| 1548 |
|
| 1549 | {
|
| 1550 | float floatValue = 0;
|
| 1551 | XMLError queryResult = pointElement->FirstChildElement( "x" )->QueryFloatText( &floatValue );
|
| 1552 | XMLTest( "QueryFloatText result", XML_SUCCESS, queryResult, false );
|
| 1553 | XMLTest( "QueryFloatText", 1.2f, floatValue, false );
|
| 1554 | }
|
| 1555 |
|
| 1556 | {
|
| 1557 | double doubleValue = 0;
|
| 1558 | XMLError queryResult = pointElement->FirstChildElement( "x" )->QueryDoubleText( &doubleValue );
|
| 1559 | XMLTest( "QueryDoubleText result", XML_SUCCESS, queryResult, false );
|
| 1560 | XMLTest( "QueryDoubleText", 1.2, doubleValue, false );
|
| 1561 | }
|
| 1562 |
|
| 1563 | {
|
| 1564 | bool boolValue = false;
|
| 1565 | XMLError queryResult = pointElement->FirstChildElement( "valid" )->QueryBoolText( &boolValue );
|
| 1566 | XMLTest( "QueryBoolText result", XML_SUCCESS, queryResult, false );
|
| 1567 | XMLTest( "QueryBoolText", true, boolValue, false );
|
| 1568 | }
|
| 1569 | }
|
| 1570 |
|
| 1571 | {
|
| 1572 | const char* xml = "<element><_sub/><:sub/><sub:sub/><sub-sub/></element>";
|
| 1573 | XMLDocument doc;
|
| 1574 | doc.Parse( xml );
|
| 1575 | XMLTest( "Non-alpha element lead letter parses.", false, doc.Error() );
|
| 1576 | }
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1577 |
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1578 | {
|
| 1579 | const char* xml = "<element _attr1=\"foo\" :attr2=\"bar\"></element>";
|
| 1580 | XMLDocument doc;
|
| 1581 | doc.Parse( xml );
|
| 1582 | XMLTest("Non-alpha attribute lead character parses.", false, doc.Error());
|
| 1583 | }
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1584 |
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1585 | {
|
| 1586 | const char* xml = "<3lement></3lement>";
|
| 1587 | XMLDocument doc;
|
| 1588 | doc.Parse( xml );
|
| 1589 | XMLTest("Element names with lead digit fail to parse.", true, doc.Error());
|
| 1590 | }
|
| 1591 |
|
| 1592 | {
|
| 1593 | const char* xml = "<element/>WOA THIS ISN'T GOING TO PARSE";
|
| 1594 | XMLDocument doc;
|
| 1595 | doc.Parse( xml, 10 );
|
| 1596 | XMLTest( "Set length of incoming data", false, doc.Error() );
|
| 1597 | }
|
| 1598 |
|
| 1599 | {
|
| 1600 | XMLDocument doc;
|
| 1601 | XMLTest( "Document is initially empty", true, doc.NoChildren() );
|
| 1602 | doc.Clear();
|
| 1603 | XMLTest( "Empty is empty after Clear()", true, doc.NoChildren() );
|
| 1604 | doc.LoadFile( "resources/dream.xml" );
|
| 1605 | XMLTest( "Load dream.xml", false, doc.Error() );
|
| 1606 | XMLTest( "Document has something to Clear()", false, doc.NoChildren() );
|
| 1607 | doc.Clear();
|
| 1608 | XMLTest( "Document Clear()'s", true, doc.NoChildren() );
|
| 1609 | }
|
| 1610 |
|
| 1611 | {
|
| 1612 | XMLDocument doc;
|
| 1613 | XMLTest( "No error initially", false, doc.Error() );
|
| 1614 | XMLError error = doc.Parse( "This is not XML" );
|
| 1615 | XMLTest( "Error after invalid XML", true, doc.Error() );
|
| 1616 | XMLTest( "Error after invalid XML", error, doc.ErrorID() );
|
| 1617 | doc.Clear();
|
| 1618 | XMLTest( "No error after Clear()", false, doc.Error() );
|
| 1619 | }
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1620 |
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1621 | // ----------- Whitespace ------------
|
| 1622 | {
|
| 1623 | const char* xml = "<element>"
|
| 1624 | "<a> This \nis ' text ' </a>"
|
| 1625 | "<b> This is ' text ' \n</b>"
|
| 1626 | "<c>This is ' \n\n text '</c>"
|
| 1627 | "</element>";
|
| 1628 | XMLDocument doc( true, COLLAPSE_WHITESPACE );
|
| 1629 | doc.Parse( xml );
|
| 1630 | XMLTest( "Parse with whitespace collapsing and &apos", false, doc.Error() );
|
| 1631 |
|
| 1632 | const XMLElement* element = doc.FirstChildElement();
|
| 1633 | for( const XMLElement* parent = element->FirstChildElement();
|
| 1634 | parent;
|
| 1635 | parent = parent->NextSiblingElement() )
|
| 1636 | {
|
| 1637 | XMLTest( "Whitespace collapse", "This is ' text '", parent->GetText() );
|
| 1638 | }
|
| 1639 | }
|
| 1640 |
|
| 1641 | #if 0
|
| 1642 | {
|
| 1643 | // Passes if assert doesn't fire.
|
| 1644 | XMLDocument xmlDoc;
|
| 1645 |
|
| 1646 | xmlDoc.NewDeclaration();
|
| 1647 | xmlDoc.NewComment("Configuration file");
|
| 1648 |
|
| 1649 | XMLElement *root = xmlDoc.NewElement("settings");
|
| 1650 | root->SetAttribute("version", 2);
|
| 1651 | }
|
| 1652 | #endif
|
| 1653 |
|
| 1654 | {
|
| 1655 | const char* xml = "<element> </element>";
|
| 1656 | XMLDocument doc( true, COLLAPSE_WHITESPACE );
|
| 1657 | doc.Parse( xml );
|
| 1658 | XMLTest( "Parse with all whitespaces", false, doc.Error() );
|
| 1659 | XMLTest( "Whitespace all space", true, 0 == doc.FirstChildElement()->FirstChild() );
|
| 1660 | }
|
| 1661 |
|
| 1662 | {
|
| 1663 | // An assert should not fire.
|
| 1664 | const char* xml = "<element/>";
|
| 1665 | XMLDocument doc;
|
| 1666 | doc.Parse( xml );
|
| 1667 | XMLTest( "Parse with self-closed element", false, doc.Error() );
|
| 1668 | XMLElement* ele = doc.NewElement( "unused" ); // This will get cleaned up with the 'doc' going out of scope.
|
| 1669 | XMLTest( "Tracking unused elements", true, ele != 0, false );
|
| 1670 | }
|
| 1671 |
|
| 1672 |
|
| 1673 | {
|
| 1674 | const char* xml = "<parent><child>abc</child></parent>";
|
| 1675 | XMLDocument doc;
|
| 1676 | doc.Parse( xml );
|
| 1677 | XMLTest( "Parse for printing of sub-element", false, doc.Error() );
|
| 1678 | XMLElement* ele = doc.FirstChildElement( "parent")->FirstChildElement( "child");
|
| 1679 |
|
| 1680 | XMLPrinter printer;
|
| 1681 | bool acceptResult = ele->Accept( &printer );
|
| 1682 | XMLTest( "Accept of sub-element", true, acceptResult );
|
| 1683 | XMLTest( "Printing of sub-element", "<child>abc</child>\n", printer.CStr(), false );
|
| 1684 | }
|
| 1685 |
|
| 1686 |
|
| 1687 | {
|
| 1688 | XMLDocument doc;
|
| 1689 | XMLError error = doc.LoadFile( "resources/empty.xml" );
|
| 1690 | XMLTest( "Loading an empty file", XML_ERROR_EMPTY_DOCUMENT, error );
|
| 1691 | XMLTest( "Loading an empty file and ErrorName as string", "XML_ERROR_EMPTY_DOCUMENT", doc.ErrorName() );
|
| 1692 | doc.PrintError();
|
| 1693 | }
|
| 1694 |
|
| 1695 | {
|
| 1696 | // BOM preservation
|
| 1697 | static const char* xml_bom_preservation = "\xef\xbb\xbf<element/>\n";
|
| 1698 | {
|
| 1699 | XMLDocument doc;
|
| 1700 | XMLTest( "BOM preservation (parse)", XML_SUCCESS, doc.Parse( xml_bom_preservation ), false );
|
| 1701 | XMLPrinter printer;
|
| 1702 | doc.Print( &printer );
|
| 1703 |
|
| 1704 | XMLTest( "BOM preservation (compare)", xml_bom_preservation, printer.CStr(), false, true );
|
| 1705 | doc.SaveFile( "resources/bomtest.xml" );
|
| 1706 | XMLTest( "Save bomtest.xml", false, doc.Error() );
|
| 1707 | }
|
| 1708 | {
|
| 1709 | XMLDocument doc;
|
| 1710 | doc.LoadFile( "resources/bomtest.xml" );
|
| 1711 | XMLTest( "Load bomtest.xml", false, doc.Error() );
|
| 1712 | XMLTest( "BOM preservation (load)", true, doc.HasBOM(), false );
|
| 1713 |
|
| 1714 | XMLPrinter printer;
|
| 1715 | doc.Print( &printer );
|
| 1716 | XMLTest( "BOM preservation (compare)", xml_bom_preservation, printer.CStr(), false, true );
|
| 1717 | }
|
| 1718 | }
|
| 1719 |
|
| 1720 | {
|
| 1721 | // Insertion with Removal
|
| 1722 | const char* xml = "<?xml version=\"1.0\" ?>"
|
| 1723 | "<root>"
|
| 1724 | "<one>"
|
| 1725 | "<subtree>"
|
| 1726 | "<elem>element 1</elem>text<!-- comment -->"
|
| 1727 | "</subtree>"
|
| 1728 | "</one>"
|
| 1729 | "<two/>"
|
| 1730 | "</root>";
|
| 1731 | const char* xmlInsideTwo = "<?xml version=\"1.0\" ?>"
|
| 1732 | "<root>"
|
| 1733 | "<one/>"
|
| 1734 | "<two>"
|
| 1735 | "<subtree>"
|
| 1736 | "<elem>element 1</elem>text<!-- comment -->"
|
| 1737 | "</subtree>"
|
| 1738 | "</two>"
|
| 1739 | "</root>";
|
| 1740 | const char* xmlAfterOne = "<?xml version=\"1.0\" ?>"
|
| 1741 | "<root>"
|
| 1742 | "<one/>"
|
| 1743 | "<subtree>"
|
| 1744 | "<elem>element 1</elem>text<!-- comment -->"
|
| 1745 | "</subtree>"
|
| 1746 | "<two/>"
|
| 1747 | "</root>";
|
| 1748 | const char* xmlAfterTwo = "<?xml version=\"1.0\" ?>"
|
| 1749 | "<root>"
|
| 1750 | "<one/>"
|
| 1751 | "<two/>"
|
| 1752 | "<subtree>"
|
| 1753 | "<elem>element 1</elem>text<!-- comment -->"
|
| 1754 | "</subtree>"
|
| 1755 | "</root>";
|
| 1756 |
|
| 1757 | XMLDocument doc;
|
| 1758 | doc.Parse(xml);
|
| 1759 | XMLTest( "Insertion with removal parse round 1", false, doc.Error() );
|
| 1760 | XMLElement* subtree = doc.RootElement()->FirstChildElement("one")->FirstChildElement("subtree");
|
| 1761 | XMLElement* two = doc.RootElement()->FirstChildElement("two");
|
| 1762 | two->InsertFirstChild(subtree);
|
| 1763 | XMLPrinter printer1(0, true);
|
| 1764 | bool acceptResult = doc.Accept(&printer1);
|
| 1765 | XMLTest("Move node from within <one> to <two> - Accept()", true, acceptResult);
|
| 1766 | XMLTest("Move node from within <one> to <two>", xmlInsideTwo, printer1.CStr());
|
| 1767 |
|
| 1768 | doc.Parse(xml);
|
| 1769 | XMLTest( "Insertion with removal parse round 2", false, doc.Error() );
|
| 1770 | subtree = doc.RootElement()->FirstChildElement("one")->FirstChildElement("subtree");
|
| 1771 | two = doc.RootElement()->FirstChildElement("two");
|
| 1772 | doc.RootElement()->InsertAfterChild(two, subtree);
|
| 1773 | XMLPrinter printer2(0, true);
|
| 1774 | acceptResult = doc.Accept(&printer2);
|
| 1775 | XMLTest("Move node from within <one> after <two> - Accept()", true, acceptResult);
|
| 1776 | XMLTest("Move node from within <one> after <two>", xmlAfterTwo, printer2.CStr(), false);
|
| 1777 |
|
| 1778 | doc.Parse(xml);
|
| 1779 | XMLTest( "Insertion with removal parse round 3", false, doc.Error() );
|
| 1780 | XMLNode* one = doc.RootElement()->FirstChildElement("one");
|
| 1781 | subtree = one->FirstChildElement("subtree");
|
| 1782 | doc.RootElement()->InsertAfterChild(one, subtree);
|
| 1783 | XMLPrinter printer3(0, true);
|
| 1784 | acceptResult = doc.Accept(&printer3);
|
| 1785 | XMLTest("Move node from within <one> after <one> - Accept()", true, acceptResult);
|
| 1786 | XMLTest("Move node from within <one> after <one>", xmlAfterOne, printer3.CStr(), false);
|
| 1787 |
|
| 1788 | doc.Parse(xml);
|
| 1789 | XMLTest( "Insertion with removal parse round 4", false, doc.Error() );
|
| 1790 | subtree = doc.RootElement()->FirstChildElement("one")->FirstChildElement("subtree");
|
| 1791 | two = doc.RootElement()->FirstChildElement("two");
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1792 | XMLTest("<two> is the last child at root level", true, two == doc.RootElement()->LastChildElement());
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1793 | doc.RootElement()->InsertEndChild(subtree);
|
| 1794 | XMLPrinter printer4(0, true);
|
| 1795 | acceptResult = doc.Accept(&printer4);
|
| 1796 | XMLTest("Move node from within <one> after <two> - Accept()", true, acceptResult);
|
| 1797 | XMLTest("Move node from within <one> after <two>", xmlAfterTwo, printer4.CStr(), false);
|
| 1798 | }
|
| 1799 |
|
| 1800 | {
|
| 1801 | const char* xml = "<svg width = \"128\" height = \"128\">"
|
| 1802 | " <text> </text>"
|
| 1803 | "</svg>";
|
| 1804 | XMLDocument doc;
|
| 1805 | doc.Parse(xml);
|
| 1806 | XMLTest( "Parse svg with text", false, doc.Error() );
|
| 1807 | doc.Print();
|
| 1808 | }
|
| 1809 |
|
| 1810 | {
|
| 1811 | // Test that it doesn't crash.
|
| 1812 | const char* xml = "<?xml version=\"1.0\"?><root><sample><field0><1</field0><field1>2</field1></sample></root>";
|
| 1813 | XMLDocument doc;
|
| 1814 | doc.Parse(xml);
|
| 1815 | XMLTest( "Parse root-sample-field0", true, doc.Error() );
|
| 1816 | doc.PrintError();
|
| 1817 | }
|
| 1818 |
|
| 1819 | #if 1
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1820 | // the question being explored is what kind of print to use:
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1821 | // https://github.com/leethomason/tinyxml2/issues/63
|
| 1822 | {
|
| 1823 | //const char* xml = "<element attrA='123456789.123456789' attrB='1.001e9' attrC='1.0e-10' attrD='1001000000.000000' attrE='0.1234567890123456789'/>";
|
| 1824 | const char* xml = "<element/>";
|
| 1825 | XMLDocument doc;
|
| 1826 | doc.Parse( xml );
|
| 1827 | XMLTest( "Parse self-closed empty element", false, doc.Error() );
|
| 1828 | doc.FirstChildElement()->SetAttribute( "attrA-f64", 123456789.123456789 );
|
| 1829 | doc.FirstChildElement()->SetAttribute( "attrB-f64", 1.001e9 );
|
| 1830 | doc.FirstChildElement()->SetAttribute( "attrC-f64", 1.0e9 );
|
| 1831 | doc.FirstChildElement()->SetAttribute( "attrC-f64", 1.0e20 );
|
| 1832 | doc.FirstChildElement()->SetAttribute( "attrD-f64", 1.0e-10 );
|
| 1833 | doc.FirstChildElement()->SetAttribute( "attrD-f64", 0.123456789 );
|
| 1834 |
|
| 1835 | doc.FirstChildElement()->SetAttribute( "attrA-f32", 123456789.123456789f );
|
| 1836 | doc.FirstChildElement()->SetAttribute( "attrB-f32", 1.001e9f );
|
| 1837 | doc.FirstChildElement()->SetAttribute( "attrC-f32", 1.0e9f );
|
| 1838 | doc.FirstChildElement()->SetAttribute( "attrC-f32", 1.0e20f );
|
| 1839 | doc.FirstChildElement()->SetAttribute( "attrD-f32", 1.0e-10f );
|
| 1840 | doc.FirstChildElement()->SetAttribute( "attrD-f32", 0.123456789f );
|
| 1841 |
|
| 1842 | doc.Print();
|
| 1843 |
|
| 1844 | /* The result of this test is platform, compiler, and library version dependent. :("
|
| 1845 | XMLPrinter printer;
|
| 1846 | doc.Print( &printer );
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1847 | XMLTest( "Float and double formatting.",
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1848 | "<element attrA-f64=\"123456789.12345679\" attrB-f64=\"1001000000\" attrC-f64=\"1e+20\" attrD-f64=\"0.123456789\" attrA-f32=\"1.2345679e+08\" attrB-f32=\"1.001e+09\" attrC-f32=\"1e+20\" attrD-f32=\"0.12345679\"/>\n",
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1849 | printer.CStr(),
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1850 | true );
|
| 1851 | */
|
| 1852 | }
|
| 1853 | #endif
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1854 |
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1855 | {
|
| 1856 | // Issue #184
|
| 1857 | // If it doesn't assert, it passes. Caused by objects
|
| 1858 | // getting created during parsing which are then
|
| 1859 | // inaccessible in the memory pools.
|
| 1860 | const char* xmlText = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><test>";
|
| 1861 | {
|
| 1862 | XMLDocument doc;
|
| 1863 | doc.Parse(xmlText);
|
| 1864 | XMLTest( "Parse hex no closing tag round 1", true, doc.Error() );
|
| 1865 | }
|
| 1866 | {
|
| 1867 | XMLDocument doc;
|
| 1868 | doc.Parse(xmlText);
|
| 1869 | XMLTest( "Parse hex no closing tag round 2", true, doc.Error() );
|
| 1870 | doc.Clear();
|
| 1871 | }
|
| 1872 | }
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1873 |
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1874 | {
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1875 | // If this doesn't assert in TINYXML2_DEBUG, all is well.
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1876 | tinyxml2::XMLDocument doc;
|
| 1877 | tinyxml2::XMLElement *pRoot = doc.NewElement("Root");
|
| 1878 | doc.DeleteNode(pRoot);
|
| 1879 | }
|
| 1880 |
|
| 1881 | {
|
| 1882 | XMLDocument doc;
|
| 1883 | XMLElement* root = doc.NewElement( "Root" );
|
| 1884 | XMLTest( "Node document before insertion", true, &doc == root->GetDocument() );
|
| 1885 | doc.InsertEndChild( root );
|
| 1886 | XMLTest( "Node document after insertion", true, &doc == root->GetDocument() );
|
| 1887 | }
|
| 1888 |
|
| 1889 | {
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1890 | // If this doesn't assert in TINYXML2_DEBUG, all is well.
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1891 | XMLDocument doc;
|
| 1892 | XMLElement* unlinkedRoot = doc.NewElement( "Root" );
|
| 1893 | XMLElement* linkedRoot = doc.NewElement( "Root" );
|
| 1894 | doc.InsertFirstChild( linkedRoot );
|
| 1895 | unlinkedRoot->GetDocument()->DeleteNode( linkedRoot );
|
| 1896 | unlinkedRoot->GetDocument()->DeleteNode( unlinkedRoot );
|
| 1897 | }
|
| 1898 |
|
| 1899 | {
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1900 | // Should not assert in TINYXML2_DEBUG
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1901 | XMLPrinter printer;
|
| 1902 | }
|
| 1903 |
|
| 1904 | {
|
| 1905 | // Issue 291. Should not crash
|
| 1906 | const char* xml = "�</a>";
|
| 1907 | XMLDocument doc;
|
| 1908 | doc.Parse( xml );
|
| 1909 | XMLTest( "Parse hex with closing tag", false, doc.Error() );
|
| 1910 |
|
| 1911 | XMLPrinter printer;
|
| 1912 | doc.Print( &printer );
|
| 1913 | }
|
| 1914 | {
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1915 | // Issue 299. Can print elements that are not linked in.
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1916 | // Will crash if issue not fixed.
|
| 1917 | XMLDocument doc;
|
| 1918 | XMLElement* newElement = doc.NewElement( "printme" );
|
| 1919 | XMLPrinter printer;
|
| 1920 | bool acceptResult = newElement->Accept( &printer );
|
| 1921 | XMLTest( "printme - Accept()", true, acceptResult );
|
| 1922 | // Delete the node to avoid possible memory leak report in debug output
|
| 1923 | doc.DeleteNode( newElement );
|
| 1924 | }
|
| 1925 | {
|
| 1926 | // Issue 302. Clear errors from LoadFile/SaveFile
|
| 1927 | XMLDocument doc;
|
| 1928 | XMLTest( "Issue 302. Should be no error initially", "XML_SUCCESS", doc.ErrorName() );
|
| 1929 | doc.SaveFile( "./no/such/path/pretty.xml" );
|
| 1930 | XMLTest( "Issue 302. Fail to save", "XML_ERROR_FILE_COULD_NOT_BE_OPENED", doc.ErrorName() );
|
| 1931 | doc.SaveFile( "./resources/out/compact.xml", true );
|
| 1932 | XMLTest( "Issue 302. Subsequent success in saving", "XML_SUCCESS", doc.ErrorName() );
|
| 1933 | }
|
| 1934 |
|
| 1935 | {
|
| 1936 | // If a document fails to load then subsequent
|
| 1937 | // successful loads should clear the error
|
| 1938 | XMLDocument doc;
|
| 1939 | XMLTest( "Should be no error initially", false, doc.Error() );
|
| 1940 | doc.LoadFile( "resources/no-such-file.xml" );
|
| 1941 | XMLTest( "No such file - should fail", true, doc.Error() );
|
| 1942 |
|
| 1943 | doc.LoadFile( "resources/dream.xml" );
|
| 1944 | XMLTest( "Error should be cleared", false, doc.Error() );
|
| 1945 | }
|
| 1946 |
|
| 1947 | {
|
| 1948 | // Check that declarations are allowed only at beginning of document
|
| 1949 | const char* xml0 = "<?xml version=\"1.0\" ?>"
|
| 1950 | " <!-- xml version=\"1.1\" -->"
|
| 1951 | "<first />";
|
| 1952 | const char* xml1 = "<?xml version=\"1.0\" ?>"
|
| 1953 | "<?xml-stylesheet type=\"text/xsl\" href=\"Anything.xsl\"?>"
|
| 1954 | "<first />";
|
| 1955 | const char* xml2 = "<first />"
|
| 1956 | "<?xml version=\"1.0\" ?>";
|
| 1957 | const char* xml3 = "<first></first>"
|
| 1958 | "<?xml version=\"1.0\" ?>";
|
| 1959 |
|
| 1960 | const char* xml4 = "<first><?xml version=\"1.0\" ?></first>";
|
| 1961 |
|
| 1962 | XMLDocument doc;
|
| 1963 | doc.Parse(xml0);
|
| 1964 | XMLTest("Test that the code changes do not affect normal parsing", false, doc.Error() );
|
| 1965 | doc.Parse(xml1);
|
| 1966 | XMLTest("Test that the second declaration is allowed", false, doc.Error() );
|
| 1967 | doc.Parse(xml2);
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1968 | XMLTest("Test that declaration after self-closed child is not allowed", XML_ERROR_PARSING_DECLARATION, doc.ErrorID() );
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1969 | doc.Parse(xml3);
|
| 1970 | XMLTest("Test that declaration after a child is not allowed", XML_ERROR_PARSING_DECLARATION, doc.ErrorID() );
|
| 1971 | doc.Parse(xml4);
|
| 1972 | XMLTest("Test that declaration inside a child is not allowed", XML_ERROR_PARSING_DECLARATION, doc.ErrorID() );
|
| 1973 | }
|
| 1974 |
|
| 1975 | {
|
| 1976 | // No matter - before or after successfully parsing a text -
|
| 1977 | // calling XMLDocument::Value() used to cause an assert in debug.
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1978 | // Null must be returned.
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 1979 | const char* validXml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
|
| 1980 | "<first />"
|
| 1981 | "<second />";
|
| 1982 | XMLDocument* doc = new XMLDocument();
|
| 1983 | XMLTest( "XMLDocument::Value() returns null?", NULL, doc->Value() );
|
| 1984 | doc->Parse( validXml );
|
| 1985 | XMLTest( "Parse to test XMLDocument::Value()", false, doc->Error());
|
| 1986 | XMLTest( "XMLDocument::Value() returns null?", NULL, doc->Value() );
|
| 1987 | delete doc;
|
| 1988 | }
|
| 1989 |
|
| 1990 | {
|
| 1991 | XMLDocument doc;
|
| 1992 | for( int i = 0; i < XML_ERROR_COUNT; i++ ) {
|
| 1993 | const XMLError error = static_cast<XMLError>(i);
|
| 1994 | const char* name = XMLDocument::ErrorIDToName(error);
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 1995 | XMLTest( "ErrorName() not null after ClearError()", true, name != 0 );
|
| 1996 | if( name == 0 ) {
|
| 1997 | // passing null pointer into strlen() is undefined behavior, so
|
| 1998 | // compiler is allowed to optimise away the null test above if it's
|
| 1999 | // as reachable as the strlen() call
|
| 2000 | continue;
|
| 2001 | }
|
| 2002 | XMLTest( "ErrorName() not empty after ClearError()", true, strlen(name) > 0 );
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 2003 | }
|
| 2004 | }
|
| 2005 |
|
| 2006 | {
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 2007 | const char* html("<!DOCTYPE html><html><body><p>test</p><p><br/></p></body></html>");
|
| 2008 | XMLDocument doc(false);
|
| 2009 | doc.Parse(html);
|
| 2010 |
|
| 2011 | XMLPrinter printer(0, true);
|
| 2012 | doc.Print(&printer);
|
| 2013 |
|
| 2014 | XMLTest(html, html, printer.CStr());
|
| 2015 | }
|
| 2016 |
|
| 2017 | {
|
| 2018 | // Evil memory leaks.
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 2019 | // If an XMLElement (etc) is allocated via NewElement() (etc.)
|
| 2020 | // and NOT added to the XMLDocument, what happens?
|
| 2021 | //
|
| 2022 | // Previously (buggy):
|
| 2023 | // The memory would be free'd when the XMLDocument is
|
| 2024 | // destructed. But the XMLElement destructor wasn't called, so
|
| 2025 | // memory allocated for the XMLElement text would not be free'd.
|
| 2026 | // In practice this meant strings allocated for the XMLElement
|
| 2027 | // text would be leaked. An edge case, but annoying.
|
| 2028 | // Now:
|
| 2029 | // The XMLElement destructor is called. But the unlinked nodes
|
| 2030 | // have to be tracked using a list. This has a minor performance
|
| 2031 | // impact that can become significant if you have a lot of
|
| 2032 | // unlinked nodes. (But why would you do that?)
|
| 2033 | // The only way to see this bug was in a Visual C++ runtime debug heap
|
| 2034 | // leak tracker. This is compiled in by default on Windows Debug and
|
| 2035 | // enabled with _CRTDBG_LEAK_CHECK_DF parameter passed to _CrtSetDbgFlag().
|
| 2036 | {
|
| 2037 | XMLDocument doc;
|
| 2038 | doc.NewElement("LEAK 1");
|
| 2039 | }
|
| 2040 | {
|
| 2041 | XMLDocument doc;
|
| 2042 | XMLElement* ele = doc.NewElement("LEAK 2");
|
| 2043 | doc.DeleteNode(ele);
|
| 2044 | }
|
| 2045 | }
|
| 2046 |
|
| 2047 | {
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 2048 | // Bad bad crash. Parsing error results in stack overflow, if uncaught.
|
| 2049 | const char* TESTS[] = {
|
| 2050 | "./resources/xmltest-5330.xml",
|
| 2051 | "./resources/xmltest-4636783552757760.xml",
|
| 2052 | "./resources/xmltest-5720541257269248.xml",
|
| 2053 | 0
|
| 2054 | };
|
| 2055 | for (int i=0; TESTS[i]; ++i) {
|
| 2056 | XMLDocument doc;
|
| 2057 | doc.LoadFile(TESTS[i]);
|
| 2058 | XMLTest("Stack overflow prevented.", XML_ELEMENT_DEPTH_EXCEEDED, doc.ErrorID());
|
| 2059 | }
|
| 2060 | }
|
| 2061 | {
|
| 2062 | const char* TESTS[] = {
|
| 2063 | "./resources/xmltest-5662204197076992.xml", // Security-level performance issue.
|
| 2064 | 0
|
| 2065 | };
|
| 2066 | for (int i = 0; TESTS[i]; ++i) {
|
| 2067 | XMLDocument doc;
|
| 2068 | doc.LoadFile(TESTS[i]);
|
| 2069 | // Need only not crash / lock up.
|
| 2070 | XMLTest("Fuzz attack prevented.", true, true);
|
| 2071 | }
|
| 2072 | }
|
| 2073 | {
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 2074 | // Crashing reported via email.
|
| 2075 | const char* xml =
|
| 2076 | "<playlist id='playlist1'>"
|
| 2077 | "<property name='track_name'>voice</property>"
|
| 2078 | "<property name='audio_track'>1</property>"
|
| 2079 | "<entry out = '604' producer = '4_playlist1' in = '0' />"
|
| 2080 | "<blank length = '1' />"
|
| 2081 | "<entry out = '1625' producer = '3_playlist' in = '0' />"
|
| 2082 | "<blank length = '2' />"
|
| 2083 | "<entry out = '946' producer = '2_playlist1' in = '0' />"
|
| 2084 | "<blank length = '1' />"
|
| 2085 | "<entry out = '128' producer = '1_playlist1' in = '0' />"
|
| 2086 | "</playlist>";
|
| 2087 |
|
| 2088 | // It's not a good idea to delete elements as you walk the
|
| 2089 | // list. I'm not sure this technically should work; but it's
|
| 2090 | // an interesting test case.
|
| 2091 | XMLDocument doc;
|
| 2092 | XMLError err = doc.Parse(xml);
|
| 2093 | XMLTest("Crash bug parsing", XML_SUCCESS, err );
|
| 2094 |
|
| 2095 | XMLElement* playlist = doc.FirstChildElement("playlist");
|
| 2096 | XMLTest("Crash bug parsing", true, playlist != 0);
|
| 2097 |
|
| 2098 | {
|
| 2099 | const char* elementName = "entry";
|
| 2100 | XMLElement* entry = playlist->FirstChildElement(elementName);
|
| 2101 | XMLTest("Crash bug parsing", true, entry != 0);
|
| 2102 | while (entry) {
|
| 2103 | XMLElement* todelete = entry;
|
| 2104 | entry = entry->NextSiblingElement(elementName);
|
| 2105 | playlist->DeleteChild(todelete);
|
| 2106 | }
|
| 2107 | entry = playlist->FirstChildElement(elementName);
|
| 2108 | XMLTest("Crash bug parsing", true, entry == 0);
|
| 2109 | }
|
| 2110 | {
|
| 2111 | const char* elementName = "blank";
|
| 2112 | XMLElement* blank = playlist->FirstChildElement(elementName);
|
| 2113 | XMLTest("Crash bug parsing", true, blank != 0);
|
| 2114 | while (blank) {
|
| 2115 | XMLElement* todelete = blank;
|
| 2116 | blank = blank->NextSiblingElement(elementName);
|
| 2117 | playlist->DeleteChild(todelete);
|
| 2118 | }
|
| 2119 | XMLTest("Crash bug parsing", true, blank == 0);
|
| 2120 | }
|
| 2121 |
|
| 2122 | tinyxml2::XMLPrinter printer;
|
| 2123 | const bool acceptResult = playlist->Accept(&printer);
|
| 2124 | XMLTest("Crash bug parsing - Accept()", true, acceptResult);
|
| 2125 | printf("%s\n", printer.CStr());
|
| 2126 |
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 2127 | // No test; it only need to not crash.
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 2128 | // Still, wrap it up with a sanity check
|
| 2129 | int nProperty = 0;
|
| 2130 | for (const XMLElement* p = playlist->FirstChildElement("property"); p; p = p->NextSiblingElement("property")) {
|
| 2131 | nProperty++;
|
| 2132 | }
|
| 2133 | XMLTest("Crash bug parsing", 2, nProperty);
|
| 2134 | }
|
| 2135 |
|
| 2136 | // ----------- Line Number Tracking --------------
|
| 2137 | {
|
| 2138 | struct TestUtil: XMLVisitor
|
| 2139 | {
|
| 2140 | TestUtil() : str() {}
|
| 2141 |
|
| 2142 | void TestParseError(const char *testString, const char *docStr, XMLError expected_error, int expectedLine)
|
| 2143 | {
|
| 2144 | XMLDocument doc;
|
| 2145 | const XMLError parseError = doc.Parse(docStr);
|
| 2146 |
|
| 2147 | XMLTest(testString, parseError, doc.ErrorID());
|
| 2148 | XMLTest(testString, true, doc.Error());
|
| 2149 | XMLTest(testString, expected_error, parseError);
|
| 2150 | XMLTest(testString, expectedLine, doc.ErrorLineNum());
|
| 2151 | };
|
| 2152 |
|
| 2153 | void TestStringLines(const char *testString, const char *docStr, const char *expectedLines)
|
| 2154 | {
|
| 2155 | XMLDocument doc;
|
| 2156 | doc.Parse(docStr);
|
| 2157 | XMLTest(testString, false, doc.Error());
|
| 2158 | TestDocLines(testString, doc, expectedLines);
|
| 2159 | }
|
| 2160 |
|
| 2161 | void TestFileLines(const char *testString, const char *file_name, const char *expectedLines)
|
| 2162 | {
|
| 2163 | XMLDocument doc;
|
| 2164 | doc.LoadFile(file_name);
|
| 2165 | XMLTest(testString, false, doc.Error());
|
| 2166 | TestDocLines(testString, doc, expectedLines);
|
| 2167 | }
|
| 2168 |
|
| 2169 | private:
|
| 2170 | DynArray<char, 10> str;
|
| 2171 |
|
| 2172 | void Push(char type, int lineNum)
|
| 2173 | {
|
| 2174 | str.Push(type);
|
| 2175 | str.Push(char('0' + (lineNum / 10)));
|
| 2176 | str.Push(char('0' + (lineNum % 10)));
|
| 2177 | }
|
| 2178 |
|
| 2179 | bool VisitEnter(const XMLDocument& doc)
|
| 2180 | {
|
| 2181 | Push('D', doc.GetLineNum());
|
| 2182 | return true;
|
| 2183 | }
|
| 2184 | bool VisitEnter(const XMLElement& element, const XMLAttribute* firstAttribute)
|
| 2185 | {
|
| 2186 | Push('E', element.GetLineNum());
|
| 2187 | for (const XMLAttribute *attr = firstAttribute; attr != 0; attr = attr->Next())
|
| 2188 | Push('A', attr->GetLineNum());
|
| 2189 | return true;
|
| 2190 | }
|
| 2191 | bool Visit(const XMLDeclaration& declaration)
|
| 2192 | {
|
| 2193 | Push('L', declaration.GetLineNum());
|
| 2194 | return true;
|
| 2195 | }
|
| 2196 | bool Visit(const XMLText& text)
|
| 2197 | {
|
| 2198 | Push('T', text.GetLineNum());
|
| 2199 | return true;
|
| 2200 | }
|
| 2201 | bool Visit(const XMLComment& comment)
|
| 2202 | {
|
| 2203 | Push('C', comment.GetLineNum());
|
| 2204 | return true;
|
| 2205 | }
|
| 2206 | bool Visit(const XMLUnknown& unknown)
|
| 2207 | {
|
| 2208 | Push('U', unknown.GetLineNum());
|
| 2209 | return true;
|
| 2210 | }
|
| 2211 |
|
| 2212 | void TestDocLines(const char *testString, XMLDocument &doc, const char *expectedLines)
|
| 2213 | {
|
| 2214 | str.Clear();
|
| 2215 | const bool acceptResult = doc.Accept(this);
|
| 2216 | XMLTest(testString, true, acceptResult);
|
| 2217 | str.Push(0);
|
| 2218 | XMLTest(testString, expectedLines, str.Mem());
|
| 2219 | }
|
| 2220 | } tester;
|
| 2221 |
|
| 2222 | tester.TestParseError("ErrorLine-Parsing", "\n<root>\n foo \n<unclosed/>", XML_ERROR_PARSING, 2);
|
| 2223 | tester.TestParseError("ErrorLine-Declaration", "<root>\n<?xml version=\"1.0\"?>", XML_ERROR_PARSING_DECLARATION, 2);
|
| 2224 | tester.TestParseError("ErrorLine-Mismatch", "\n<root>\n</mismatch>", XML_ERROR_MISMATCHED_ELEMENT, 2);
|
| 2225 | tester.TestParseError("ErrorLine-CData", "\n<root><![CDATA[ \n foo bar \n", XML_ERROR_PARSING_CDATA, 2);
|
| 2226 | tester.TestParseError("ErrorLine-Text", "\n<root>\n foo bar \n", XML_ERROR_PARSING_TEXT, 3);
|
| 2227 | tester.TestParseError("ErrorLine-Comment", "\n<root>\n<!-- >\n", XML_ERROR_PARSING_COMMENT, 3);
|
| 2228 | tester.TestParseError("ErrorLine-Declaration", "\n<root>\n<? >\n", XML_ERROR_PARSING_DECLARATION, 3);
|
| 2229 | tester.TestParseError("ErrorLine-Unknown", "\n<root>\n<! \n", XML_ERROR_PARSING_UNKNOWN, 3);
|
| 2230 | tester.TestParseError("ErrorLine-Element", "\n<root>\n<unclosed \n", XML_ERROR_PARSING_ELEMENT, 3);
|
| 2231 | tester.TestParseError("ErrorLine-Attribute", "\n<root>\n<unclosed \n att\n", XML_ERROR_PARSING_ATTRIBUTE, 4);
|
| 2232 | tester.TestParseError("ErrorLine-ElementClose", "\n<root>\n<unclosed \n/unexpected", XML_ERROR_PARSING_ELEMENT, 3);
|
| 2233 |
|
| 2234 | tester.TestStringLines(
|
| 2235 | "LineNumbers-String",
|
| 2236 |
|
| 2237 | "<?xml version=\"1.0\"?>\n" // 1 Doc, DecL
|
| 2238 | "<root a='b' \n" // 2 Element Attribute
|
| 2239 | "c='d'> d <blah/> \n" // 3 Attribute Text Element
|
| 2240 | "newline in text \n" // 4 Text
|
| 2241 | "and second <zxcv/><![CDATA[\n" // 5 Element Text
|
| 2242 | " cdata test ]]><!-- comment -->\n" // 6 Comment
|
| 2243 | "<! unknown></root>", // 7 Unknown
|
| 2244 |
|
| 2245 | "D01L01E02A02A03T03E03T04E05T05C06U07");
|
| 2246 |
|
| 2247 | tester.TestStringLines(
|
| 2248 | "LineNumbers-CRLF",
|
| 2249 |
|
| 2250 | "\r\n" // 1 Doc (arguably should be line 2)
|
| 2251 | "<?xml version=\"1.0\"?>\n" // 2 DecL
|
| 2252 | "<root>\r\n" // 3 Element
|
| 2253 | "\n" // 4
|
| 2254 | "text contining new line \n" // 5 Text
|
| 2255 | " and also containing crlf \r\n" // 6
|
| 2256 | "<sub><![CDATA[\n" // 7 Element Text
|
| 2257 | "cdata containing new line \n" // 8
|
| 2258 | " and also containing cflr\r\n" // 9
|
| 2259 | "]]></sub><sub2/></root>", // 10 Element
|
| 2260 |
|
| 2261 | "D01L02E03T05E07T07E10");
|
| 2262 |
|
| 2263 | tester.TestFileLines(
|
| 2264 | "LineNumbers-File",
|
| 2265 | "resources/utf8test.xml",
|
| 2266 | "D01L01E02E03A03A03T03E04A04A04T04E05A05A05T05E06A06A06T06E07A07A07T07E08A08A08T08E09T09E10T10");
|
| 2267 | }
|
| 2268 |
|
| 2269 | {
|
| 2270 | const char* xml = "<Hello>Text</Error>";
|
| 2271 | XMLDocument doc;
|
| 2272 | doc.Parse(xml);
|
| 2273 | XMLTest("Test mismatched elements.", true, doc.Error());
|
| 2274 | XMLTest("Test mismatched elements.", XML_ERROR_MISMATCHED_ELEMENT, doc.ErrorID());
|
| 2275 | // For now just make sure calls work & doesn't crash.
|
| 2276 | // May solidify the error output in the future.
|
| 2277 | printf("%s\n", doc.ErrorStr());
|
| 2278 | doc.PrintError();
|
| 2279 | }
|
| 2280 |
|
| 2281 | // ----------- Performance tracking --------------
|
| 2282 | {
|
| 2283 | #if defined( _MSC_VER )
|
| 2284 | __int64 start, end, freq;
|
| 2285 | QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
|
| 2286 | #endif
|
| 2287 |
|
| 2288 | FILE* perfFP = fopen("resources/dream.xml", "r");
|
| 2289 | XMLTest("Open dream.xml", true, perfFP != 0);
|
| 2290 | fseek(perfFP, 0, SEEK_END);
|
| 2291 | long size = ftell(perfFP);
|
| 2292 | fseek(perfFP, 0, SEEK_SET);
|
| 2293 |
|
| 2294 | char* mem = new char[size + 1];
|
| 2295 | memset(mem, 0xfe, size);
|
| 2296 | size_t bytesRead = fread(mem, 1, size, perfFP);
|
| 2297 | XMLTest("Read dream.xml", true, uint32_t(size) >= uint32_t(bytesRead));
|
| 2298 | fclose(perfFP);
|
| 2299 | mem[size] = 0;
|
| 2300 |
|
| 2301 | #if defined( _MSC_VER )
|
| 2302 | QueryPerformanceCounter((LARGE_INTEGER*)&start);
|
| 2303 | #else
|
| 2304 | clock_t cstart = clock();
|
| 2305 | #endif
|
| 2306 | bool parseDreamXmlFailed = false;
|
| 2307 | static const int COUNT = 10;
|
| 2308 | for (int i = 0; i < COUNT; ++i) {
|
| 2309 | XMLDocument doc;
|
| 2310 | doc.Parse(mem);
|
| 2311 | parseDreamXmlFailed = parseDreamXmlFailed || doc.Error();
|
| 2312 | }
|
| 2313 | #if defined( _MSC_VER )
|
| 2314 | QueryPerformanceCounter((LARGE_INTEGER*)&end);
|
| 2315 | #else
|
| 2316 | clock_t cend = clock();
|
| 2317 | #endif
|
| 2318 | XMLTest( "Parse dream.xml", false, parseDreamXmlFailed );
|
| 2319 |
|
| 2320 | delete[] mem;
|
| 2321 |
|
| 2322 | static const char* note =
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 2323 | #ifdef TINYXML2_DEBUG
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 2324 | "DEBUG";
|
| 2325 | #else
|
| 2326 | "Release";
|
| 2327 | #endif
|
| 2328 |
|
| 2329 | #if defined( _MSC_VER )
|
| 2330 | const double duration = 1000.0 * (double)(end - start) / ((double)freq * (double)COUNT);
|
| 2331 | #else
|
| 2332 | const double duration = (double)(cend - cstart) / (double)COUNT;
|
| 2333 | #endif
|
| 2334 | printf("\nParsing dream.xml (%s): %.3f milli-seconds\n", note, duration);
|
| 2335 | }
|
| 2336 |
|
Elliott Hughes | d173c99 | 2019-01-10 14:51:35 -0800 | [diff] [blame] | 2337 | #if defined( _MSC_VER ) && defined( TINYXML2_DEBUG )
|
Narayan Kamath | 74c03bb | 2017-12-22 10:59:43 +0000 | [diff] [blame] | 2338 | {
|
| 2339 | _CrtMemCheckpoint( &endMemState );
|
| 2340 |
|
| 2341 | _CrtMemState diffMemState;
|
| 2342 | _CrtMemDifference( &diffMemState, &startMemState, &endMemState );
|
| 2343 | _CrtMemDumpStatistics( &diffMemState );
|
| 2344 |
|
| 2345 | {
|
| 2346 | int leaksBeforeExit = _CrtDumpMemoryLeaks();
|
| 2347 | XMLTest( "No leaks before exit?", FALSE, leaksBeforeExit );
|
| 2348 | }
|
| 2349 | }
|
| 2350 | #endif
|
| 2351 |
|
| 2352 | printf ("\nPass %d, Fail %d\n", gPass, gFail);
|
| 2353 |
|
| 2354 | return gFail;
|
| 2355 | }
|