mirror of
https://gitlab.com/freepascal.org/fpc/source.git
synced 2025-04-27 23:23:44 +02:00
672 lines
18 KiB
ObjectPascal
672 lines
18 KiB
ObjectPascal
{**********************************************************************
|
|
|
|
This file is part of the Free Component Library (FCL)
|
|
|
|
Test cases for TXMLReader class and its descendants
|
|
Copyright (c) 2012 by Sergei Gorelkin, sergei_gorelkin@mail.ru
|
|
|
|
Using tests from Mono test suite, written by
|
|
Jason Diamond (jason@injektilo.org)
|
|
Martin Willemoes Hansen (mwh@sysrq.dk)
|
|
(C) 2001, 2002 Jason Diamond http://injektilo.org/
|
|
|
|
See the file COPYING.FPC, included in this distribution,
|
|
for details about the copyright.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
**********************************************************************}
|
|
unit readertest;
|
|
{$mode objfpc}{$h+}
|
|
|
|
interface
|
|
implementation
|
|
|
|
uses
|
|
sysutils, fpcunit, testregistry, xmlutils, readerunit, XmlReader;
|
|
|
|
type
|
|
TXMLReaderTest = class(TXMLReaderTestBase)
|
|
public
|
|
procedure TestInitialState(r: TXMLReader);
|
|
procedure TestReadEmptySource(r: TXMLReader);
|
|
procedure TestRead(r: TXMLReader);
|
|
procedure TestReadAttributeValue(r: TXMLReader);
|
|
procedure TestReadAttributeValue2(r: TXMLReader);
|
|
procedure TestDTDProperties(r: TXMLReader);
|
|
procedure TestReadStringFromElement(r: TXMLReader);
|
|
procedure TestEmptyElement(r: TXMLReader);
|
|
procedure TestNestedEmptyTag(r: TXMLReader);
|
|
procedure TestNestedText(r: TXMLReader);
|
|
procedure TestEmptyElementWithAttributes(r: TXMLReader);
|
|
procedure TestPIBeforeRoot(r: TXMLReader);
|
|
procedure TestCommentBeforeRoot(r: TXMLReader);
|
|
procedure TestCDATA(r: TXMLReader);
|
|
procedure TestChildElementInNamespace(r: TXMLReader);
|
|
procedure TestMoveToElementFromAttribute(r: TXMLReader);
|
|
procedure TestMoveToElementFromElement(r: TXMLReader);
|
|
procedure TestMoveToNextAttribute(r: TXMLReader);
|
|
procedure TestResolveEntity(r: TXMLReader);
|
|
procedure TestLineInfo(r: TXMLReader);
|
|
published
|
|
procedure InitialState;
|
|
procedure ReadEmptySource;
|
|
procedure Read;
|
|
procedure ReadAttributeValue;
|
|
procedure ReadAttributeValue2;
|
|
procedure DTDProperties;
|
|
procedure ReadStringFromElement;
|
|
procedure EmptyElement;
|
|
procedure NestedEmptyTag;
|
|
procedure NestedText;
|
|
procedure EmptyElementWithAttributes;
|
|
procedure PIBeforeRoot;
|
|
procedure CommentBeforeRoot;
|
|
procedure CDATA;
|
|
procedure ChildElementInNamespace;
|
|
procedure MoveToElementFromAttribute;
|
|
procedure MoveToElementFromElement;
|
|
procedure MoveToNextAttribute;
|
|
procedure ResolveEntity;
|
|
procedure LineInfo;
|
|
end;
|
|
|
|
const
|
|
xml1 = '<root attr1=''value1''><child /></root>';
|
|
xml2 = '<root><foo/><bar>test.</bar></root>';
|
|
xml3 = '<root> test of <b>mixed</b> string.<![CDATA[ cdata string.]]></root>';
|
|
|
|
|
|
procedure TXMLReaderTest.TestInitialState(r: TXMLReader);
|
|
begin
|
|
AssertEquals('Depth', 0, r.Depth);
|
|
AssertEquals('EOF', False, r.EOF);
|
|
AssertEquals('HasValue', False, r.HasValue);
|
|
AssertEqualsW('LocalName', '', r.LocalName);
|
|
AssertEquals('NodeType', ntNone, r.NodeType);
|
|
AssertEquals('ReadState', rsInitial, r.ReadState);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.InitialState;
|
|
begin
|
|
DoTest(xml1, @TestInitialState);
|
|
end;
|
|
|
|
// TODO: this should fail only when conformancelevel=document
|
|
procedure TXMLReaderTest.TestReadEmptySource(r: TXMLReader);
|
|
begin
|
|
try
|
|
r.Read;
|
|
Fail('Read empty source succeeded');
|
|
except
|
|
end;
|
|
end;
|
|
|
|
procedure TXMLReaderTest.ReadEmptySource;
|
|
begin
|
|
DoTest('', @TestReadEmptySource);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestRead(r: TXMLReader);
|
|
begin
|
|
r.Read;
|
|
AssertEquals('<root>.NodeType', ntElement, r.NodeType);
|
|
AssertEqualsW('<root>.Name', 'root', r.Name);
|
|
AssertEquals('<root>.ReadState', rsInteractive, r.ReadState);
|
|
AssertEquals('<root>.Depth', 0, r.Depth);
|
|
|
|
// move to 'child'
|
|
r.Read;
|
|
AssertEquals('<child/>.Depth', 1, r.Depth);
|
|
AssertEquals('<child/>.NodeType', ntElement, r.NodeType);
|
|
AssertEqualsW('<child/>.Name', 'child', r.Name);
|
|
|
|
{ this differs from .net; we don't support EmptyElement }
|
|
r.Read;
|
|
AssertEquals('<child/>.EndDepth', 1, r.Depth);
|
|
AssertEquals('<child/>.EndNodeType', ntEndElement, r.NodeType);
|
|
AssertEqualsW('<child/>.EndName', 'child', r.Name);
|
|
|
|
r.Read;
|
|
AssertEquals('</root>.Depth', 0, r.Depth);
|
|
AssertEquals('</root>.NodeType', ntEndElement, r.NodeType);
|
|
AssertEqualsW('</root>.Name', 'root', r.Name);
|
|
|
|
r.Read;
|
|
AssertTrue('end.EOF', r.EOF);
|
|
AssertEquals('end.NodeType', ntNone, r.NodeType);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.Read;
|
|
begin
|
|
DoTest(xml1, @TestRead);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestReadAttributeValue(r: TXMLReader);
|
|
begin
|
|
r.Read; // root
|
|
AssertTrue('#1',r.MoveToFirstAttribute);
|
|
AssertNodeValues('#2', r,
|
|
ntAttribute,
|
|
1, 'attr', '', 'attr', '', 'value', true, 1, true);
|
|
AssertTrue('#3',r.ReadAttributeValue);
|
|
AssertNodeValues('#4', r,
|
|
ntText,
|
|
2, '', '', '', '', 'value', true, 1, true);
|
|
AssertTrue('#5',r.MoveToElement);
|
|
AssertNodeValues('#6', r,
|
|
ntElement,
|
|
0, 'root', '', 'root', '', '', false, 1, true);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.ReadAttributeValue;
|
|
begin
|
|
DoTest('<root attr="value"/>', @TestReadAttributeValue);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestReadAttributeValue2(r: TXMLReader);
|
|
begin
|
|
r.Read; // DTD
|
|
r.Read; // root
|
|
AssertTrue('#1',r.MoveToFirstAttribute);
|
|
AssertNodeValues('#2', r,
|
|
ntAttribute,
|
|
1, 'attr', '', 'attr', '', 'ax1y1x1b', true, 1, true);
|
|
AssertTrue('#3',r.ReadAttributeValue);
|
|
AssertNodeValues('#4', r,
|
|
ntText, 2,
|
|
'', '', '', '', 'a', true, 1, true);
|
|
|
|
AssertTrue('#5', r.ReadAttributeValue);
|
|
AssertNodeValues('#6', r,
|
|
ntEntityReference, 2,
|
|
'e1','','e1','', '', false, 1, true);
|
|
|
|
r.ResolveEntity;
|
|
AssertEquals('#6a', 2, r.Depth);
|
|
AssertEquals('#6b', ntEntityReference, r.nodeType);
|
|
|
|
AssertTrue('#6c', r.ReadAttributeValue);
|
|
AssertNodeValues('#6d', r,
|
|
ntEntityReference, 3,
|
|
'e2', '', 'e2', '', '', false, 1, true);
|
|
|
|
// Don't resolve it and advance to 'y1' textnode
|
|
AssertTrue('#6e', r.ReadAttributeValue);
|
|
AssertNodeValues('#6f', r,
|
|
ntText, 3,
|
|
'', '', '', '', 'y1', true, 1, true);
|
|
|
|
AssertTrue('#6g', r.ReadAttributeValue);
|
|
AssertNodeValues('#6h', r,
|
|
ntEntityReference, 3,
|
|
'e2', '', 'e2', '', '', false, 1, true);
|
|
|
|
r.ResolveEntity;
|
|
|
|
AssertTrue('#6i', r.ReadAttributeValue);
|
|
AssertNodeValues('#6j', r,
|
|
ntText, 4,
|
|
'','','','','x1', true, 1, true);
|
|
|
|
AssertTrue('#6k', r.ReadAttributeValue);
|
|
AssertNodeValues('#6l', r,
|
|
ntEndEntity, 3,
|
|
'e2','','e2','', '', false, 1, true);
|
|
|
|
AssertTrue('#7', r.ReadAttributeValue);
|
|
AssertNodeValues('#8', r,
|
|
ntEndEntity, 2,
|
|
'e1','','e1','', '', false, 1, true);
|
|
|
|
AssertTrue('#9', r.ReadAttributeValue);
|
|
|
|
AssertNodeValues('#10', r,
|
|
ntText, 2,
|
|
'', '', '', '', 'b', true, 1, true);
|
|
AssertFalse('#11', r.ReadAttributeValue);
|
|
|
|
AssertTrue('#12',r.MoveToElement);
|
|
AssertNodeValues('#13', r,
|
|
ntElement, 0,
|
|
'root', '', 'root', '', '', false, 1, true);
|
|
|
|
end;
|
|
|
|
procedure TXMLReaderTest.ReadAttributeValue2;
|
|
const
|
|
xml = '<!DOCTYPE root ['+
|
|
'<!ELEMENT root ANY>'+
|
|
'<!ENTITY e2 "x1">'+
|
|
'<!ENTITY e1 "&e2;y1&e2;">]>'+
|
|
'<root attr="a&e1;b"/>';
|
|
begin
|
|
DoTest(xml, @TestReadAttributeValue2);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestDTDProperties(r: TXMLReader);
|
|
begin
|
|
r.Read;
|
|
AssertNodeValues('#DTD',r,
|
|
ntDocumentType, 0,
|
|
'root', '', 'root', '', '<!ELEMENT root ANY><!ENTITY e2 "x1"><!ENTITY e1 "&e2;y1&e2;">', True, 0, False);
|
|
r.Read;
|
|
AssertNodeValues('#root',r,
|
|
ntElement, 0,
|
|
'root','', 'root', '', '', False,
|
|
1, True);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.DTDProperties;
|
|
const
|
|
xml = '<!DOCTYPE root ['+
|
|
'<!ELEMENT root ANY>'+
|
|
'<!ENTITY e2 "x1">'+
|
|
'<!ENTITY e1 "&e2;y1&e2;">]>'+
|
|
'<root attr="a&e1;b"/>';
|
|
begin
|
|
DoTest(xml, @TestDTDProperties);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestReadStringFromElement(r: TXMLReader);
|
|
var
|
|
s: XMLString;
|
|
begin
|
|
r.Read;
|
|
s := r.ReadString;
|
|
AssertEqualsW('readString.1.ret_val', ' test of ', s);
|
|
AssertEqualsW('readString.1.Name', 'b', r.Name);
|
|
s := r.ReadString;
|
|
AssertEqualsW('readString.2.ret_val', 'mixed', s);
|
|
AssertEquals('readString.2.nodeType', ntEndElement, r.NodeType);
|
|
s := r.ReadString; // does not advance
|
|
AssertEqualsW('readString.3.ret_val', '',s);
|
|
AssertEquals('readString.3.nodeType', ntEndElement, r.NodeType);
|
|
r.Read;
|
|
AssertEquals('readString.4.nodeType', ntText, r.NodeType);
|
|
AssertEqualsW('readString.4.Value', ' string.', r.Value);
|
|
s := r.ReadString;
|
|
AssertEqualsW('readString.5.ret_val', ' string. cdata string.', s);
|
|
AssertEquals('readString.5.nodeType', ntEndElement, r.NodeType);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.ReadStringFromElement;
|
|
begin
|
|
DoTest(xml3, @TestReadStringFromElement);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestEmptyElement(r: TXMLReader);
|
|
begin
|
|
AssertStartDocument(r);
|
|
AssertNode('#1', r, ntElement, 0,
|
|
'foo', '', 'foo', '', // name, prefix, localname, nsuri
|
|
'', 0);
|
|
AssertNode('#2', r, ntEndElement, 0,
|
|
'foo', '', 'foo', '',
|
|
'', 0);
|
|
AssertEndDocument(r);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.EmptyElement;
|
|
begin
|
|
DoTest('<foo/>', @TestEmptyElement);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestNestedEmptyTag(r: TXMLReader);
|
|
begin
|
|
AssertStartDocument(r);
|
|
AssertNode('#1', r,
|
|
ntElement, 0,
|
|
'foo', '', 'foo', '',
|
|
'', 0);
|
|
AssertNode('#2', r,
|
|
ntElement, 1,
|
|
'bar', '', 'bar', '',
|
|
'', 0);
|
|
AssertNode('#3', r,
|
|
ntEndElement, 1,
|
|
'bar', '', 'bar', '',
|
|
'', 0);
|
|
AssertNode('#4', r,
|
|
ntEndElement, 0,
|
|
'foo', '', 'foo', '',
|
|
'', 0);
|
|
AssertEndDocument(r);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.NestedEmptyTag;
|
|
begin
|
|
DoTest('<foo><bar/></foo>', @TestNestedEmptyTag);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestNestedText(r: TXMLReader);
|
|
begin
|
|
AssertStartDocument(r);
|
|
AssertNode('#1', r,
|
|
ntElement, 0,
|
|
'foo', '', 'foo', '',
|
|
'', 0);
|
|
AssertNode('#2', r,
|
|
ntText, 1,
|
|
'', '', '', '',
|
|
'bar', 0);
|
|
AssertNode('#3', r,
|
|
ntEndElement, 0,
|
|
'foo', '', 'foo', '',
|
|
'', 0);
|
|
AssertEndDocument(r);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.NestedText;
|
|
begin
|
|
DoTest('<foo>bar</foo>', @TestNestedText);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestEmptyElementWithAttributes(r: TXMLReader);
|
|
begin
|
|
AssertStartDocument(r);
|
|
AssertNode('#1', r,
|
|
ntElement, 0,
|
|
'foo', '', 'foo', '',
|
|
'', 4);
|
|
AssertAttribute(r,
|
|
'bar', '', 'bar', '',
|
|
'baz');
|
|
AssertAttribute(r,
|
|
'quux', '', 'quux', '',
|
|
'quuux');
|
|
AssertAttribute(r, // non-existing attribute
|
|
'notexist', '', 'notexist', '',
|
|
'');
|
|
AssertAttribute(r, // non-existing prefixed attribute
|
|
'x:bar', 'x', 'bar', 'urn:xfoo',
|
|
'');
|
|
AssertAttribute(r,
|
|
'x:foo', 'x', 'foo', 'urn:xfoo',
|
|
'x-foo');
|
|
AssertNode('#2', r,
|
|
ntEndElement, 0,
|
|
'foo', '', 'foo', '',
|
|
'', 0);
|
|
AssertEndDocument(r);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.EmptyElementWithAttributes;
|
|
begin
|
|
DoTest('<foo bar="baz" quux=''quuux'' x:foo=''x-foo'' xmlns:x = ''urn:xfoo'' />',
|
|
@TestEmptyElementWithAttributes);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestPIBeforeRoot(r: TXMLReader);
|
|
begin
|
|
AssertStartDocument(r);
|
|
AssertNode('#1', r,
|
|
ntProcessingInstruction, 0,
|
|
'foo', '', 'foo', '',
|
|
'bar', 0);
|
|
AssertNode('#2', r,
|
|
ntElement, 0,
|
|
'baz', '', 'baz', '',
|
|
'', 0);
|
|
AssertNode('#3', r,
|
|
ntEndElement, 0,
|
|
'baz', '', 'baz', '',
|
|
'', 0);
|
|
AssertEndDocument(r);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.PIBeforeRoot;
|
|
begin
|
|
DoTest('<?foo bar?><baz/>', @TestPIBeforeRoot);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestCommentBeforeRoot(r: TXMLReader);
|
|
begin
|
|
AssertStartDocument(r);
|
|
AssertNode('#1', r,
|
|
ntComment, 0,
|
|
'','','','',
|
|
'foo', 0);
|
|
AssertNode('#2', r,
|
|
ntElement, 0,
|
|
'bar', '', 'bar', '',
|
|
'', 0);
|
|
AssertNode('#3', r,
|
|
ntEndElement, 0,
|
|
'bar', '', 'bar', '',
|
|
'', 0);
|
|
AssertEndDocument(r);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.CommentBeforeRoot;
|
|
begin
|
|
DoTest('<!--foo--><bar/>', @TestCommentBeforeRoot);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestCDATA(r: TXMLReader);
|
|
begin
|
|
AssertStartDocument(r);
|
|
AssertNode('#1', r,
|
|
ntElement, 0,
|
|
'foo', '', 'foo', '',
|
|
'', 0);
|
|
AssertNode('#2', r,
|
|
ntCDATA, 1,
|
|
'','','','',
|
|
'<>&', 0);
|
|
AssertNode('#3', r,
|
|
ntEndElement, 0,
|
|
'foo', '', 'foo', '',
|
|
'',0);
|
|
AssertEndDocument(r);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.CDATA;
|
|
begin
|
|
DoTest('<foo><![CDATA[<>&]]></foo>', @TestCDATA);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.ChildElementInNamespace;
|
|
begin
|
|
DoTest('<foo:bar xmlns:foo=''http://foo/''><baz:quux xmlns:baz=''http://baz/'' /></foo:bar>', @TestChildElementInNamespace);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestChildElementInNamespace(r: TXMLReader);
|
|
begin
|
|
AssertStartDocument(r);
|
|
|
|
AssertNode('#1', r,
|
|
ntElement, 0,
|
|
'foo:bar', 'foo', 'bar', 'http://foo/',
|
|
'', 1);
|
|
|
|
AssertAttribute(r,
|
|
'xmlns:foo', 'xmlns', 'foo', 'http://www.w3.org/2000/xmlns/',
|
|
'http://foo/');
|
|
|
|
AssertEqualsW('http://foo/', r.LookupNamespace('foo'));
|
|
|
|
AssertNode('#2', r,
|
|
ntElement, 1,
|
|
'baz:quux', 'baz', 'quux', 'http://baz/',
|
|
'', 1);
|
|
|
|
AssertAttribute(r,
|
|
'xmlns:baz', 'xmlns', 'baz', 'http://www.w3.org/2000/xmlns/',
|
|
'http://baz/');
|
|
|
|
AssertEqualsW('http://foo/', r.LookupNamespace ('foo'));
|
|
AssertEqualsW('http://baz/', r.LookupNamespace ('baz'));
|
|
|
|
AssertNode('#3', r,
|
|
ntEndElement, 1,
|
|
'baz:quux', 'baz', 'quux', 'http://baz/',
|
|
'', 0);
|
|
|
|
AssertNode('#4', r,
|
|
ntEndElement, 0,
|
|
'foo:bar', 'foo', 'bar', 'http://foo/',
|
|
'', 0);
|
|
|
|
AssertEqualsW('http://foo/', r.LookupNamespace('foo'));
|
|
AssertNull('', r.LookupNamespace('baz'));
|
|
|
|
AssertEndDocument(r);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestMoveToElementFromAttribute(r: TXMLReader);
|
|
begin
|
|
AssertTrue(r.Read);
|
|
AssertEquals(ntElement, r.NodeType);
|
|
AssertTrue(r.MoveToFirstAttribute);
|
|
AssertEquals(ntAttribute, r.NodeType);
|
|
AssertTrue(r.MoveToElement);
|
|
AssertEquals(ntElement, r.NodeType);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.MoveToElementFromAttribute;
|
|
begin
|
|
DoTest('<foo bar="baz" />', @TestMoveToElementFromAttribute);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestMoveToElementFromElement(r: TXMLReader);
|
|
begin
|
|
AssertTrue(r.Read);
|
|
AssertEquals(ntElement, r.NodeType);
|
|
AssertFalse(r.MoveToElement);
|
|
AssertEquals(ntElement, r.NodeType);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.MoveToElementFromElement;
|
|
begin
|
|
DoTest('<foo bar="baz" />', @TestMoveToElementFromElement);
|
|
end;
|
|
|
|
// TODO: moveToFirstAttribute_negative
|
|
// moveToNextAttribute_negative
|
|
|
|
procedure TXMLReaderTest.TestMoveToNextAttribute(r: TXMLReader);
|
|
begin
|
|
AssertStartDocument(r);
|
|
AssertNode('#1', r,
|
|
ntElement, 0,
|
|
'foo', '', 'foo', '',
|
|
'', 2);
|
|
AssertAttribute(r,
|
|
'bar', '', 'bar', '',
|
|
'baz');
|
|
AssertAttribute(r,
|
|
'quux', '', 'quux', '',
|
|
'quuux');
|
|
AssertTrue(r.MoveToNextAttribute);
|
|
AssertEqualsW('bar', r.Name);
|
|
AssertEqualsW('baz', r.Value);
|
|
AssertTrue(r.MoveToNextAttribute);
|
|
AssertEqualsW('quux', r.Name);
|
|
AssertEqualsW('quuux', r.Value);
|
|
AssertFalse(r.MoveToNextAttribute);
|
|
AssertTrue(r.MoveToElement);
|
|
AssertNodeValues('#1', r,
|
|
ntElement, 0,
|
|
'foo','','foo','',
|
|
'', False, 2, True);
|
|
AssertNode('#2', r,
|
|
ntEndElement, 0,
|
|
'foo','','foo','',
|
|
'', 0);
|
|
AssertEndDocument(r);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.MoveToNextAttribute;
|
|
begin
|
|
DoTest('<foo bar="baz" quux=''quuux''/>', @TestMoveToNextAttribute);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestResolveEntity(r: TXMLReader);
|
|
begin
|
|
r.Read; // DTD
|
|
r.Read; // root
|
|
r.Read; // &ent;
|
|
AssertEquals('#1', ntEntityReference, r.NodeType);
|
|
AssertEquals('#2', 1, r.Depth);
|
|
r.ResolveEntity;
|
|
// stays on entity reference
|
|
AssertEquals('#3', ntEntityReference, r.NodeType);
|
|
AssertEquals('#3a', 1, r.Depth);
|
|
r.Read;
|
|
// now advances to replacement text
|
|
AssertEquals('#4', ntText, r.NodeType);
|
|
AssertEquals('#5', 2, r.Depth);
|
|
AssertEqualsW('#6', 'entity string', r.Value);
|
|
r.Read;
|
|
AssertEquals('#7', ntEndEntity, r.NodeType);
|
|
AssertEquals('#8', 1, r.Depth);
|
|
AssertEqualsW('#9', '', r.Value);
|
|
|
|
r.Read; // &ent2;
|
|
AssertEquals('#10', ntEntityReference, r.NodeType);
|
|
AssertEquals('#11', 1, r.Depth);
|
|
r.ResolveEntity;
|
|
// stays on entity reference
|
|
AssertEquals('#12', ntEntityReference, r.NodeType);
|
|
AssertEquals('#12a', 1, r.Depth);
|
|
// now advances to element node
|
|
r.Read;
|
|
AssertEquals('#13', ntElement, r.NodeType);
|
|
AssertEquals('#14', 2, r.Depth);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.ResolveEntity;
|
|
const
|
|
xml='<!DOCTYPE root [<!ELEMENT root (#PCDATA|foo)*>'+
|
|
'<!ENTITY ent "entity string">'+
|
|
'<!ENTITY ent2 "<foo/><foo/>">]>'+
|
|
'<root>&ent;&ent2;</root>';
|
|
begin
|
|
DoTest(xml, @TestResolveEntity);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.TestLineInfo(r: TXMLReader);
|
|
var
|
|
aux: IXmlLineInfo;
|
|
begin
|
|
if not Supports(r, IXmlLineInfo, aux) then
|
|
Exit;
|
|
AssertEquals('#1a', 0, aux.LineNumber);
|
|
AssertEquals('#1b', 0, aux.LinePosition);
|
|
r.MoveToContent;
|
|
AssertEquals('#2a', 1, aux.LineNumber);
|
|
AssertEquals('#2b', 2, aux.LinePosition);
|
|
r.Read;
|
|
AssertEquals('#3a', 1, aux.LineNumber);
|
|
AssertEquals('#3b', 7, aux.LinePosition);
|
|
r.Read;
|
|
r.Read;
|
|
// r.ReadOuterXml;
|
|
AssertEquals('#4a', 1, aux.LineNumber);
|
|
AssertEquals('#4b', 22, aux.LinePosition);
|
|
r.Read;
|
|
r.Read;
|
|
// r.ReadInnerXml;
|
|
AssertEquals('#5a', 1, aux.LineNumber);
|
|
AssertEquals('#5b', 34, aux.LinePosition);
|
|
r.Read; { now at EOF }
|
|
AssertEquals('#6a', 1, aux.LineNumber);
|
|
AssertEquals('#6b', 38, aux.LinePosition);
|
|
r.Close;
|
|
AssertEquals('#7a', 0, aux.LineNumber);
|
|
AssertEquals('#7b', 0, aux.LinePosition);
|
|
end;
|
|
|
|
procedure TXMLReaderTest.LineInfo;
|
|
begin
|
|
DoTest('<all><hello></hello><bug></bug></all>', @TestLineInfo);
|
|
end;
|
|
|
|
initialization
|
|
RegisterTest(TXMLReaderTest);
|
|
|
|
end.
|