+# coding: binary

+require "test/unit/testcase"

+

+require "rexml/document"

+require "rexml/parseexception"

+require "rexml/formatters/default"

+

+class ContribTester < Test::Unit::TestCase

+ include REXML

+

+XML_STRING_01 = <<DELIMITER

+<?xml version="1.0" encoding="UTF-8"?>

+<biblio>

+ <entry type="Book">

+ <author>Thomas, David; Hunt, Andrew</author>

+ <language>english</language>

+ <publisher>Addison-Wesley</publisher>

+ <title>Programming Ruby. The Pragmatic Programmer's Guide</title>

+ <year>2000</year>

+ </entry>

+ <entry type="Book">

+ <author>Blammo, Blah</author>

+ <language>english</language>

+ <publisher>Hubbabubba</publisher>

+ <title>Foozboozer's Life</title>

+ <type>Book</type>

+ <year>2002</year>

+ </entry>

+</biblio>

+DELIMITER

+

+XML_STRING_02 = <<DELIMITER

+<biblio>

+ <entry type="Book">

+ <language>english</language>

+ <publisher>Addison-Wesley</publisher>

+ <title>Programming Ruby. The Pragmatic Programmer's Guide</title>

+ <type>Book</type>

+ <year>2000</year>

+ </entry>

+ <entry type="Book">

+ <author>Blammo, Blah</author>

+ <language>english</language>

+ <publisher>Hubbabubba</publisher>

+ <title>Foozboozer's Life</title>

+ <type>Book</type>

+ <year>2002</year>

+ </entry>

+</biblio>

+DELIMITER

+

+ # Tobias Reif <[email protected]>

+ def test_bad_doctype_Tobias

+ source = <<-EOF

+ <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN"

+ "http://www.w3.org/TR/SVG/DTD/svg10.dtd"

+ [

+ <!-- <!ENTITY % fast-slow "0 0 .5 1">-->

+ <!--<!ENTITY % slow-fast ".5 0 1 1">-->

+ <!ENTITY hover_ani

+ '<animateTransform attributeName="transform"

+ type="scale" restart="whenNotActive" values="1;0.96"

+ dur="0.5s" calcMode="spline" keySplines="0 0 .5 1"

+ fill="freeze" begin="mouseover"/>

+ <animateTransform attributeName="transform"

+ type="scale" restart="whenNotActive" values="0.96;1"

+ dur="0.5s" calcMode="spline" keySplines=".5 0 1 1"

+ fill="freeze" begin="mouseover+0.5s"/>'

+ >

+ ]

+ >

+ EOF

+ doc = REXML::Document.new source

+ doc.write(out="")

+ assert(out[/>'>/] != nil, "Couldn't find >'>")

+ assert(out[/\]>/] != nil, "Couldn't find ]>")

+ end

+

+ # Peter Verhage

+ def test_namespace_Peter

+ source = <<-EOF

+ <?xml version="1.0"?>

+ <config:myprog-config xmlns:config="http://someurl/program/version">

+ <!-- main options -->

+ <config:main>

+ <config:parameter name="name" value="value"/>

+ </config:main>

+ </config:myprog-config>

+ EOF

+ doc = REXML::Document.new source

+ assert_equal "myprog-config", doc.root.name

+ count = 0

+ REXML::XPath.each(doc, "x:myprog-config/x:main/x:parameter",

+ {"x"=>"http://someurl/program/version"}) { |element|

+ assert_equal "name", element.attributes["name"]

+ count += 1;

+ }

+ assert_equal 1, count

+ assert_equal "myprog-config", doc.elements["config:myprog-config"].name

+ end

+

+ # Tobias Reif <[email protected]>

+ def test_complex_xpath_Tobias

+ source = <<-EOF

+ <root>

+ <foo>

+ <bar style="baz"/>

+ <blah style="baz"/>

+ <blam style="baz"/>

+ </foo>

+ <wax>

+ <fudge>

+ <noodle/>

+ </fudge>

+ </wax>

+ </root>

+ EOF

+ # elements that have child elements

+ # but not grandchildren

+ # and not children that don't have a style attribute

+ # and not children that have a unique style attribute

+ complex_path = "*[* "+

+ "and not(*/node()) "+

+ "and not(*[not(@style)]) "+

+ "and not(*/@style != */@style)]"

+ doc = REXML::Document.new source

+ results = REXML::XPath.match( doc.root, complex_path )

+ assert(results)

+ assert_equal 1, results.size

+ assert_equal "foo", results[0].name

+ end

+

+ # "Chris Morris" <[email protected]>

+ def test_extra_newline_on_read_Chris

+ text = 'test text'

+ e = REXML::Element.new('Test')

+ e.add_text(text)

+ REXML::Formatters::Default.new.write(e,out="")

+

+ doc = REXML::Document.new(out)

+ outtext = doc.root.text

+

+ assert_equal(text, outtext)

+ end

+

+ # Tobias Reif <[email protected]>

+ def test_other_xpath_Tobias

+ schema = <<-DELIM

+ <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"

+ elementFormDefault="qualified">

+ <xs:element name="rect">

+ <xs:complexType>

+ <xs:attribute name="width" type="xs:byte" use="required"/>

+ <xs:attribute name="height" type="xs:byte" use="required"/>

+ </xs:complexType>

+ </xs:element>

+ <xs:element name="svg">

+ <xs:complexType>

+ <xs:sequence>

+ <xs:element ref="rect"/>

+ </xs:sequence>

+ </xs:complexType>

+ </xs:element>

+ </xs:schema>

+ DELIM

+

+ doc = REXML::Document.new schema

+

+ result = REXML::XPath.first(doc.root, 'xs:element[descendant::xs:element[@ref]]')

+ assert result

+ assert_equal "svg", result.attributes['name']

+ result = REXML::XPath.first(doc, 'element[descendant::element[@ref]]')

+ assert_nil result

+ end

+

+ #this first test succeeds, to check if stuff is set up correctly

+ def test_xpath_01_TobiasReif

+ doc = Document.new XML_STRING_01.dup

+ desired_result = Document.new '<author>Thomas, David; Hunt, Andrew</author>'

+ xpath = '//author'

+ result = XPath.first(doc, xpath)

+ assert_equal desired_result.to_s, result.to_s

+ end

+

+ def test_xpath_whitespace_TobiasReif

+ # same as above, with whitespace in XPath

+ doc = Document.new(XML_STRING_01.dup)

+ desired_result = Document.new('<author>Thomas, David; Hunt, Andrew</author>')

+ xpath = "\/\/author\n \n"

+ result = XPath.first(doc, xpath)

+ failure_message = "\n[[[TR: AFAIK, whitespace should be allowed]]]\n"

+ assert_equal(desired_result.to_s, result.to_s, failure_message)

+ end

+

+ def test_xpath_02_TobiasReif

+ doc = Document.new XML_STRING_01.dup

+ desired_result = Document.new '<author>Thomas, David; Hunt, Andrew</author>'

+ # Could that quirky

+ # Programmer',&quot;'&quot;,'s

+ # be handled automatically, somehow?

+ # Or is there a simpler way? (the below XPath should match the author element above,

+ # AFAIK; I tested it inside an XSLT)

+ xpath = %q{/biblio/entry[

+ title/text()=concat('Programming Ruby. The Pragmatic Programmer',"'",'s Guide')

+ and

+ year='2000'

+ ]/author}

+ result = XPath.first(doc, xpath)

+ failure_message = "\nHow to handle the apos inside the string inside the XPath?\nXPath = #{xpath}\n"

+ assert_equal desired_result.to_s, result.to_s, failure_message

+ end

+

+ def test_xpath_03_TobiasReif

+ doc = Document.new XML_STRING_02.dup

+ desired_result_string = "<entry type='Book'>

+ <language>english</language>

+ <publisher>Addison-Wesley</publisher>

+ <title>Programming Ruby. The Pragmatic Programmer's Guide</title>

+ <type>Book</type>

+ <year>2000</year>

+ </entry>"

+ desired_result_tree = Document.new desired_result_string

+ xpath = "/biblio/entry[not(author)]"

+ result = XPath.first(doc, xpath)

+ assert_equal desired_result_string, result.to_s

+ end

+

+ def test_umlaut

+ koln_iso = "K\xf6ln"

+ koln_utf = "K\xc3\xb6ln"

+ source_iso = "<?xml version='1.0' encoding='ISO-8859-1'?><test>#{koln_iso}</test>"

+ source_utf = "<?xml version='1.0' encoding='UTF-8'?><test>#{koln_utf}</test>"

+

+ if String.method_defined? :encode

+ koln_iso.force_encoding('iso-8859-1')

+ koln_utf.force_encoding('utf-8')

+ source_iso.force_encoding('iso-8859-1')

+ source_utf.force_encoding('utf-8')

+ end

+

+ doc = REXML::Document.new(source_iso)

+ assert_equal('ISO-8859-1', doc.xml_decl.encoding)

+ assert_equal(koln_utf, doc.root.text)

+ doc.write(out="")

+ assert_equal(source_iso, out )

+ doc.xml_decl.encoding = 'UTF-8'

+ doc.write(out="")

+ assert_equal(source_utf, out)

+

+ doc = Document.new <<-EOF

+<?xml version="1.0" encoding="ISO-8859-1"?>

+<intranet>

+<position><aktuell datum="01-10-11">Technik</aktuell></position>

+<hauptspalte>

+<headline>Technik</headline>

+Die Technik ist das R�ckgrat der meisten Gesch�ftsprozesse bei Home of the Brave. Deshalb sollen hier alle relevanten technischen Abl�ufe, Daten und Einrichtungen beschrieben werden, damit jeder im Bedarfsfall die n�tigen Informationen, Anweisungen und Verhaltensempfehlungen nachlesen und/oder abrufen kann.

+</hauptspalte>

+<nebenspalte>

+ <link ziel="Flash/">Flash</link><umbruch/>

+ N�tzliches von Flashern f�r Flasher.<umbruch/>

+ <link neu="ja" ziel="Cvs/">CVS-FAQ</link><umbruch/>

+ FAQ zur Benutzung von CVS bei HOB

+</nebenspalte>

+</intranet>

+EOF

+ tn = XPath.first(doc, "//nebenspalte/text()[2]")

+ expected_iso = "N�tzliches von Flashern f�r Flasher."

+ expected_utf = expected_iso.unpack('C*').pack('U*')

+ if expected_utf.respond_to? :encode

+ expected_iso.force_encoding("iso-8859-1")

+ expected_utf.force_encoding(Encoding::UTF_8)

+ end

+ assert_equal(expected_utf, tn.to_s.strip)

+ f = REXML::Formatters::Default.new

+ f.write( tn, Output.new(o = "", "ISO-8859-1") )

+ assert_equal(expected_iso, o.strip)

+

+ doc = Document.new File.new('test/data/xmlfile-bug.xml')

+ tn = XPath.first(doc, "//nebenspalte/text()[2]")

+ assert_equal(expected_utf, tn.to_s.strip)

+ f.write( tn, Output.new(o = "", "ISO-8859-1") )

+ assert_equal(expected_iso, o.strip)

+ end

+

+ def test_element_cloning_namespace_Chris

+ aDoc = REXML::Document.new '<h1 tpl:content="title" xmlns:tpl="1">Dummy title</h1>'

+

+ anElement = anElement = aDoc.elements[1]

+ elementAttrPrefix = anElement.attributes.get_attribute('content').prefix

+

+ aClone = anElement.clone

+ cloneAttrPrefix = aClone.attributes.get_attribute('content').prefix

+

+ assert_equal( elementAttrPrefix , cloneAttrPrefix )

+ end

+

+ def test_namespaces_in_attlist_tobias

+ in_string = File.open('test/data/foo.xml', 'r') do |file|

+ file.read

+ end

+

+ doc = Document.new in_string

+

+ assert_nil XPath.first(doc,'//leg')

+ assert_equal 'http://www.foo.com/human', doc.root.elements[1].namespace

+ assert_equal 'human leg',

+ XPath.first(doc, '//x:leg/text()', {'x'=>'http://www.foo.com/human'}).to_s

+ end

+

+ # Alun ap Rhisiart

+ def test_less_than_in_element_content

+ source = File.new('test/data/ProductionSupport.xml')

+ h = Hash.new

+ doc = REXML::Document.new source

+ doc.elements.each("//CommonError") { |el|

+ h[el.elements['Key'].text] = 'okay'

+ }

+ assert(h.include?('MotorInsuranceContract(Object)>>#error:'))

+ end

+

+ # XPaths provided by Thomas Sawyer

+ def test_various_xpath

+ #@doc = REXML::Document.new('<r a="1"><p><c b="2"/></p></r>')

+ doc = REXML::Document.new('<r a="1"><p><c b="2">3</c></p></r>')

+

+ [['/r', REXML::Element],

+ ['/r/p/c', REXML::Element],

+ ['/r/attribute::a', Attribute],

+ ['/r/@a', Attribute],

+ ['/r/attribute::*', Attribute],

+ ['/r/@*', Attribute],

+ ['/r/p/c/attribute::b', Attribute],

+ ['/r/p/c/@b', Attribute],

+ ['/r/p/c/attribute::*', Attribute],

+ ['/r/p/c/@*', Attribute],

+ ['//c/attribute::b', Attribute],

+ ['//c/@b', Attribute],

+ ['//c/attribute::*', Attribute],

+ ['//c/@*', Attribute],

+ ['.//node()', REXML::Node ],

+ ['.//node()[@a]', REXML::Element ],

+ ['.//node()[@a="1"]', REXML::Element ],

+ ['.//node()[@b]', REXML::Element ], # no show, why?

+ ['.//node()[@b="2"]', REXML::Element ]

+ ].each do |xpath,kind|

+ begin

+ REXML::XPath.each( doc, xpath ) do |what|

+ assert_kind_of( kind, what, "\n\nWrong type (#{what.class}) returned for #{xpath} (expected #{kind.name})\n\n" )

+ end

+ rescue Exception

+ puts "PATH WAS: #{xpath}"

+ raise

+ end

+ end

+

+ [

+ ['/r', 'attribute::a', Attribute ],

+ ['/r', '@a', Attribute ],

+ ['/r', 'attribute::*', Attribute ],

+ ['/r', '@*', Attribute ],

+ ['/r/p/c', 'attribute::b', Attribute ],

+ ['/r/p/c', '@b', Attribute ],

+ ['/r/p/c', 'attribute::*', Attribute ],

+ ['/r/p/c', '@*', Attribute ]

+ ].each do |nodepath, xpath, kind|

+ begin

+ context = REXML::XPath.first(doc, nodepath)

+ REXML::XPath.each( context, xpath ) do |what|

+ assert_kind_of kind, what, "Wrong type (#{what.class}) returned for #{xpath} (expected #{kind.name})\n"

+ end

+ rescue Exception

+ puts "PATH WAS: #{xpath}"

+ raise

+ end

+ end

+ end

+

+ def test_entities_Holden_Glova

+ document = <<-EOL

+ <?xml version="1.0" encoding="UTF-8"?>

+ <!DOCTYPE rubynet [

+ <!ENTITY rbconfig.MAJOR "1">

+ <!ENTITY rbconfig.MINOR "7">

+ <!ENTITY rbconfig.TEENY "2">

+ <!ENTITY rbconfig.ruby_version "&rbconfig.MAJOR;.&rbconfig.MINOR;">

+ <!ENTITY rbconfig.arch "i386-freebsd5">

+ <!ENTITY rbconfig.prefix "/usr/local">

+ <!ENTITY rbconfig.libdir "&rbconfig.prefix;/lib">

+ <!ENTITY rbconfig.includedir "&rbconfig.prefix;/include">

+ <!ENTITY rbconfig.sitedir "&rbconfig.prefix;/lib/ruby/site_ruby">

+ <!ENTITY rbconfig.sitelibdir "&rbconfig.sitedir;/&rbconfig.ruby_version;">

+ <!ENTITY rbconfig.sitearchdir "&rbconfig.sitelibdir;/&rbconfig.arch;">

+ ]>

+ <rubynet>

+ <pkg version="version1.0">

+ <files>

+ <file>

+ <filename>uga.rb</filename>

+ <mode>0444</mode>

+ <path>&rbconfig.libdir;/rexml</path>

+ <content encoding="xml">... the file here</content>

+ </file>

+ <file>

+ <filename>booga.h</filename>

+ <mode>0444</mode>

+ <path>&rbconfig.includedir;</path>

+ <content encoding="xml">... the file here</content>

+ </file>

+ <file>

+ <filename>foo.so</filename>

+ <mode>0555</mode>

+ <path>&rbconfig.sitearchdir;/rexml</path>

+ <content encoding="mime64">Li4uIHRoZSBmaWxlIGhlcmU=\n</content>

+ </file>

+ </files>

+ </pkg>

+ </rubynet>

+ EOL

+

+ file_xpath = '/rubynet/pkg/files/file'

+

+ root = REXML::Document.new(document)

+

+ root.elements.each(file_xpath) do |metadata|

+ text = metadata.elements['path'].get_text.value

+ assert text !~ /&rbconfig/, "'#{text}' failed"

+ end

+

+ #Error occurred in test_package_file_opens(TC_PackageInstall):

+ # ArgumentError:

+ #illegal access mode &rbconfig.prefix;/lib/rexml

+ #

+ #[synack@Evergreen] src $ ruby --version

+ #ruby 1.6.7 (2002-03-01) [i686-linux-gnu]

+ #

+ #It looks like it expanded the first entity, but didn't reparse it for more

+ #entities. possible bug - or have I mucked this up?

+ end

+

+ def test_whitespace_after_xml_decl

+ d = Document.new <<EOL

+<?xml version='1.0'?>

+ <blo>

+ <wak>

+ </wak>

+</blo>

+EOL

+ end

+

+ def test_external_entity

+ xp = '//channel/title'

+

+ %w{data/working.rss data/broken.rss}.each do |path|

+ File.open(File.join( "test", path )) do |file|

+ doc = REXML::Document.new file.readlines.join('')

+

+ # check to make sure everything is kosher

+ assert_equal( doc.root.class, REXML::Element )

+ assert_equal( doc.root.elements.class, REXML::Elements )

+

+ # get the title of the feed

+ assert( doc.root.elements[xp].kind_of?( REXML::Element ) )

+ end

+ end

+ end

+

+ def test_maintain_dtd

+ src = %q{<?xml version="1.0" encoding="UTF-8"?>

+<!DOCTYPE ivattacks SYSTEM "../../ivacm.dtd" [

+<!ENTITY % extern-packages SYSTEM "../../ivpackages.dtd">

+<!ENTITY % extern-packages SYSTEM "../../common-declarations.dtd">

+%extern-packages;

+%extern-common;

+]>}

+ doc = Document.new( src )

+ doc.write( out="" )

+ src = src.tr('"', "'")

+ out = out.tr('"', "'")

+ assert_equal( src, out )

+ end

+

+ def test_text_nodes_nomatch

+ source = "<root><child>test</child></root>"

+ d = REXML::Document.new( source )

+ r = REXML::XPath.match( d, %q{/root/child[text()="no-test"]} )

+ assert_equal( 0, r.size )

+ end

+

+ def test_raw_Terje_Elde

+ f = REXML::Formatters::Default.new

+ txt = 'abc&#248;def'

+ a = Text.new( txt,false,nil,true )

+ f.write(a,out="")

+ assert_equal( txt, out )

+

+ txt = '<sean><russell>abc&#248;def</russell></sean>'

+ a = Document.new( txt, { :raw => ["russell"] } )

+ f.write(a,out="")

+ assert_equal( txt, out )

+ end

+

+ def test_indenting_error

+ a=Element.new("test1")

+ b=Element.new("test2")

+ c=Element.new("test3")

+ b << c

+ a << b

+

+ REXML::Formatters::Pretty.new.write(a,s="")

+ end

+

+ def test_pos

+ testfile = "/tmp/tidal#{$$}"

+ testdata = %Q{<calibration>

+<section name="parameters">

+<param name="barpress">760</param>

+<param name="hertz">50</param>

+</section>

+</calibration>

+}

+

+ File.open(testfile, 'w') do |f|

+ f.puts testdata

+ end

+ File.open(testfile) do |f|

+ d = REXML::Document.new(f)

+ end

+ #File.unlink(testfile)

+ end

+

+ def test_deep_clone

+ a = Document.new( '<?xml version="1.0"?><!DOCTYPE html PUBLIC

+ "-//W3C//DTD

+ XHTML 1.0 Transitional//EN"

+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html

+ xmlns="http:///www.w3.org/1999/xhtml"></html>' )

+ b = a.deep_clone

+ assert_equal a.to_s, b.to_s

+ end

+

+ def test_double_escaping

+ data = '<title>AT&amp;T</title>'

+ xml = "<description><![CDATA[#{data}]]></description>"

+

+ doc = REXML::Document.new(xml)

+ description = doc.find {|e| e.name=="description"}

+ assert_equal data, description.text

+ end

+

+ def test_ticket_12

+ cfg = "<element><anotherelement><child1>a</child1><child2>b</child2></anotherelement></element>"

+

+ config = REXML::Document.new( cfg )

+

+ assert_equal( "a", config.elements[ "//child1" ].text )

+ end

+

+=begin

+ # This is a silly test, and is low priority

+ def test_namespace_serialization_tobi_reif

+ doc = Document.new '<doc xmlns:b="http://www.foo.foo">

+ <b:p/>

+</doc>'

+ ns = 'http://www.foo.foo'

+ ns_declaration={'f'=>ns}

+ returned = XPath.match(doc,'//f:p',ns_declaration)

+ # passes:

+ assert( (returned[0].namespace==ns), 'namespace should be '+ns)

+ serialized = returned.to_s

+ serialized_and_parsed = Document.new(serialized)

+ puts 'serialized: '+serialized

+ # ... currently brings <b:p/>

+ # prefix b is undeclared (!)

+ assert( (serialized_and_parsed.namespace==ns),

+ 'namespace should still be '+ns.inspect+

+ ' and not '+serialized_and_parsed.namespace.inspect)

+ # ... currently results in a failure:

+ # 'namespace should still be "http://www.foo.foo" and not ""'

+ end

+=end

+end