mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
2a15d25a59
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@29285 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
583 lines
18 KiB
Ruby
583 lines
18 KiB
Ruby
# coding: binary
|
||
|
||
require "rexml_test_utils"
|
||
|
||
require "rexml/document"
|
||
require "rexml/parseexception"
|
||
require "rexml/formatters/default"
|
||
|
||
class ContribTester < Test::Unit::TestCase
|
||
include REXMLTestUtils
|
||
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 <tobiasreif@pinkjuice.com>
|
||
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 <tobiasreif@pinkjuice.com>
|
||
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" <chrismo@charter.net>
|
||
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 <tobiasreif@pinkjuice.com>
|
||
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',"'",'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<63>ftsprozesse bei Home of the Brave. Deshalb sollen hier alle relevanten technischen Abl<62>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<EFBFBD>tzliches von Flashern f<EFBFBD>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(fixture_path('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(fixture_path('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(fixture_path('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{working.rss broken.rss}.each do |path|
|
||
File.open(File.join(fixture_path(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ødef'
|
||
a = Text.new( txt,false,nil,true )
|
||
f.write(a,out="")
|
||
assert_equal( txt, out )
|
||
|
||
txt = '<sean><russell>abcø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&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
|