summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorkou <kou@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2014-05-27 13:10:55 +0000
committerkou <kou@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2014-05-27 13:10:55 +0000
commitba3d2f4ac20bec871fe96a393d923d0cbb0fd96a (patch)
tree897a0308607db1dad21eef1fee86b351e93ebfa5
parent313fa180333a1eb4d1fa1542930e83f8d77e6b2d (diff)
* test/rexml/test_contrib.rb: Indent.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@46174 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
-rw-r--r--ChangeLog4
-rw-r--r--test/rexml/parse/test_document_type_declaration.rb56
-rw-r--r--test/rexml/parse/test_notation_declaration.rb118
-rw-r--r--test/rexml/test_attributes.rb342
-rw-r--r--test/rexml/test_attributes_mixin.rb48
-rw-r--r--test/rexml/test_changing_encoding.rb66
-rw-r--r--test/rexml/test_contrib.rb880
-rw-r--r--test/rexml/test_core.rb2454
-rw-r--r--test/rexml/test_doctype.rb190
-rw-r--r--test/rexml/test_elements.rb196
-rw-r--r--test/rexml/test_encoding.rb150
-rw-r--r--test/rexml/test_entity.rb312
-rw-r--r--test/rexml/test_functions.rb400
-rw-r--r--test/rexml/test_functions_number.rb52
-rw-r--r--test/rexml/test_jaxen.rb208
-rw-r--r--test/rexml/test_light.rb170
-rw-r--r--test/rexml/test_lightparser.rb16
-rw-r--r--test/rexml/test_listener.rb202
-rw-r--r--test/rexml/test_martin_fowler.rb40
-rw-r--r--test/rexml/test_namespace.rb54
-rw-r--r--test/rexml/test_order.rb172
-rw-r--r--test/rexml/test_preceding_sibling.rb56
-rw-r--r--test/rexml/test_pullparser.rb160
-rw-r--r--test/rexml/test_rexml_issuezilla.rb18
-rw-r--r--test/rexml/test_sax.rb472
-rw-r--r--test/rexml/test_stream.rb194
-rw-r--r--test/rexml/test_text.rb28
-rw-r--r--test/rexml/test_ticket_80.rb46
-rw-r--r--test/rexml/test_validation_rng.rb616
-rw-r--r--test/rexml/test_xml_declaration.rb42
-rw-r--r--test/rexml/xpath/test_attribute.rb30
-rw-r--r--test/rexml/xpath/test_axis_preceding_sibling.rb54
-rw-r--r--test/rexml/xpath/test_base.rb1820
-rw-r--r--test/rexml/xpath/test_node.rb36
-rw-r--r--test/rexml/xpath/test_predicate.rb114
-rw-r--r--test/rexml/xpath/test_text.rb120
36 files changed, 4970 insertions, 4966 deletions
diff --git a/ChangeLog b/ChangeLog
index 852b71a..3216cb1 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+Tue May 27 22:10:30 2014 Kouhei Sutou <kou@cozmixng.org>
+
+ * test/rexml/test_contrib.rb: Indent.
+
Tue May 27 21:28:16 2014 NARUSE, Yui <naruse@ruby-lang.org>
* ext/socket/ifaddr.c (ifaddr_inspect_flags): support IFF_SIMPLEX.
diff --git a/test/rexml/parse/test_document_type_declaration.rb b/test/rexml/parse/test_document_type_declaration.rb
index fb7cee5..59fe561 100644
--- a/test/rexml/parse/test_document_type_declaration.rb
+++ b/test/rexml/parse/test_document_type_declaration.rb
@@ -2,48 +2,48 @@ require "test/unit"
require "rexml/document"
module REXMLTests
-class TestParseDocumentTypeDeclaration < Test::Unit::TestCase
- private
- def xml(internal_subset)
- <<-XML
+ class TestParseDocumentTypeDeclaration < Test::Unit::TestCase
+ private
+ def xml(internal_subset)
+ <<-XML
<!DOCTYPE r SYSTEM "urn:x-rexml:test" [
#{internal_subset}
]>
<r/>
- XML
- end
+ XML
+ end
- def parse(internal_subset)
- REXML::Document.new(xml(internal_subset)).doctype
- end
+ def parse(internal_subset)
+ REXML::Document.new(xml(internal_subset)).doctype
+ end
- class TestMixed < self
- def test_entity_element
- doctype = parse(<<-INTERNAL_SUBSET)
+ class TestMixed < self
+ def test_entity_element
+ doctype = parse(<<-INTERNAL_SUBSET)
<!ENTITY entity-name "entity content">
<!ELEMENT element-name EMPTY>
- INTERNAL_SUBSET
- assert_equal([REXML::Entity, REXML::ElementDecl],
- doctype.children.collect(&:class))
- end
+ INTERNAL_SUBSET
+ assert_equal([REXML::Entity, REXML::ElementDecl],
+ doctype.children.collect(&:class))
+ end
- def test_attlist_entity
- doctype = parse(<<-INTERNAL_SUBSET)
+ def test_attlist_entity
+ doctype = parse(<<-INTERNAL_SUBSET)
<!ATTLIST attribute-list-name attribute-name CDATA #REQUIRED>
<!ENTITY entity-name "entity content">
- INTERNAL_SUBSET
- assert_equal([REXML::AttlistDecl, REXML::Entity],
- doctype.children.collect(&:class))
- end
+ INTERNAL_SUBSET
+ assert_equal([REXML::AttlistDecl, REXML::Entity],
+ doctype.children.collect(&:class))
+ end
- def test_notation_attlist
- doctype = parse(<<-INTERNAL_SUBSET)
+ def test_notation_attlist
+ doctype = parse(<<-INTERNAL_SUBSET)
<!NOTATION notation-name SYSTEM "system-literal">
<!ATTLIST attribute-list-name attribute-name CDATA #REQUIRED>
- INTERNAL_SUBSET
- assert_equal([REXML::NotationDecl, REXML::AttlistDecl],
- doctype.children.collect(&:class))
+ INTERNAL_SUBSET
+ assert_equal([REXML::NotationDecl, REXML::AttlistDecl],
+ doctype.children.collect(&:class))
+ end
end
end
end
-end
diff --git a/test/rexml/parse/test_notation_declaration.rb b/test/rexml/parse/test_notation_declaration.rb
index ecce44a..0a4e737 100644
--- a/test/rexml/parse/test_notation_declaration.rb
+++ b/test/rexml/parse/test_notation_declaration.rb
@@ -2,98 +2,98 @@ require 'test/unit'
require 'rexml/document'
module REXMLTests
-class TestParseNotationDeclaration < Test::Unit::TestCase
- private
- def xml(internal_subset)
- <<-XML
+ class TestParseNotationDeclaration < Test::Unit::TestCase
+ private
+ def xml(internal_subset)
+ <<-XML
<!DOCTYPE r SYSTEM "urn:x-henrikmartensson:test" [
#{internal_subset}
]>
<r/>
- XML
- end
-
- def parse(internal_subset)
- REXML::Document.new(xml(internal_subset)).doctype
- end
-
- class TestCommon < self
- def test_name
- doctype = parse("<!NOTATION name PUBLIC 'urn:public-id'>")
- assert_equal("name", doctype.notation("name").name)
+ XML
end
- end
- class TestExternalID < self
- class TestSystem < self
- def test_single_quote
- doctype = parse(<<-INTERNAL_SUBSET)
-<!NOTATION name SYSTEM 'system-literal'>
- INTERNAL_SUBSET
- assert_equal("system-literal", doctype.notation("name").system)
- end
+ def parse(internal_subset)
+ REXML::Document.new(xml(internal_subset)).doctype
+ end
- def test_double_quote
- doctype = parse(<<-INTERNAL_SUBSET)
-<!NOTATION name SYSTEM "system-literal">
- INTERNAL_SUBSET
- assert_equal("system-literal", doctype.notation("name").system)
+ class TestCommon < self
+ def test_name
+ doctype = parse("<!NOTATION name PUBLIC 'urn:public-id'>")
+ assert_equal("name", doctype.notation("name").name)
end
end
- class TestPublic < self
- class TestPublicIDLiteral < self
+ class TestExternalID < self
+ class TestSystem < self
def test_single_quote
doctype = parse(<<-INTERNAL_SUBSET)
-<!NOTATION name PUBLIC 'public-id-literal' "system-literal">
+<!NOTATION name SYSTEM 'system-literal'>
INTERNAL_SUBSET
- assert_equal("public-id-literal", doctype.notation("name").public)
+ assert_equal("system-literal", doctype.notation("name").system)
end
def test_double_quote
doctype = parse(<<-INTERNAL_SUBSET)
-<!NOTATION name PUBLIC "public-id-literal" "system-literal">
+<!NOTATION name SYSTEM "system-literal">
INTERNAL_SUBSET
- assert_equal("public-id-literal", doctype.notation("name").public)
+ assert_equal("system-literal", doctype.notation("name").system)
end
end
- class TestSystemLiteral < self
- def test_single_quote
- doctype = parse(<<-INTERNAL_SUBSET)
-<!NOTATION name PUBLIC "public-id-literal" 'system-literal'>
- INTERNAL_SUBSET
- assert_equal("system-literal", doctype.notation("name").system)
+ class TestPublic < self
+ class TestPublicIDLiteral < self
+ def test_single_quote
+ doctype = parse(<<-INTERNAL_SUBSET)
+<!NOTATION name PUBLIC 'public-id-literal' "system-literal">
+ INTERNAL_SUBSET
+ assert_equal("public-id-literal", doctype.notation("name").public)
+ end
+
+ def test_double_quote
+ doctype = parse(<<-INTERNAL_SUBSET)
+<!NOTATION name PUBLIC "public-id-literal" "system-literal">
+ INTERNAL_SUBSET
+ assert_equal("public-id-literal", doctype.notation("name").public)
+ end
end
- def test_double_quote
- doctype = parse(<<-INTERNAL_SUBSET)
+ class TestSystemLiteral < self
+ def test_single_quote
+ doctype = parse(<<-INTERNAL_SUBSET)
+<!NOTATION name PUBLIC "public-id-literal" 'system-literal'>
+ INTERNAL_SUBSET
+ assert_equal("system-literal", doctype.notation("name").system)
+ end
+
+ def test_double_quote
+ doctype = parse(<<-INTERNAL_SUBSET)
<!NOTATION name PUBLIC "public-id-literal" "system-literal">
- INTERNAL_SUBSET
- assert_equal("system-literal", doctype.notation("name").system)
+ INTERNAL_SUBSET
+ assert_equal("system-literal", doctype.notation("name").system)
+ end
end
end
- end
- class TestMixed < self
- def test_system_public
- doctype = parse(<<-INTERNAL_SUBSET)
+ class TestMixed < self
+ def test_system_public
+ doctype = parse(<<-INTERNAL_SUBSET)
<!NOTATION system-name SYSTEM "system-literal">
<!NOTATION public-name PUBLIC "public-id-literal" 'system-literal'>
- INTERNAL_SUBSET
- assert_equal(["system-name", "public-name"],
- doctype.notations.collect(&:name))
- end
+ INTERNAL_SUBSET
+ assert_equal(["system-name", "public-name"],
+ doctype.notations.collect(&:name))
+ end
- def test_public_system
- doctype = parse(<<-INTERNAL_SUBSET)
+ def test_public_system
+ doctype = parse(<<-INTERNAL_SUBSET)
<!NOTATION public-name PUBLIC "public-id-literal" 'system-literal'>
<!NOTATION system-name SYSTEM "system-literal">
- INTERNAL_SUBSET
- assert_equal(["public-name", "system-name"],
- doctype.notations.collect(&:name))
+ INTERNAL_SUBSET
+ assert_equal(["public-name", "system-name"],
+ doctype.notations.collect(&:name))
+ end
end
end
end
end
-end
diff --git a/test/rexml/test_attributes.rb b/test/rexml/test_attributes.rb
index fea4ee7..aea1d88 100644
--- a/test/rexml/test_attributes.rb
+++ b/test/rexml/test_attributes.rb
@@ -2,203 +2,203 @@ require 'test/unit/testcase'
require 'rexml/document'
module REXMLTests
-class AttributesTester < Test::Unit::TestCase
- include REXML
- def test_accessor
- doc = Document.new("<a xmlns:foo='a' xmlns:bar='b' foo:att='1' bar:att='2' att='3'/>")
- assert_equal '3', doc.root.attributes['att']
- assert_equal '2', doc.root.attributes['bar:att']
- doc.root.attributes['att'] = 5
- assert_equal '5', doc.root.attributes['att']
- end
-
- def test_each_attribute
- doc = Document.new('<a x="1" y="2"/>')
- doc.root.attributes.each_attribute {|attr|
- if attr.expanded_name == 'x'
- assert_equal '1', attr.value
- elsif attr.expanded_name == 'y'
- assert_equal '2', attr.value
- else
- assert_fail "No such attribute!!"
- end
- }
- end
+ class AttributesTester < Test::Unit::TestCase
+ include REXML
+ def test_accessor
+ doc = Document.new("<a xmlns:foo='a' xmlns:bar='b' foo:att='1' bar:att='2' att='3'/>")
+ assert_equal '3', doc.root.attributes['att']
+ assert_equal '2', doc.root.attributes['bar:att']
+ doc.root.attributes['att'] = 5
+ assert_equal '5', doc.root.attributes['att']
+ end
- def test_each
- doc = Document.new('<a x="1" y="2"/>')
- doc.root.attributes.each {|name, value|
- if name == 'x'
- assert_equal '1', value
- elsif name == 'y'
- assert_equal '2', value
- else
- assert_fail "No such attribute!!"
- end
- }
- end
+ def test_each_attribute
+ doc = Document.new('<a x="1" y="2"/>')
+ doc.root.attributes.each_attribute {|attr|
+ if attr.expanded_name == 'x'
+ assert_equal '1', attr.value
+ elsif attr.expanded_name == 'y'
+ assert_equal '2', attr.value
+ else
+ assert_fail "No such attribute!!"
+ end
+ }
+ end
- def test_get_attribute
- doc = Document.new('<a xmlns:x="a" x:foo="1" foo="2" bar="3"/>')
- assert_equal '2', doc.root.attributes.get_attribute("foo").value
- assert_equal '1', doc.root.attributes.get_attribute("x:foo").value
- end
+ def test_each
+ doc = Document.new('<a x="1" y="2"/>')
+ doc.root.attributes.each {|name, value|
+ if name == 'x'
+ assert_equal '1', value
+ elsif name == 'y'
+ assert_equal '2', value
+ else
+ assert_fail "No such attribute!!"
+ end
+ }
+ end
- def test_size
- doc = Document.new("<a xmlns:foo='a' x='1' y='2' foo:x='3'/>")
- assert_equal 4, doc.root.attributes.length
- end
+ def test_get_attribute
+ doc = Document.new('<a xmlns:x="a" x:foo="1" foo="2" bar="3"/>')
+ assert_equal '2', doc.root.attributes.get_attribute("foo").value
+ assert_equal '1', doc.root.attributes.get_attribute("x:foo").value
+ end
- def test_setter
- doc = Document.new("<a xmlns:x='a' x:foo='1' foo='3'/>")
- doc.root.attributes['y:foo'] = '2'
- assert_equal '2', doc.root.attributes['y:foo']
- doc.root.attributes['foo'] = '4'
- assert_equal '4', doc.root.attributes['foo']
- doc.root.attributes['x:foo'] = nil
- assert_equal 3, doc.root.attributes.size
- end
+ def test_size
+ doc = Document.new("<a xmlns:foo='a' x='1' y='2' foo:x='3'/>")
+ assert_equal 4, doc.root.attributes.length
+ end
- def test_delete
- doc = Document.new("<a xmlns:y='a' xmlns:x='b' xmlns:z='c' y:foo='0' x:foo='1' foo='3' z:foo='4'/>")
- doc.root.attributes.delete 'foo'
- assert_equal 6, doc.root.attributes.size
- assert_equal '1', doc.root.attributes['x:foo']
+ def test_setter
+ doc = Document.new("<a xmlns:x='a' x:foo='1' foo='3'/>")
+ doc.root.attributes['y:foo'] = '2'
+ assert_equal '2', doc.root.attributes['y:foo']
+ doc.root.attributes['foo'] = '4'
+ assert_equal '4', doc.root.attributes['foo']
+ doc.root.attributes['x:foo'] = nil
+ assert_equal 3, doc.root.attributes.size
+ end
- doc.root.attributes.delete 'x:foo'
- assert_equal 5, doc.root.attributes.size
+ def test_delete
+ doc = Document.new("<a xmlns:y='a' xmlns:x='b' xmlns:z='c' y:foo='0' x:foo='1' foo='3' z:foo='4'/>")
+ doc.root.attributes.delete 'foo'
+ assert_equal 6, doc.root.attributes.size
+ assert_equal '1', doc.root.attributes['x:foo']
- attr = doc.root.attributes.get_attribute('y:foo')
- doc.root.attributes.delete attr
- assert_equal 4, doc.root.attributes.size
+ doc.root.attributes.delete 'x:foo'
+ assert_equal 5, doc.root.attributes.size
- assert_equal '4', doc.root.attributes['z:foo']
- end
+ attr = doc.root.attributes.get_attribute('y:foo')
+ doc.root.attributes.delete attr
+ assert_equal 4, doc.root.attributes.size
- def test_prefixes
- doc = Document.new("<a xmlns='foo' xmlns:x='bar' xmlns:y='twee' z='glorp' x:k='gru'/>")
- prefixes = doc.root.attributes.prefixes
- assert_equal 2, prefixes.size
- assert_equal 0, (prefixes - ['x', 'y']).size
- end
+ assert_equal '4', doc.root.attributes['z:foo']
+ end
- # Contributed by Mike Stok
- def test_values_with_apostrophes
- doc = Document.new(%q#<tag h1="1'2'" h2='1"2'/>#)
- s = doc.to_s
- assert(s =~ /h1='1&apos;2&apos;'/)
- assert(s =~ /h2='1"2'/)
- end
+ def test_prefixes
+ doc = Document.new("<a xmlns='foo' xmlns:x='bar' xmlns:y='twee' z='glorp' x:k='gru'/>")
+ prefixes = doc.root.attributes.prefixes
+ assert_equal 2, prefixes.size
+ assert_equal 0, (prefixes - ['x', 'y']).size
+ end
- # Submitted by Kou
- def test_namespace_conflict
- assert_raise( ParseException,
- "Declaring two attributes with the same namespace should be an error" ) do
- REXML::Document.new <<-XML
- <x xmlns:n1="http://www.w3.org"
- xmlns:n2="http://www.w3.org" >
- <bad n1:a="1" n2:a="2" />
- </x>
- XML
+ # Contributed by Mike Stok
+ def test_values_with_apostrophes
+ doc = Document.new(%q#<tag h1="1'2'" h2='1"2'/>#)
+ s = doc.to_s
+ assert(s =~ /h1='1&apos;2&apos;'/)
+ assert(s =~ /h2='1"2'/)
end
- REXML::Document.new("<a xmlns:a='a' xmlns:b='a'></a>")
- end
+ # Submitted by Kou
+ def test_namespace_conflict
+ assert_raise( ParseException,
+ "Declaring two attributes with the same namespace should be an error" ) do
+ REXML::Document.new <<-XML
+ <x xmlns:n1="http://www.w3.org"
+ xmlns:n2="http://www.w3.org" >
+ <bad n1:a="1" n2:a="2" />
+ </x>
+ XML
+ end
- # Submitted by Kou
- def test_attribute_deletion
- e = REXML::Element.new
- e.add_namespace("a", "http://a/")
- e.add_namespace("b", "http://b/")
- e.add_attributes({"c" => "cc", "a:c" => "cC", "b:c" => "CC"})
+ REXML::Document.new("<a xmlns:a='a' xmlns:b='a'></a>")
+ end
- e.attributes.delete("c")
- assert_nil(e.attributes.get_attribute("c"))
+ # Submitted by Kou
+ def test_attribute_deletion
+ e = REXML::Element.new
+ e.add_namespace("a", "http://a/")
+ e.add_namespace("b", "http://b/")
+ e.add_attributes({"c" => "cc", "a:c" => "cC", "b:c" => "CC"})
- before_size = e.attributes.size
- e.attributes.delete("c")
- assert_nil(e.attributes.get_attribute("c"))
- assert_equal(before_size, e.attributes.size)
+ e.attributes.delete("c")
+ assert_nil(e.attributes.get_attribute("c"))
- e.attributes.delete(e.attributes.get_attribute("a:c"))
- assert_nil(e.attributes.get_attribute("a:c"))
+ before_size = e.attributes.size
+ e.attributes.delete("c")
+ assert_nil(e.attributes.get_attribute("c"))
+ assert_equal(before_size, e.attributes.size)
- e.attributes.delete("b:c")
- assert_nil(e.attributes.get_attribute("b:c"))
+ e.attributes.delete(e.attributes.get_attribute("a:c"))
+ assert_nil(e.attributes.get_attribute("a:c"))
- before_size = e.attributes.size
- e.attributes.delete(e.attributes.get_attribute("b:c"))
- assert_nil(e.attributes.get_attribute("b:c"))
- assert_equal(before_size, e.attributes.size)
+ e.attributes.delete("b:c")
+ assert_nil(e.attributes.get_attribute("b:c"))
- before_size = e.attributes.size
- e.attributes.delete("c")
- assert_nil(e.attributes.get_attribute("c"))
- assert_equal(before_size, e.attributes.size)
+ before_size = e.attributes.size
+ e.attributes.delete(e.attributes.get_attribute("b:c"))
+ assert_nil(e.attributes.get_attribute("b:c"))
+ assert_equal(before_size, e.attributes.size)
- e.add_attribute("c", "cc")
+ before_size = e.attributes.size
+ e.attributes.delete("c")
+ assert_nil(e.attributes.get_attribute("c"))
+ assert_equal(before_size, e.attributes.size)
- e.attributes.delete(e.attributes.get_attribute("c"))
- assert_nil(e.attributes.get_attribute("c"))
- end
+ e.add_attribute("c", "cc")
- # Submitted by Kou
- def test_element_usage
- attr = Attribute.new("name", "value")
- elem = Element.new("elem")
- a = Attribute.new(attr, elem)
- assert_equal(elem, a.element)
- end
+ e.attributes.delete(e.attributes.get_attribute("c"))
+ assert_nil(e.attributes.get_attribute("c"))
+ end
- def attr_test(attr_name,attr_value)
- a1 = REXML::Attribute.new(attr_name,attr_value)
+ # Submitted by Kou
+ def test_element_usage
+ attr = Attribute.new("name", "value")
+ elem = Element.new("elem")
+ a = Attribute.new(attr, elem)
+ assert_equal(elem, a.element)
+ end
- s1 = a1.value
- s2 = a1.value
+ def attr_test(attr_name,attr_value)
+ a1 = REXML::Attribute.new(attr_name,attr_value)
- #p s1
- #p s2
- assert_equal(s1,s2)
+ s1 = a1.value
+ s2 = a1.value
- a2 = REXML::Attribute.new(attr_name,attr_value)
+ #p s1
+ #p s2
+ assert_equal(s1,s2)
- a2.to_s # NB invocation of to_s
- s1 = a2.value
- s2 = a2.value
+ a2 = REXML::Attribute.new(attr_name,attr_value)
- #p s1
- #p s2
- assert_equal(s1,s2)
- end
+ a2.to_s # NB invocation of to_s
+ s1 = a2.value
+ s2 = a2.value
- def test_amp_attributes
- attr_test('name','value with &amp; ampersand only')
- end
+ #p s1
+ #p s2
+ assert_equal(s1,s2)
+ end
- def test_amp_and_lf_attributes
- attr_test('name','value with LF &#x000a; &amp; ampersand')
- end
+ def test_amp_attributes
+ attr_test('name','value with &amp; ampersand only')
+ end
- def test_quoting
- d = Document.new(%q{<a x='1' y="2"/>})
- assert_equal( %q{<a x='1' y='2'/>}, d.to_s )
- d.root.context[:attribute_quote] = :quote
- assert_equal( %q{<a x="1" y="2"/>}, d.to_s )
+ def test_amp_and_lf_attributes
+ attr_test('name','value with LF &#x000a; &amp; ampersand')
+ end
- d = Document.new(%q{<a x='1' y="2"><b z='3'/></a>})
- assert_equal( %q{<a x='1' y='2'><b z='3'/></a>}, d.to_s )
- d.root.context[:attribute_quote] = :quote
- assert_equal( %q{<a x="1" y="2"><b z="3"/></a>}, d.to_s )
- end
+ def test_quoting
+ d = Document.new(%q{<a x='1' y="2"/>})
+ assert_equal( %q{<a x='1' y='2'/>}, d.to_s )
+ d.root.context[:attribute_quote] = :quote
+ assert_equal( %q{<a x="1" y="2"/>}, d.to_s )
- def test_ticket_127
- doc = Document.new
- doc.add_element 'a', { 'v' => 'x & y' }
- assert doc.to_s.index(';')
- end
+ d = Document.new(%q{<a x='1' y="2"><b z='3'/></a>})
+ assert_equal( %q{<a x='1' y='2'><b z='3'/></a>}, d.to_s )
+ d.root.context[:attribute_quote] = :quote
+ assert_equal( %q{<a x="1" y="2"><b z="3"/></a>}, d.to_s )
+ end
+
+ def test_ticket_127
+ doc = Document.new
+ doc.add_element 'a', { 'v' => 'x & y' }
+ assert doc.to_s.index(';')
+ end
- def test_to_a_with_namespaces
- document = Document.new(<<-XML)
+ def test_to_a_with_namespaces
+ document = Document.new(<<-XML)
<root
xmlns:ns1="http://example.org/ns1"
xmlns:ns2="http://example.org/ns2">
@@ -209,14 +209,14 @@ class AttributesTester < Test::Unit::TestCase
other-attribute="other-value"/>
</root>
XML
- child = document.root.elements["child"]
- assert_equal([
- "attribute='no-ns'",
- "ns1:attribute='ns1'",
- "ns2:attribute='ns2'",
- "other-attribute='other-value'",
- ],
- child.attributes.to_a.collect(&:to_string).sort)
+ child = document.root.elements["child"]
+ assert_equal([
+ "attribute='no-ns'",
+ "ns1:attribute='ns1'",
+ "ns2:attribute='ns2'",
+ "other-attribute='other-value'",
+ ],
+ child.attributes.to_a.collect(&:to_string).sort)
+ end
end
end
-end
diff --git a/test/rexml/test_attributes_mixin.rb b/test/rexml/test_attributes_mixin.rb
index a92c783..17cca4e 100644
--- a/test/rexml/test_attributes_mixin.rb
+++ b/test/rexml/test_attributes_mixin.rb
@@ -2,30 +2,30 @@ require 'test/unit'
require 'rexml/document'
module REXMLTests
-class TestAttributes < Test::Unit::TestCase
- def setup
- @ns_a = "urn:x-test:a"
- @ns_b = "urn:x-test:b"
- element_string = <<-"XMLEND"
- <test xmlns:a="#{@ns_a}"
- xmlns:b="#{@ns_b}"
- a = "1"
- b = '2'
- a:c = "3"
- a:d = '4'
- a:e = "5"
- b:f = "6"/>
- XMLEND
- @attributes = REXML::Document.new(element_string).root.attributes
- end
+ class TestAttributes < Test::Unit::TestCase
+ def setup
+ @ns_a = "urn:x-test:a"
+ @ns_b = "urn:x-test:b"
+ element_string = <<-"XMLEND"
+ <test xmlns:a="#{@ns_a}"
+ xmlns:b="#{@ns_b}"
+ a = "1"
+ b = '2'
+ a:c = "3"
+ a:d = '4'
+ a:e = "5"
+ b:f = "6"/>
+ XMLEND
+ @attributes = REXML::Document.new(element_string).root.attributes
+ end
- def test_get_attribute_ns
- assert_equal("1", @attributes.get_attribute_ns("", "a").value)
- assert_equal("2", @attributes.get_attribute_ns("", "b").value)
- assert_equal("3", @attributes.get_attribute_ns(@ns_a, "c").value)
- assert_equal("4", @attributes.get_attribute_ns(@ns_a, "d").value)
- assert_equal("5", @attributes.get_attribute_ns(@ns_a, "e").value)
- assert_equal("6", @attributes.get_attribute_ns(@ns_b, "f").value)
+ def test_get_attribute_ns
+ assert_equal("1", @attributes.get_attribute_ns("", "a").value)
+ assert_equal("2", @attributes.get_attribute_ns("", "b").value)
+ assert_equal("3", @attributes.get_attribute_ns(@ns_a, "c").value)
+ assert_equal("4", @attributes.get_attribute_ns(@ns_a, "d").value)
+ assert_equal("5", @attributes.get_attribute_ns(@ns_a, "e").value)
+ assert_equal("6", @attributes.get_attribute_ns(@ns_b, "f").value)
+ end
end
end
-end
diff --git a/test/rexml/test_changing_encoding.rb b/test/rexml/test_changing_encoding.rb
index 0e0cd6c..5a085e2 100644
--- a/test/rexml/test_changing_encoding.rb
+++ b/test/rexml/test_changing_encoding.rb
@@ -3,42 +3,42 @@
require 'rexml/encoding'
module REXMLTests
-class ChangingEncodings < Test::Unit::TestCase
- def initialize a
- @u = 'テスト ほげ ふが 美しい'
- @e = @u.encode("EUC-JP")
- @f = Foo.new
- super
- end
+ class ChangingEncodings < Test::Unit::TestCase
+ def initialize a
+ @u = 'テスト ほげ ふが 美しい'
+ @e = @u.encode("EUC-JP")
+ @f = Foo.new
+ super
+ end
- class Foo
- include REXML::Encoding
- end
+ class Foo
+ include REXML::Encoding
+ end
- # Note that these tests must be executed in order for the third one to
- # actually test anything.
- def test_0_euc
- @f.encoding = 'EUC-JP'
- assert_equal( @u, @f.decode(@e) )
- # This doesn't happen anymore, for some reason
- #assert_raises( Iconv::IllegalSequence, "Decoding unicode should fail" ) {
- # @f.decode(@u) == @u
- #}
- end
+ # Note that these tests must be executed in order for the third one to
+ # actually test anything.
+ def test_0_euc
+ @f.encoding = 'EUC-JP'
+ assert_equal( @u, @f.decode(@e) )
+ # This doesn't happen anymore, for some reason
+ #assert_raises( Iconv::IllegalSequence, "Decoding unicode should fail" ) {
+ # @f.decode(@u) == @u
+ #}
+ end
- def test_1_utf
- @f.encoding = 'UTF-8'
- assert_not_equal( @u, @f.decode( @e ) )
- assert_equal( @u, @f.decode( @u ) )
- end
+ def test_1_utf
+ @f.encoding = 'UTF-8'
+ assert_not_equal( @u, @f.decode( @e ) )
+ assert_equal( @u, @f.decode( @u ) )
+ end
- def test_2_euc
- @f.encoding = 'EUC-JP'
- assert_equal( @u, @f.decode(@e) )
- # This doesn't happen anymore, for some reason
- #assert_raises( Iconv::IllegalSequence, "Decoding unicode should fail" ) {
- # @f.decode(@u) == @u
- #}
+ def test_2_euc
+ @f.encoding = 'EUC-JP'
+ assert_equal( @u, @f.decode(@e) )
+ # This doesn't happen anymore, for some reason
+ #assert_raises( Iconv::IllegalSequence, "Decoding unicode should fail" ) {
+ # @f.decode(@u) == @u
+ #}
+ end
end
end
-end
diff --git a/test/rexml/test_contrib.rb b/test/rexml/test_contrib.rb
index ea357b1..917502f 100644
--- a/test/rexml/test_contrib.rb
+++ b/test/rexml/test_contrib.rb
@@ -7,11 +7,11 @@ require "rexml/parseexception"
require "rexml/formatters/default"
module REXMLTests
-class ContribTester < Test::Unit::TestCase
- include REXMLTestUtils
- include REXML
+ class ContribTester < Test::Unit::TestCase
+ include REXMLTestUtils
+ include REXML
- XML_STRING_01 = <<DELIMITER
+ XML_STRING_01 = <<DELIMITER
<?xml version="1.0" encoding="UTF-8"?>
<biblio>
<entry type="Book">
@@ -32,7 +32,7 @@ class ContribTester < Test::Unit::TestCase
</biblio>
DELIMITER
- XML_STRING_02 = <<DELIMITER
+ XML_STRING_02 = <<DELIMITER
<biblio>
<entry type="Book">
<language>english</language>
@@ -52,205 +52,205 @@ DELIMITER
</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"/>'
+ # 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
+ 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
+ # 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
+ # 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="")
+ # "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
+ doc = REXML::Document.new(out)
+ outtext = doc.root.text
- assert_equal(text, outtext)
- end
+ 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
+ # 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
+ #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_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_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'>
+ 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>"
- 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')
+ Document.new desired_result_string
+ xpath = "/biblio/entry[not(author)]"
+ result = XPath.first(doc, xpath)
+ assert_equal desired_result_string, result.to_s
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)
+ 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
+ doc = Document.new <<-EOF
<?xml version="1.0" encoding="ISO-8859-1"?>
<intranet>
<position><aktuell datum="01-10-11">Technik</aktuell></position>
@@ -266,254 +266,254 @@ Die Technik ist das R\xFCckgrat der meisten Gesch\xFCftsprozesse bei Home of the
</nebenspalte>
</intranet>
EOF
- tn = XPath.first(doc, "//nebenspalte/text()[2]")
- expected_iso = "N\xFCtzliches von Flashern f\xFCr Flasher."
- expected_utf = expected_iso.unpack('C*').pack('U*')
- expected_iso.force_encoding(::Encoding::ISO_8859_1)
- expected_utf.force_encoding(::Encoding::UTF_8)
- 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>'
+ tn = XPath.first(doc, "//nebenspalte/text()[2]")
+ expected_iso = "N\xFCtzliches von Flashern f\xFCr Flasher."
+ expected_utf = expected_iso.unpack('C*').pack('U*')
+ expected_iso.force_encoding(::Encoding::ISO_8859_1)
+ expected_utf.force_encoding(::Encoding::UTF_8)
+ 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
- anElement = anElement = aDoc.elements[1]
- elementAttrPrefix = anElement.attributes.get_attribute('content').prefix
+ def test_element_cloning_namespace_Chris
+ aDoc = REXML::Document.new '<h1 tpl:content="title" xmlns:tpl="1">Dummy title</h1>'
- aClone = anElement.clone
- cloneAttrPrefix = aClone.attributes.get_attribute('content').prefix
+ anElement = anElement = aDoc.elements[1]
+ elementAttrPrefix = anElement.attributes.get_attribute('content').prefix
- assert_equal( elementAttrPrefix , cloneAttrPrefix )
- end
+ aClone = anElement.clone
+ cloneAttrPrefix = aClone.attributes.get_attribute('content').prefix
- def test_namespaces_in_attlist_tobias
- in_string = File.open(fixture_path('foo.xml'), 'r') do |file|
- file.read
+ assert_equal( elementAttrPrefix , cloneAttrPrefix )
end
- doc = Document.new in_string
+ def test_namespaces_in_attlist_tobias
+ in_string = File.open(fixture_path('foo.xml'), 'r') do |file|
+ file.read
+ end
- 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
+ doc = Document.new in_string
- # 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
+ 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
- # 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" )
+ # 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
- 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"
+ [
+ ['/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
- 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
+ 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
+ #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
- Document.new <<EOL
+ def test_whitespace_after_xml_decl
+ Document.new <<EOL
<?xml version='1.0'?>
<blo>
<wak>
</wak>
</blo>
EOL
- end
+ end
- def test_external_entity
- xp = '//channel/title'
+ 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('')
+ %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 )
+ # 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 ) )
+ # get the title of the feed
+ assert( doc.root.elements[xp].kind_of?( REXML::Element ) )
+ end
end
end
- end
- def test_maintain_dtd
- src = %q{<?xml version="1.0" encoding="UTF-8"?>
+ 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
+ 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_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_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
+ 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,"")
- end
+ REXML::Formatters::Pretty.new.write(a,"")
+ end
- def test_pos
- require 'tempfile'
- Tempfile.create("tidal") {|testfile|
- testdata = %Q{<calibration>
+ def test_pos
+ require 'tempfile'
+ Tempfile.create("tidal") {|testfile|
+ testdata = %Q{<calibration>
<section name="parameters">
<param name="barpress">760</param>
<param name="hertz">50</param>
@@ -521,63 +521,63 @@ EOL
</calibration>
}
- testfile.puts testdata
- testfile.rewind
- assert_nothing_raised do
- REXML::Document.new(testfile)
- end
- }
- end
+ testfile.puts testdata
+ testfile.rewind
+ assert_nothing_raised do
+ REXML::Document.new(testfile)
+ end
+ }
+ 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_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>"
+ 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
+ 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>"
+ def test_ticket_12
+ cfg = "<element><anotherelement><child1>a</child1><child2>b</child2></anotherelement></element>"
- config = REXML::Document.new( cfg )
+ config = REXML::Document.new( cfg )
- assert_equal( "a", config.elements[ "//child1" ].text )
- end
+ 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
+ # 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
+ end
end
diff --git a/test/rexml/test_core.rb b/test/rexml/test_core.rb
index 8bba293..f628cb9 100644
--- a/test/rexml/test_core.rb
+++ b/test/rexml/test_core.rb
@@ -12,1165 +12,1165 @@ require "rexml/undefinednamespaceexception"
require_relative "listener"
module REXMLTests
-class Tester < Test::Unit::TestCase
- include REXMLTestUtils
- include REXML
- def setup
- @xsa_source = <<-EOL
- <?xml version="1.0"?>
- <?xsl stylesheet="blah.xsl"?>
- <!-- The first line tests the XMLDecl, the second tests PI.
- The next line tests DocType. This line tests comments. -->
- <!DOCTYPE xsa PUBLIC
- "-//LM Garshol//DTD XML Software Autoupdate 1.0//EN//XML"
- "http://www.garshol.priv.no/download/xsa/xsa.dtd">
-
- <xsa>
- <vendor id="blah">
- <name>Lars Marius Garshol</name>
- <email>larsga@garshol.priv.no</email>
- <url>http://www.stud.ifi.uio.no/~lmariusg/</url>
- </vendor>
- </xsa>
- EOL
- end
+ class Tester < Test::Unit::TestCase
+ include REXMLTestUtils
+ include REXML
+ def setup
+ @xsa_source = <<-EOL
+ <?xml version="1.0"?>
+ <?xsl stylesheet="blah.xsl"?>
+ <!-- The first line tests the XMLDecl, the second tests PI.
+ The next line tests DocType. This line tests comments. -->
+ <!DOCTYPE xsa PUBLIC
+ "-//LM Garshol//DTD XML Software Autoupdate 1.0//EN//XML"
+ "http://www.garshol.priv.no/download/xsa/xsa.dtd">
+
+ <xsa>
+ <vendor id="blah">
+ <name>Lars Marius Garshol</name>
+ <email>larsga@garshol.priv.no</email>
+ <url>http://www.stud.ifi.uio.no/~lmariusg/</url>
+ </vendor>
+ </xsa>
+ EOL
+ end
- def test_bad_markup
- [
- "<pkg='version'> foo </pkg>",
- '<0/>',
- '<a>&</a>',
- '<a>&a</a>',
-# '<a>&a;</a>', # FIXME
- '<a a="<"/>',
- '<a 3="<"/>',
- '<a a="1" a="2"/>',
- '<a><!-- -- --></a>',
- '<a><!-- ---></a>',
- '<a>&#x00;</a>',
- '<a>&#0;</a>',
- "<a a='&#0;' />",
- "<a>\f</a>",
- "<a a='\f' />",
- "<a>\000</a>",
+ def test_bad_markup
+ [
+ "<pkg='version'> foo </pkg>",
+ '<0/>',
+ '<a>&</a>',
+ '<a>&a</a>',
+# '<a>&a;</a>', # FIXME
+ '<a a="<"/>',
+ '<a 3="<"/>',
+ '<a a="1" a="2"/>',
+ '<a><!-- -- --></a>',
+ '<a><!-- ---></a>',
+ '<a>&#x00;</a>',
+ '<a>&#0;</a>',
+ "<a a='&#0;' />",
+ "<a>\f</a>",
+ "<a a='\f' />",
+ "<a>\000</a>",
# FIXME '<a' + [65535].pack('U') + ' />',
- '<a>&#xfffe;</a>',
- '<a>&#65535;</a>',
+ '<a>&#xfffe;</a>',
+ '<a>&#65535;</a>',
# FIXME '<a' + [0x0371].pack('U') + ' />',
# FIXME '<a a' + [0x0371].pack('U') + '="" />',
- ].each do |src|
- assert_raise( ParseException, %Q{Parse #{src.inspect} should have failed!} ) do
- Document.new(src)
+ ].each do |src|
+ assert_raise( ParseException, %Q{Parse #{src.inspect} should have failed!} ) do
+ Document.new(src)
+ end
end
end
- end
- def test_attribute
- # Testing constructors
- #a = Attribute.new "hello", "dolly"
- #b = Attribute.new a
- #d = Document.new( "<a hello='dolly' href='blah'/>" )
- #c = d[0].attributes.get_attribute( "hello" )
-
- #assert_equal a, b
- #for attr in [ a, b, c]
- # assert_equal "hello", attr.name
- # assert_equal "dolly", attr.value
- #end
-
- # This because of a reported bug in attribute handling in 1.0a8
- source = '<a att="A">blah</a>'
- doc = Document.new source
- doc.elements.each do |a|
- a.attributes['att'] << 'B'
- assert_equal "AB", a.attributes['att']
- a.attributes['att'] = 'C'
- assert_equal "C", a.attributes['att']
- end
-
- # Bryan Murphy <murphybryanp@yahoo.com>
- text = "this is a {target[@name='test']/@value} test"
- source = <<-EOL
- <?xml version="1.0"?>
- <doc search="#{text}"/>
- EOL
-
- xml = Document.new source
- value = xml.root.attributes["search"]
- assert_equal text, value.to_s
-
- e = Element.new "test"
- e.add_attributes({ "name1" => "test1", "name4" => "test4" })
- e.add_attributes([["name3","test3"], ["name2","test2"]])
- assert_equal "test1", e.attributes["name1"]
- assert_equal "test2", e.attributes["name2"]
- assert_equal "test3", e.attributes["name3"]
- assert_equal "test4", e.attributes["name4"]
-
- # ensure that the attributes come out in sorted order
- assert_equal %w(<test
- name1='test1'
- name2='test2'
- name3='test3'
- name4='test4'/>).join(' '), e.to_s
- end
+ def test_attribute
+ # Testing constructors
+ #a = Attribute.new "hello", "dolly"
+ #b = Attribute.new a
+ #d = Document.new( "<a hello='dolly' href='blah'/>" )
+ #c = d[0].attributes.get_attribute( "hello" )
+
+ #assert_equal a, b
+ #for attr in [ a, b, c]
+ # assert_equal "hello", attr.name
+ # assert_equal "dolly", attr.value
+ #end
+
+ # This because of a reported bug in attribute handling in 1.0a8
+ source = '<a att="A">blah</a>'
+ doc = Document.new source
+ doc.elements.each do |a|
+ a.attributes['att'] << 'B'
+ assert_equal "AB", a.attributes['att']
+ a.attributes['att'] = 'C'
+ assert_equal "C", a.attributes['att']
+ end
- def test_cdata
- test = "The quick brown fox jumped
- & < & < \" '
- over the lazy dog."
+ # Bryan Murphy <murphybryanp@yahoo.com>
+ text = "this is a {target[@name='test']/@value} test"
+ source = <<-EOL
+ <?xml version="1.0"?>
+ <doc search="#{text}"/>
+ EOL
+
+ xml = Document.new source
+ value = xml.root.attributes["search"]
+ assert_equal text, value.to_s
+
+ e = Element.new "test"
+ e.add_attributes({ "name1" => "test1", "name4" => "test4" })
+ e.add_attributes([["name3","test3"], ["name2","test2"]])
+ assert_equal "test1", e.attributes["name1"]
+ assert_equal "test2", e.attributes["name2"]
+ assert_equal "test3", e.attributes["name3"]
+ assert_equal "test4", e.attributes["name4"]
+
+ # ensure that the attributes come out in sorted order
+ assert_equal %w(<test
+ name1='test1'
+ name2='test2'
+ name3='test3'
+ name4='test4'/>).join(' '), e.to_s
+ end
- source = "<a><![CDATA[#{test}]]></a>"
- d = REXML::Document.new( source )
+ def test_cdata
+ test = "The quick brown fox jumped
+ & < & < \" '
+ over the lazy dog."
- # Test constructors
- cdata = d[0][0]
- assert_equal test, cdata.value
- end
+ source = "<a><![CDATA[#{test}]]></a>"
+ d = REXML::Document.new( source )
- def test_comment
- string = "This is a new comment!"
- source = "<!--#{string}-->"
- comment = Comment.new string
- REXML::Formatters::Default.new.write( comment, out = "" )
- assert_equal(source, out)
-
- comment2 = Comment.new comment
- assert_equal(comment, comment2)
-
- assert_raise(ParseException) {
- REXML::Document.new("<d><!- foo --></d>")
- }
- assert_raise(ParseException) {
- REXML::Document.new("<d><!-- foo -></d>")
- }
- end
+ # Test constructors
+ cdata = d[0][0]
+ assert_equal test, cdata.value
+ end
- def test_whitespace
- doc = Document.new "<root-element><first-element/></root-element>"
- assert_equal 1, doc.root.size
- assert_equal 1, doc.root.elements.size
- doc = Document.new "<root-element>
- <first-element/>
- </root-element>"
- assert_equal 3, doc.root.size
- assert_equal 1, doc.root.elements.size
-
- text = " This is text
- with a lot of whitespace "
- source = "<a>#{text}<b>#{text}</b><c>#{text}</c>#{text}</a>"
-
- doc = Document.new( source, {
- :respect_whitespace => %w{ a c }
- } )
- assert_equal text, doc.elements["//c"].text
- string = ""
- doc.root.each { |n| string << n.to_s if n.kind_of? Text }
- assert_equal text+text, string
-
- string =" lots of blank
- space"
- doc.root.add_element("d").add_element("c").text = string
- doc.root.add_element("e").text = string
- assert_equal string, doc.elements["/a/d/c"].text
- assert string != doc.elements["/a/e"].text, "Text wasn't properly compressed"
-
- doc = Document.new source, { :respect_whitespace => :all }
- doc.root.add_element("d").text = string
- assert_equal text, doc.root.text
- nxt = ""
- doc.root.each { |n| nxt << n.to_s if n.kind_of? Text }
- assert_equal text+text, nxt
- assert_equal text, doc.root.elements["b"].text
- assert_equal text, doc.root.elements["c"].text
- assert_equal string, doc.root.elements["d"].text
- end
+ def test_comment
+ string = "This is a new comment!"
+ source = "<!--#{string}-->"
+ comment = Comment.new string
+ REXML::Formatters::Default.new.write( comment, out = "" )
+ assert_equal(source, out)
+
+ comment2 = Comment.new comment
+ assert_equal(comment, comment2)
+
+ assert_raise(ParseException) {
+ REXML::Document.new("<d><!- foo --></d>")
+ }
+ assert_raise(ParseException) {
+ REXML::Document.new("<d><!-- foo -></d>")
+ }
+ end
- # This isn't complete. We need to check declarations and comments
- def test_doctype
- string = "something"
- correct = "<!DOCTYPE something>"
- doc = DocType.new(string)
- assert_equal(string, doc.name)
- doc.write(out="")
- assert_equal(correct, out)
-
- doc2 = DocType.new(doc)
- assert_equal(doc.name, doc2.name)
- assert_equal(doc.external_id, doc2.external_id)
-
- correct = '<!DOCTYPE xsa PUBLIC "-//LM Garshol//DTD XML Software Autoupdate 1.0//EN//XML" "http://www.garshol.priv.no/download/xsa/xsa.dtd">'
-
- one_line_source = '<!DOCTYPE xsa PUBLIC "-//LM Garshol//DTD XML Software Autoupdate 1.0//EN//XML" "http://www.garshol.priv.no/download/xsa/xsa.dtd"><a/>'
- doc = Document.new( one_line_source )
- doc = doc[0]
- assert(doc)
- doc.write(test="")
- assert_equal(correct, test)
-
- multi_line_source = '<!DOCTYPE xsa PUBLIC
- "-//LM Garshol//DTD XML Software Autoupdate 1.0//EN//XML"
- "http://www.garshol.priv.no/download/xsa/xsa.dtd">
- <a/>'
- d = Document.new( multi_line_source )
- doc = d[0]
- assert(doc)
- doc.write(test="")
- assert_equal(correct, test)
-
- odd_space_source = ' <!DOCTYPE
- xsa PUBLIC "-//LM Garshol//DTD XML Software Autoupdate 1.0//EN//XML"
- "http://www.garshol.priv.no/download/xsa/xsa.dtd"> <a/>'
- d = Document.new( odd_space_source )
- dt = d.doctype
- dt.write(test="")
- assert_equal(correct, test)
-
- # OK, the BIG doctype test, numba wun
- docin = File.new(fixture_path("doctype_test.xml"))
- doc = Document.new(docin)
- doc.write(test="")
- assert_equal(31, doc.doctype.size)
- end
+ def test_whitespace
+ doc = Document.new "<root-element><first-element/></root-element>"
+ assert_equal 1, doc.root.size
+ assert_equal 1, doc.root.elements.size
+ doc = Document.new "<root-element>
+ <first-element/>
+ </root-element>"
+ assert_equal 3, doc.root.size
+ assert_equal 1, doc.root.elements.size
+
+ text = " This is text
+ with a lot of whitespace "
+ source = "<a>#{text}<b>#{text}</b><c>#{text}</c>#{text}</a>"
+
+ doc = Document.new( source, {
+ :respect_whitespace => %w{ a c }
+ } )
+ assert_equal text, doc.elements["//c"].text
+ string = ""
+ doc.root.each { |n| string << n.to_s if n.kind_of? Text }
+ assert_equal text+text, string
+
+ string =" lots of blank
+ space"
+ doc.root.add_element("d").add_element("c").text = string
+ doc.root.add_element("e").text = string
+ assert_equal string, doc.elements["/a/d/c"].text
+ assert string != doc.elements["/a/e"].text, "Text wasn't properly compressed"
+
+ doc = Document.new source, { :respect_whitespace => :all }
+ doc.root.add_element("d").text = string
+ assert_equal text, doc.root.text
+ nxt = ""
+ doc.root.each { |n| nxt << n.to_s if n.kind_of? Text }
+ assert_equal text+text, nxt
+ assert_equal text, doc.root.elements["b"].text
+ assert_equal text, doc.root.elements["c"].text
+ assert_equal string, doc.root.elements["d"].text
+ end
- def test_document
- # Testing cloning
- source = "<element/>"
- doc = Document.new source
+ # This isn't complete. We need to check declarations and comments
+ def test_doctype
+ string = "something"
+ correct = "<!DOCTYPE something>"
+ doc = DocType.new(string)
+ assert_equal(string, doc.name)
+ doc.write(out="")
+ assert_equal(correct, out)
+
+ doc2 = DocType.new(doc)
+ assert_equal(doc.name, doc2.name)
+ assert_equal(doc.external_id, doc2.external_id)
+
+ correct = '<!DOCTYPE xsa PUBLIC "-//LM Garshol//DTD XML Software Autoupdate 1.0//EN//XML" "http://www.garshol.priv.no/download/xsa/xsa.dtd">'
+
+ one_line_source = '<!DOCTYPE xsa PUBLIC "-//LM Garshol//DTD XML Software Autoupdate 1.0//EN//XML" "http://www.garshol.priv.no/download/xsa/xsa.dtd"><a/>'
+ doc = Document.new( one_line_source )
+ doc = doc[0]
+ assert(doc)
+ doc.write(test="")
+ assert_equal(correct, test)
+
+ multi_line_source = '<!DOCTYPE xsa PUBLIC
+ "-//LM Garshol//DTD XML Software Autoupdate 1.0//EN//XML"
+ "http://www.garshol.priv.no/download/xsa/xsa.dtd">
+ <a/>'
+ d = Document.new( multi_line_source )
+ doc = d[0]
+ assert(doc)
+ doc.write(test="")
+ assert_equal(correct, test)
+
+ odd_space_source = ' <!DOCTYPE
+ xsa PUBLIC "-//LM Garshol//DTD XML Software Autoupdate 1.0//EN//XML"
+ "http://www.garshol.priv.no/download/xsa/xsa.dtd"> <a/>'
+ d = Document.new( odd_space_source )
+ dt = d.doctype
+ dt.write(test="")
+ assert_equal(correct, test)
+
+ # OK, the BIG doctype test, numba wun
+ docin = File.new(fixture_path("doctype_test.xml"))
+ doc = Document.new(docin)
+ doc.write(test="")
+ assert_equal(31, doc.doctype.size)
+ end
- # Testing Root
- assert_equal doc.root.name.to_s, "element"
+ def test_document
+ # Testing cloning
+ source = "<element/>"
+ doc = Document.new source
- # Testing String source
- source = @xsa_source
- doc = Document.new source
- assert_instance_of XMLDecl, doc.xml_decl
- assert_instance_of DocType, doc.doctype
- assert_equal doc.version, "1.0"
+ # Testing Root
+ assert_equal doc.root.name.to_s, "element"
- source = File.new(fixture_path("dash.xml"))
- doc = Document.new source
- assert_equal "content-2", doc.elements["//content-2"].name
- end
+ # Testing String source
+ source = @xsa_source
+ doc = Document.new source
+ assert_instance_of XMLDecl, doc.xml_decl
+ assert_instance_of DocType, doc.doctype
+ assert_equal doc.version, "1.0"
- def test_instruction
- target = "use"
- content = "ruby"
- source = "<?#{target} #{content}?>"
+ source = File.new(fixture_path("dash.xml"))
+ doc = Document.new source
+ assert_equal "content-2", doc.elements["//content-2"].name
+ end
- instruction = Instruction.new target, content
- instruction2 = Instruction.new instruction
- assert_equal(instruction, instruction2)
- REXML::Formatters::Default.new.write( instruction, out = "" )
- assert_equal(source, out)
+ def test_instruction
+ target = "use"
+ content = "ruby"
+ source = "<?#{target} #{content}?>"
- d = Document.new( source )
- instruction2 = d[0]
- assert_equal(instruction.to_s, instruction2.to_s)
+ instruction = Instruction.new target, content
+ instruction2 = Instruction.new instruction
+ assert_equal(instruction, instruction2)
+ REXML::Formatters::Default.new.write( instruction, out = "" )
+ assert_equal(source, out)
- assert_raise(ParseException) {
- REXML::Document.new("<d><?foo bar></d>")
- }
- end
+ d = Document.new( source )
+ instruction2 = d[0]
+ assert_equal(instruction.to_s, instruction2.to_s)
- def test_parent
- parent = Parent.new
- begin
- parent << "Something"
- rescue Exception
- parent << Comment.new("Some comment")
- assert parent.size == 1, "size of parent should be 1"
- else
- assert_fail "should have gotten an exception trying to add a "+ "String to a Parent"
- end
-
- source = "<a><one/><three/><five/></a>"
- doc = Document.new source
- three = doc.root.elements["three"]
- doc.root.insert_before( three, Element.new("two") )
- nxt = doc.root.elements["one"]
- string = ""
- while nxt
- string << nxt.name
- nxt = nxt.next_sibling
- end
- assert_equal "onetwothreefive", string
-
-
- doc.root.insert_after( three, Element.new("four") )
- string = ""
- doc.root.each { |element| string << element.name }
- assert_equal "onetwothreefourfive", string
-
- string = ""
- nxt = doc.root.elements["five"]
- while nxt
- string << nxt.name
- nxt = nxt.previous_sibling
- end
- assert_equal "fivefourthreetwoone", string
-
- doc.insert_after "//two", Element.new("two-and-half")
- string = doc.root.elements.collect {|x| x.name}.join
- assert_equal "onetwotwo-and-halfthreefourfive", string
- doc.elements["/a/five"].insert_before "../four", Element.new("three-and-half")
- string = doc.root.elements.collect {|x| x.name}.join
- assert_equal "onetwotwo-and-halfthreethree-and-halffourfive", string
-
- doc.elements["/a/five"].previous_sibling = Element.new("four-and-half")
- string = doc.root.elements.collect {|x| x.name}.join
- assert_equal "onetwotwo-and-halfthreethree-and-halffourfour-and-halffive", string
- doc.elements["/a/one"].next_sibling = Element.new("one-and-half")
- string = doc.root.elements.collect {|x| x.name}.join
- assert_equal "oneone-and-halftwotwo-and-halfthreethree-and-halffourfour-and-halffive", string
-
- doc = Document.new "<a><one/><three/></a>"
- doc.root[1,0] = Element.new "two"
- string = ""
- doc.root.each { |el| string << el.name }
- assert_equal "onetwothree", string
- end
+ assert_raise(ParseException) {
+ REXML::Document.new("<d><?foo bar></d>")
+ }
+ end
- # The Source classes are tested extensively throughout the test suite
- def test_source
- # Testing string source
- source = @xsa_source
- doc = Document.new source
- assert_equal doc.root.name.to_s, "xsa"
+ def test_parent
+ parent = Parent.new
+ begin
+ parent << "Something"
+ rescue Exception
+ parent << Comment.new("Some comment")
+ assert parent.size == 1, "size of parent should be 1"
+ else
+ assert_fail "should have gotten an exception trying to add a "+ "String to a Parent"
+ end
- # Testing IO source
- doc = Document.new File.new(fixture_path("project.xml"))
- assert_equal doc.root.name.to_s, "Project"
- end
+ source = "<a><one/><three/><five/></a>"
+ doc = Document.new source
+ three = doc.root.elements["three"]
+ doc.root.insert_before( three, Element.new("two") )
+ nxt = doc.root.elements["one"]
+ string = ""
+ while nxt
+ string << nxt.name
+ nxt = nxt.next_sibling
+ end
+ assert_equal "onetwothreefive", string
- def test_text
- f = REXML::Formatters::Default.new
- string = "Some text"
- text = Text.new(string)
- assert_equal(string, text.to_s)
- text2 = Text.new(text)
- assert_equal(text, text2)
- #testing substitution
- string = "0 < ( 1 & 1 )"
- correct = "0 &lt; ( 1 &amp; 1 )"
- text = Text.new(string, true)
- f.write(text,out="")
- assert_equal(correct, out)
-
- string = "Cats &amp; dogs"
- text = Text.new(string, false, nil, true)
- assert_equal(string, text.to_s)
-
- string2 = "<a>#{string}</a>"
- doc = Document.new( string2, {
- :raw => %w{ a b }
- } )
- f.write(doc,out="")
- assert_equal(string2, out)
- b = doc.root.add_element( "b" )
- b.text = string
- assert_equal(string, b.get_text.to_s)
-
- c = doc.root.add_element("c")
- c.text = string
- assert_equal("Cats &amp;amp; dogs", c.get_text.to_s)
-
- # test all
- string = "<a>&amp;<b>&lt;</b><c>&gt;<d>&quot;</d></c></a>"
- doc = Document.new(string, { :raw => :all })
- assert_equal( "&amp;", doc.elements["/a"][0].to_s )
- assert_equal( "&", doc.elements["/a"].text )
- assert_equal( "&lt;", doc.elements["/a/b"][0].to_s )
- assert_equal( "<", doc.elements["/a/b"].text )
- assert_equal( "&gt;", doc.elements["/a/c"][0].to_s )
- assert_equal( ">", doc.elements["/a/c"].text )
- assert_equal( '&quot;', doc.elements["//d"][0].to_s )
- assert_equal( '"', doc.elements["//d"].text )
-
- # test some other stuff
- doc = Document.new('<a><b/></a>')
- doc.root.text = 'Sean'
- assert_equal( '<a><b/>Sean</a>', doc.to_s )
- doc.root.text = 'Elliott'
- assert_equal( '<a><b/>Elliott</a>', doc.to_s )
- doc.root.add_element( 'c' )
- assert_equal( '<a><b/>Elliott<c/></a>', doc.to_s )
- doc.root.text = 'Russell'
- assert_equal( '<a><b/>Russell<c/></a>', doc.to_s )
- doc.root.text = nil
- assert_equal( '<a><b/><c/></a>', doc.to_s )
- end
- def test_text_frozen
- string = "Frozen".freeze
- text = Text.new(string)
- assert_equal(string, text.to_s)
- end
+ doc.root.insert_after( three, Element.new("four") )
+ string = ""
+ doc.root.each { |element| string << element.name }
+ assert_equal "onetwothreefourfive", string
- def test_xmldecl
- source = "<?xml version='1.0'?>"
- # test args
- # test no args
- decl2 = XMLDecl.new
- assert_equal source, decl2.to_s
- # test XMLDecl
- decl2 = XMLDecl.new "1.0"
- assert_equal source, decl2.to_s
- end
+ string = ""
+ nxt = doc.root.elements["five"]
+ while nxt
+ string << nxt.name
+ nxt = nxt.previous_sibling
+ end
+ assert_equal "fivefourthreetwoone", string
+
+ doc.insert_after "//two", Element.new("two-and-half")
+ string = doc.root.elements.collect {|x| x.name}.join
+ assert_equal "onetwotwo-and-halfthreefourfive", string
+ doc.elements["/a/five"].insert_before "../four", Element.new("three-and-half")
+ string = doc.root.elements.collect {|x| x.name}.join
+ assert_equal "onetwotwo-and-halfthreethree-and-halffourfive", string
+
+ doc.elements["/a/five"].previous_sibling = Element.new("four-and-half")
+ string = doc.root.elements.collect {|x| x.name}.join
+ assert_equal "onetwotwo-and-halfthreethree-and-halffourfour-and-halffive", string
+ doc.elements["/a/one"].next_sibling = Element.new("one-and-half")
+ string = doc.root.elements.collect {|x| x.name}.join
+ assert_equal "oneone-and-halftwotwo-and-halfthreethree-and-halffourfour-and-halffive", string
+
+ doc = Document.new "<a><one/><three/></a>"
+ doc.root[1,0] = Element.new "two"
+ string = ""
+ doc.root.each { |el| string << el.name }
+ assert_equal "onetwothree", string
+ end
- def test_xmldecl_utf_16be_encoding_name
- assert_equal("<?xml version='1.0' encoding='UTF-16'?>",
- XMLDecl.new("1.0", "UTF-16").to_s)
- end
+ # The Source classes are tested extensively throughout the test suite
+ def test_source
+ # Testing string source
+ source = @xsa_source
+ doc = Document.new source
+ assert_equal doc.root.name.to_s, "xsa"
- def each_test( element, xpath, num_children )
- count = 0
- element.each_element( xpath ) { |child|
- count += 1
- yield child if block_given?
- }
- assert_equal num_children, count
- end
+ # Testing IO source
+ doc = Document.new File.new(fixture_path("project.xml"))
+ assert_equal doc.root.name.to_s, "Project"
+ end
- # This is the biggest test, as the number of permutations of xpath are
- # enormous.
- def test_element_access
- # Testing each_element
- doc = Document.new File.new(fixture_path("project.xml"))
-
- each_test( doc, "/", 1 ) { |child|
- assert_equal doc.name, child.name
- }
- each_test(doc, ".", 1) { |child| assert_equal doc, child }
- each_test(doc.root, "..", 1) { |child| assert_equal doc, child }
- each_test(doc.root, "*", 5)
- each_test(doc, "Project/Datasets", 1) { |child|
- assert_equal "Datasets", child.name
- }
- each_test(doc, "Project/Datasets/link", 2 )
- each_test(doc.root, "/Project/Description", 1) {|child|
- assert_equal "Description", child.name
- }
- each_test(doc.root, "./Description",1 ) { |child|
- assert_equal "Description",child.name
- }
- each_test(doc.root, "../Project",1 ) { |child|
- assert_equal doc.root, child
- }
- #each_test(doc,".../link",2) {|child| assert_equal "link",child.name.to_s}
-
- # test get_element
- first = doc.elements[ "Project" ]
- assert_equal doc.root, first
- second = doc.elements[ "Project" ].elements[1]
- third = doc.elements[ "Project/Creator" ]
- assert_equal second, third
- fourth = doc.elements[ "Project/Datasets/link[@idref='18']" ]
- assert_equal "Test data 1", fourth.attributes["name"]
-
- # Testing each_predicate
- each_test( doc, "Project/Datasets/link[@idref='18']", 1 ) { |child|
- assert_equal "Test data 1", child.attributes["name"]
- }
-
- # testing next/previous_element
- creator = doc.elements["//Creator"]
- lm = creator.next_element
- assert_equal "LastModifier", lm.name
- assert_equal "Creator", lm.previous_element.name
- end
+ def test_text
+ f = REXML::Formatters::Default.new
+ string = "Some text"
+ text = Text.new(string)
+ assert_equal(string, text.to_s)
+ text2 = Text.new(text)
+ assert_equal(text, text2)
+ #testing substitution
+ string = "0 < ( 1 & 1 )"
+ correct = "0 &lt; ( 1 &amp; 1 )"
+ text = Text.new(string, true)
+ f.write(text,out="")
+ assert_equal(correct, out)
+
+ string = "Cats &amp; dogs"
+ text = Text.new(string, false, nil, true)
+ assert_equal(string, text.to_s)
+
+ string2 = "<a>#{string}</a>"
+ doc = Document.new( string2, {
+ :raw => %w{ a b }
+ } )
+ f.write(doc,out="")
+ assert_equal(string2, out)
+ b = doc.root.add_element( "b" )
+ b.text = string
+ assert_equal(string, b.get_text.to_s)
+
+ c = doc.root.add_element("c")
+ c.text = string
+ assert_equal("Cats &amp;amp; dogs", c.get_text.to_s)
+
+ # test all
+ string = "<a>&amp;<b>&lt;</b><c>&gt;<d>&quot;</d></c></a>"
+ doc = Document.new(string, { :raw => :all })
+ assert_equal( "&amp;", doc.elements["/a"][0].to_s )
+ assert_equal( "&", doc.elements["/a"].text )
+ assert_equal( "&lt;", doc.elements["/a/b"][0].to_s )
+ assert_equal( "<", doc.elements["/a/b"].text )
+ assert_equal( "&gt;", doc.elements["/a/c"][0].to_s )
+ assert_equal( ">", doc.elements["/a/c"].text )
+ assert_equal( '&quot;', doc.elements["//d"][0].to_s )
+ assert_equal( '"', doc.elements["//d"].text )
+
+ # test some other stuff
+ doc = Document.new('<a><b/></a>')
+ doc.root.text = 'Sean'
+ assert_equal( '<a><b/>Sean</a>', doc.to_s )
+ doc.root.text = 'Elliott'
+ assert_equal( '<a><b/>Elliott</a>', doc.to_s )
+ doc.root.add_element( 'c' )
+ assert_equal( '<a><b/>Elliott<c/></a>', doc.to_s )
+ doc.root.text = 'Russell'
+ assert_equal( '<a><b/>Russell<c/></a>', doc.to_s )
+ doc.root.text = nil
+ assert_equal( '<a><b/><c/></a>', doc.to_s )
+ end
- def test_child
- sean = Element.new "Sean"
- rubbell = Element.new "Rubbell"
- elliott = sean.add_element "Elliott"
- sean << rubbell
- assert_equal elliott, rubbell.previous_sibling
- assert_equal rubbell, elliott.next_sibling
-
- russell = Element.new "Russell"
- rubbell.replace_with russell
- assert_equal elliott, russell.previous_sibling
- assert_equal russell, elliott.next_sibling
-
- assert_nil russell.document
- assert_equal sean, russell.root
- end
+ def test_text_frozen
+ string = "Frozen".freeze
+ text = Text.new(string)
+ assert_equal(string, text.to_s)
+ end
- # Most of this class is tested elsewhere. Here are the methods which
- # aren't used in any other class
- def test_element
- sean = Element.new "Sean"
- string = "1) He's a great guy!"
- sean.text = string
- russell = Element.new "Russell"
- sean << russell
-
- russell.attributes["email"] = "ser@germane-software.com"
- assert_equal russell.attributes["email"], "ser@germane-software.com"
- russell.attributes["webpage"] = "http://www.germane-software.com/~ser"
-
- assert sean.has_text?, "element should have text"
- assert_equal sean.text, string
- assert sean.has_elements?, "element should have one element"
- string = "2) What a stud!"
- sean.add_text string
- sean.text = "3) Super programmer!"
- sean.text = nil
- assert sean.has_text?, "element should still have text"
- assert_equal sean.text, string
-
- russell.delete_attribute "email"
- assert_nil russell.attributes["email"]
- russell.attributes.delete "webpage"
- assert !russell.has_attributes?, "element should have no attributes"
- end
+ def test_xmldecl
+ source = "<?xml version='1.0'?>"
+ # test args
+ # test no args
+ decl2 = XMLDecl.new
+ assert_equal source, decl2.to_s
+ # test XMLDecl
+ decl2 = XMLDecl.new "1.0"
+ assert_equal source, decl2.to_s
+ end
- def test_no_format
- source = "<a><b><c>blah</c><d/></b></a>"
- out = ""
- doc = Document.new( source )
- doc.write(out)
- assert_equal(source, out)
- end
+ def test_xmldecl_utf_16be_encoding_name
+ assert_equal("<?xml version='1.0' encoding='UTF-16'?>",
+ XMLDecl.new("1.0", "UTF-16").to_s)
+ end
- def test_namespace
- source = <<-EOF
- <x xmlns:foo="http://www.bar.com/schema">
- </x>
- EOF
- doc = Document.new(source)
- assert_equal("http://www.bar.com/schema", doc.root.namespace( "foo" ))
- source = <<-EOF
- <!-- bar namespace is "someuri" -->
- <foo:bar xmlns="default" xmlns:foo="someuri">
- <!-- a namespace is "default" -->
- <a/>
- <!-- foo:b namespace is "someuri" -->
- <foo:b>
- <!-- c namespace is "default" -->
- <c/>
- </foo:b>
- <!-- d namespace is "notdefault" -->
- <d xmlns="notdefault">
- <!-- e namespace is "notdefault" -->
- <e/>
- <f xmlns="">
- <g/>
- </f>
- </d>
- </foo:bar>
- EOF
- doc = Document.new source
- assert_equal "someuri", doc.root.namespace
- assert_equal "default", doc.root.elements[1].namespace
- assert_equal "someuri", doc.root.elements[2].namespace
- assert_equal "notdefault", doc.root.elements[ 3 ].namespace
-
- # Testing namespaces in attributes
- source = <<-EOF
- <a xmlns:b="uri">
- <b b:a="x" a="y"/>
- <c xmlns="foo">
- </c>
- </a>
- EOF
- doc = Document.new source
- b = doc.root.elements["b"]
- assert_equal "x", b.attributes["b:a"]
- assert_equal "y", b.attributes["a"]
-
- doc = Document.new
- doc.add_element "sean:blah"
- doc.root.text = "Some text"
- out = ""
- doc.write(out)
- assert_equal "<sean:blah>Some text</sean:blah>", out
- end
+ def each_test( element, xpath, num_children )
+ count = 0
+ element.each_element( xpath ) { |child|
+ count += 1
+ yield child if block_given?
+ }
+ assert_equal num_children, count
+ end
+
+ # This is the biggest test, as the number of permutations of xpath are
+ # enormous.
+ def test_element_access
+ # Testing each_element
+ doc = Document.new File.new(fixture_path("project.xml"))
+
+ each_test( doc, "/", 1 ) { |child|
+ assert_equal doc.name, child.name
+ }
+ each_test(doc, ".", 1) { |child| assert_equal doc, child }
+ each_test(doc.root, "..", 1) { |child| assert_equal doc, child }
+ each_test(doc.root, "*", 5)
+ each_test(doc, "Project/Datasets", 1) { |child|
+ assert_equal "Datasets", child.name
+ }
+ each_test(doc, "Project/Datasets/link", 2 )
+ each_test(doc.root, "/Project/Description", 1) {|child|
+ assert_equal "Description", child.name
+ }
+ each_test(doc.root, "./Description",1 ) { |child|
+ assert_equal "Description",child.name
+ }
+ each_test(doc.root, "../Project",1 ) { |child|
+ assert_equal doc.root, child
+ }
+ #each_test(doc,".../link",2) {|child| assert_equal "link",child.name.to_s}
+
+ # test get_element
+ first = doc.elements[ "Project" ]
+ assert_equal doc.root, first
+ second = doc.elements[ "Project" ].elements[1]
+ third = doc.elements[ "Project/Creator" ]
+ assert_equal second, third
+ fourth = doc.elements[ "Project/Datasets/link[@idref='18']" ]
+ assert_equal "Test data 1", fourth.attributes["name"]
+
+ # Testing each_predicate
+ each_test( doc, "Project/Datasets/link[@idref='18']", 1 ) { |child|
+ assert_equal "Test data 1", child.attributes["name"]
+ }
+
+ # testing next/previous_element
+ creator = doc.elements["//Creator"]
+ lm = creator.next_element
+ assert_equal "LastModifier", lm.name
+ assert_equal "Creator", lm.previous_element.name
+ end
+ def test_child
+ sean = Element.new "Sean"
+ rubbell = Element.new "Rubbell"
+ elliott = sean.add_element "Elliott"
+ sean << rubbell
+ assert_equal elliott, rubbell.previous_sibling
+ assert_equal rubbell, elliott.next_sibling
+
+ russell = Element.new "Russell"
+ rubbell.replace_with russell
+ assert_equal elliott, russell.previous_sibling
+ assert_equal russell, elliott.next_sibling
+
+ assert_nil russell.document
+ assert_equal sean, russell.root
+ end
- def test_add_namespace
- e = Element.new 'a'
- e.add_namespace 'someuri'
- e.add_namespace 'foo', 'otheruri'
- e.add_namespace 'xmlns:bar', 'thirduri'
- assert_equal 'someuri', e.attributes['xmlns']
- assert_equal 'otheruri', e.attributes['xmlns:foo']
- assert_equal 'thirduri', e.attributes['xmlns:bar']
- end
+ # Most of this class is tested elsewhere. Here are the methods which
+ # aren't used in any other class
+ def test_element
+ sean = Element.new "Sean"
+ string = "1) He's a great guy!"
+ sean.text = string
+ russell = Element.new "Russell"
+ sean << russell
+
+ russell.attributes["email"] = "ser@germane-software.com"
+ assert_equal russell.attributes["email"], "ser@germane-software.com"
+ russell.attributes["webpage"] = "http://www.germane-software.com/~ser"
+
+ assert sean.has_text?, "element should have text"
+ assert_equal sean.text, string
+ assert sean.has_elements?, "element should have one element"
+ string = "2) What a stud!"
+ sean.add_text string
+ sean.text = "3) Super programmer!"
+ sean.text = nil
+ assert sean.has_text?, "element should still have text"
+ assert_equal sean.text, string
+
+ russell.delete_attribute "email"
+ assert_nil russell.attributes["email"]
+ russell.attributes.delete "webpage"
+ assert !russell.has_attributes?, "element should have no attributes"
+ end
+ def test_no_format
+ source = "<a><b><c>blah</c><d/></b></a>"
+ out = ""
+ doc = Document.new( source )
+ doc.write(out)
+ assert_equal(source, out)
+ end
- def test_big_documentation
- f = File.new(fixture_path("documentation.xml"))
- d = Document.new f
- assert_equal "Sean Russell", d.elements["documentation/head/author"].text.tr("\n\t", " ").squeeze(" ")
- out = ""
- d.write out
- end
+ def test_namespace
+ source = <<-EOF
+ <x xmlns:foo="http://www.bar.com/schema">
+ </x>
+ EOF
+ doc = Document.new(source)
+ assert_equal("http://www.bar.com/schema", doc.root.namespace( "foo" ))
+ source = <<-EOF
+ <!-- bar namespace is "someuri" -->
+ <foo:bar xmlns="default" xmlns:foo="someuri">
+ <!-- a namespace is "default" -->
+ <a/>
+ <!-- foo:b namespace is "someuri" -->
+ <foo:b>
+ <!-- c namespace is "default" -->
+ <c/>
+ </foo:b>
+ <!-- d namespace is "notdefault" -->
+ <d xmlns="notdefault">
+ <!-- e namespace is "notdefault" -->
+ <e/>
+ <f xmlns="">
+ <g/>
+ </f>
+ </d>
+ </foo:bar>
+ EOF
+ doc = Document.new source
+ assert_equal "someuri", doc.root.namespace
+ assert_equal "default", doc.root.elements[1].namespace
+ assert_equal "someuri", doc.root.elements[2].namespace
+ assert_equal "notdefault", doc.root.elements[ 3 ].namespace
+
+ # Testing namespaces in attributes
+ source = <<-EOF
+ <a xmlns:b="uri">
+ <b b:a="x" a="y"/>
+ <c xmlns="foo">
+ </c>
+ </a>
+ EOF
+ doc = Document.new source
+ b = doc.root.elements["b"]
+ assert_equal "x", b.attributes["b:a"]
+ assert_equal "y", b.attributes["a"]
+
+ doc = Document.new
+ doc.add_element "sean:blah"
+ doc.root.text = "Some text"
+ out = ""
+ doc.write(out)
+ assert_equal "<sean:blah>Some text</sean:blah>", out
+ end
- def test_tutorial
- doc = Document.new File.new(fixture_path("tutorial.xml"))
- out = ""
- doc.write out
- end
- def test_stream
- c = Listener.new
- Document.parse_stream( File.new(fixture_path("documentation.xml")), c )
- assert(c.ts, "Stream parsing apparantly didn't parse the whole file")
- assert(c.te, "Stream parsing dropped end tag for documentation")
+ def test_add_namespace
+ e = Element.new 'a'
+ e.add_namespace 'someuri'
+ e.add_namespace 'foo', 'otheruri'
+ e.add_namespace 'xmlns:bar', 'thirduri'
+ assert_equal 'someuri', e.attributes['xmlns']
+ assert_equal 'otheruri', e.attributes['xmlns:foo']
+ assert_equal 'thirduri', e.attributes['xmlns:bar']
+ end
- Document.parse_stream("<a.b> <c/> </a.b>", c)
- Document.parse_stream("<a>&lt;&gt;&amp;</a>", c)
- assert_equal('<>&', c.normalize)
- end
+ def test_big_documentation
+ f = File.new(fixture_path("documentation.xml"))
+ d = Document.new f
+ assert_equal "Sean Russell", d.elements["documentation/head/author"].text.tr("\n\t", " ").squeeze(" ")
+ out = ""
+ d.write out
+ end
- def test_line
- Document.new File.new(fixture_path("bad.xml"))
- assert_fail "There should have been an error"
- rescue Exception
- # We should get here
- assert($!.line == 5, "Should have been an error on line 5, "+
- "but was reported as being on line #{$!.line}" )
- end
+ def test_tutorial
+ doc = Document.new File.new(fixture_path("tutorial.xml"))
+ out = ""
+ doc.write out
+ end
- def test_substitution
- val = "a'b\"c"
- el = Element.new("a")
- el.attributes["x"] = val
- REXML::Formatters::Default.new.write(el, out="")
+ def test_stream
+ c = Listener.new
+ Document.parse_stream( File.new(fixture_path("documentation.xml")), c )
+ assert(c.ts, "Stream parsing apparantly didn't parse the whole file")
+ assert(c.te, "Stream parsing dropped end tag for documentation")
- nel = Document.new( out)
- assert_equal( val, nel.root.attributes["x"] )
- end
+ Document.parse_stream("<a.b> <c/> </a.b>", c)
+
+ Document.parse_stream("<a>&lt;&gt;&amp;</a>", c)
+ assert_equal('<>&', c.normalize)
+ end
- def test_exception
- source = SourceFactory.create_from "<a/>"
- p = ParseException.new( "dummy message", source )
- begin
- raise "dummy"
+ def test_line
+ Document.new File.new(fixture_path("bad.xml"))
+ assert_fail "There should have been an error"
rescue Exception
- p.continued_exception = $!
+ # We should get here
+ assert($!.line == 5, "Should have been an error on line 5, "+
+ "but was reported as being on line #{$!.line}" )
end
- end
- def test_bad_content
- in_gt = '<root-el>content>content</root-el>'
- in_lt = '<root-el>content<content</root-el>'
+ def test_substitution
+ val = "a'b\"c"
+ el = Element.new("a")
+ el.attributes["x"] = val
+ REXML::Formatters::Default.new.write(el, out="")
- # This is OK
- tree_gt = Document.new in_gt
- assert_equal "content>content", tree_gt.elements[1].text
- # This isn't
- begin
- Document.new in_lt
- assert_fail "Should have gotten a parse error"
- rescue ParseException
+ nel = Document.new( out)
+ assert_equal( val, nel.root.attributes["x"] )
end
- end
-
- def test_iso_8859_1_output_function
- out = ""
- output = Output.new( out )
- koln_iso_8859_1 = "K\xF6ln"
- koln_utf8 = "K\xc3\xb6ln"
- source = Source.new( koln_iso_8859_1, 'iso-8859-1' )
- results = source.scan(/.*/)[0]
- koln_utf8.force_encoding('UTF-8') if koln_utf8.respond_to?(:force_encoding)
- assert_equal koln_utf8, results
- output << results
- if koln_iso_8859_1.respond_to?(:force_encoding)
- koln_iso_8859_1.force_encoding('ISO-8859-1')
- end
- assert_equal koln_iso_8859_1, out
- end
- def test_attributes_each
- doc = Document.new("<a xmlns:a='foo'><b x='1' y='2' z='3' a:x='4'/></a>")
- count = 0
- doc.root.elements[1].attributes.each {|k,v| count += 1 }
- assert_equal 4, count
- end
+ def test_exception
+ source = SourceFactory.create_from "<a/>"
+ p = ParseException.new( "dummy message", source )
+ begin
+ raise "dummy"
+ rescue Exception
+ p.continued_exception = $!
+ end
+ end
- def test_delete_namespace
- doc = Document.new "<a xmlns='1' xmlns:x='2'/>"
- doc.root.delete_namespace
- doc.root.delete_namespace 'x'
- assert_equal "<a/>", doc.to_s
- end
+ def test_bad_content
+ in_gt = '<root-el>content>content</root-el>'
+ in_lt = '<root-el>content<content</root-el>'
- def test_each_element_with_attribute
- doc = Document.new "<a><b id='1'/><c id='2'/><d id='1'/><e/></a>"
- arry = []
- block = proc { |e|
- assert arry.include?(e.name)
- arry.delete e.name
- }
- # Yields b, c, d
- arry = %w{b c d}
- doc.root.each_element_with_attribute( 'id', &block )
- assert_equal 0, arry.size
- # Yields b, d
- arry = %w{b d}
- doc.root.each_element_with_attribute( 'id', '1', &block )
- assert_equal 0, arry.size
- # Yields b
- arry = ['b']
- doc.root.each_element_with_attribute( 'id', '1', 1, &block )
- assert_equal 0, arry.size
- # Yields d
- arry = ['d']
- doc.root.each_element_with_attribute( 'id', '1', 0, 'd', &block )
- assert_equal 0, arry.size
- end
- def test_each_element_with_text
- doc = Document.new '<a><b>b</b><c>b</c><d>d</d><e/></a>'
- arry = []
- block = proc { |e|
- assert arry.include?(e.name)
- arry.delete e.name
- }
- # Yields b, c, d
- arry = %w{b c d}
- doc.root.each_element_with_text(&block)
- assert_equal 0, arry.size
- # Yields b, d
- arry = %w{b c}
- doc.root.each_element_with_text( 'b', &block )
- assert_equal 0, arry.size
- # Yields b
- arry = ['b']
- doc.root.each_element_with_text( 'b', 1, &block )
- assert_equal 0, arry.size
- # Yields d
- arry = ['d']
- doc.root.each_element_with_text( nil, 0, 'd', &block )
- assert_equal 0, arry.size
- end
+ # This is OK
+ tree_gt = Document.new in_gt
+ assert_equal "content>content", tree_gt.elements[1].text
+ # This isn't
+ begin
+ Document.new in_lt
+ assert_fail "Should have gotten a parse error"
+ rescue ParseException
+ end
+ end
- def test_element_parse_stream
- s = Source.new( "<a>some text</a>" )
- l = Listener.new
- class << l
- def tag_start name, attributes
- raise "Didn't find proper tag name" unless 'a'==name
+ def test_iso_8859_1_output_function
+ out = ""
+ output = Output.new( out )
+ koln_iso_8859_1 = "K\xF6ln"
+ koln_utf8 = "K\xc3\xb6ln"
+ source = Source.new( koln_iso_8859_1, 'iso-8859-1' )
+ results = source.scan(/.*/)[0]
+ koln_utf8.force_encoding('UTF-8') if koln_utf8.respond_to?(:force_encoding)
+ assert_equal koln_utf8, results
+ output << results
+ if koln_iso_8859_1.respond_to?(:force_encoding)
+ koln_iso_8859_1.force_encoding('ISO-8859-1')
end
+ assert_equal koln_iso_8859_1, out
end
- Document::parse_stream(s, l)
- end
+ def test_attributes_each
+ doc = Document.new("<a xmlns:a='foo'><b x='1' y='2' z='3' a:x='4'/></a>")
+ count = 0
+ doc.root.elements[1].attributes.each {|k,v| count += 1 }
+ assert_equal 4, count
+ end
- def test_deep_clone
- a = Document.new( '<?xml version="1"?><a x="y"><b>text</b>text<c><d><e>text</e></d></c></a>' )
- b = a.deep_clone
- assert_equal a.to_s, b.to_s
+ def test_delete_namespace
+ doc = Document.new "<a xmlns='1' xmlns:x='2'/>"
+ doc.root.delete_namespace
+ doc.root.delete_namespace 'x'
+ assert_equal "<a/>", doc.to_s
+ end
- a = Document.new( '<a>some &lt; text <b> more &gt; text </b> &gt; </a>' )
- b = a.deep_clone
- assert_equal a.to_s, b.to_s
- c = Document.new( b.to_s )
- assert_equal a.to_s, c.to_s
- end
+ def test_each_element_with_attribute
+ doc = Document.new "<a><b id='1'/><c id='2'/><d id='1'/><e/></a>"
+ arry = []
+ block = proc { |e|
+ assert arry.include?(e.name)
+ arry.delete e.name
+ }
+ # Yields b, c, d
+ arry = %w{b c d}
+ doc.root.each_element_with_attribute( 'id', &block )
+ assert_equal 0, arry.size
+ # Yields b, d
+ arry = %w{b d}
+ doc.root.each_element_with_attribute( 'id', '1', &block )
+ assert_equal 0, arry.size
+ # Yields b
+ arry = ['b']
+ doc.root.each_element_with_attribute( 'id', '1', 1, &block )
+ assert_equal 0, arry.size
+ # Yields d
+ arry = ['d']
+ doc.root.each_element_with_attribute( 'id', '1', 0, 'd', &block )
+ assert_equal 0, arry.size
+ end
+ def test_each_element_with_text
+ doc = Document.new '<a><b>b</b><c>b</c><d>d</d><e/></a>'
+ arry = []
+ block = proc { |e|
+ assert arry.include?(e.name)
+ arry.delete e.name
+ }
+ # Yields b, c, d
+ arry = %w{b c d}
+ doc.root.each_element_with_text(&block)
+ assert_equal 0, arry.size
+ # Yields b, d
+ arry = %w{b c}
+ doc.root.each_element_with_text( 'b', &block )
+ assert_equal 0, arry.size
+ # Yields b
+ arry = ['b']
+ doc.root.each_element_with_text( 'b', 1, &block )
+ assert_equal 0, arry.size
+ # Yields d
+ arry = ['d']
+ doc.root.each_element_with_text( nil, 0, 'd', &block )
+ assert_equal 0, arry.size
+ end
+
+ def test_element_parse_stream
+ s = Source.new( "<a>some text</a>" )
+ l = Listener.new
+ class << l
+ def tag_start name, attributes
+ raise "Didn't find proper tag name" unless 'a'==name
+ end
+ end
+
+ Document::parse_stream(s, l)
+ end
- def test_whitespace_before_root
- a = <<EOL
+ def test_deep_clone
+ a = Document.new( '<?xml version="1"?><a x="y"><b>text</b>text<c><d><e>text</e></d></c></a>' )
+ b = a.deep_clone
+ assert_equal a.to_s, b.to_s
+
+ a = Document.new( '<a>some &lt; text <b> more &gt; text </b> &gt; </a>' )
+ b = a.deep_clone
+ assert_equal a.to_s, b.to_s
+ c = Document.new( b.to_s )
+ assert_equal a.to_s, c.to_s
+ end
+
+ def test_whitespace_before_root
+ a = <<EOL
<?xml version='1.0'?>
<blo>
<wak>
</wak>
</blo>
EOL
- d = Document.new(a)
- b = ""
- d.write( b )
- assert_equal a,b
- end
+ d = Document.new(a)
+ b = ""
+ d.write( b )
+ assert_equal a,b
+ end
- def test_entities
- a = Document.new( '<a>&#101;&#x65;&#252;</a>' )
- assert_equal('eeü'.force_encoding("UTF-8"), a.root.text)
- end
+ def test_entities
+ a = Document.new( '<a>&#101;&#x65;&#252;</a>' )
+ assert_equal('eeü'.force_encoding("UTF-8"), a.root.text)
+ end
- def test_element_decl
- element_decl = Source.new("<!DOCTYPE foo [
+ def test_element_decl
+ element_decl = Source.new("<!DOCTYPE foo [
<!ELEMENT bar (#PCDATA)>
]>")
- doc = Document.new( element_decl )
- d = doc[0]
- assert_equal("<!ELEMENT bar (#PCDATA)>", d.to_s.split(/\n/)[1].strip)
- end
+ doc = Document.new( element_decl )
+ d = doc[0]
+ assert_equal("<!ELEMENT bar (#PCDATA)>", d.to_s.split(/\n/)[1].strip)
+ end
- def test_attlist_decl
- doc = Document.new <<-EOL
- <!DOCTYPE blah [
- <!ATTLIST blah
- xmlns CDATA "foo">
- <!ATTLIST a
- bar CDATA "gobble"
- xmlns:one CDATA "two"
- >
- ]>
- <a xmlns:three='xxx' three='yyy'><one:b/><three:c/></a>
- EOL
- assert_equal 'gobble', doc.root.attributes['bar']
- assert_equal 'xxx', doc.root.elements[2].namespace
- assert_equal 'two', doc.root.elements[1].namespace
- assert_equal 'foo', doc.root.namespace
-
- doc = Document.new <<-EOL
- <?xml version="1.0"?>
- <!DOCTYPE schema SYSTEM "XMLSchema.dtd" [
- <!ENTITY % p ''>
- <!ENTITY % s ''>
- <!ATTLIST schema
- xmlns:svg CDATA #FIXED "http://www.w3.org/2000/svg"
- xmlns:xlink CDATA #FIXED "http://www.w3.org/1999/xlink"
- xmlns:xml CDATA #FIXED "http://www.w3.org/XML/1998/namespace"
- >]>
- <schema/>
- EOL
- prefixes = doc.root.prefixes.sort
- correct = ['svg', 'xlink', 'xml']
- assert_equal correct, prefixes
- end
+ def test_attlist_decl
+ doc = Document.new <<-EOL
+ <!DOCTYPE blah [
+ <!ATTLIST blah
+ xmlns CDATA "foo">
+ <!ATTLIST a
+ bar CDATA "gobble"
+ xmlns:one CDATA "two"
+ >
+ ]>
+ <a xmlns:three='xxx' three='yyy'><one:b/><three:c/></a>
+ EOL
+ assert_equal 'gobble', doc.root.attributes['bar']
+ assert_equal 'xxx', doc.root.elements[2].namespace
+ assert_equal 'two', doc.root.elements[1].namespace
+ assert_equal 'foo', doc.root.namespace
+
+ doc = Document.new <<-EOL
+ <?xml version="1.0"?>
+ <!DOCTYPE schema SYSTEM "XMLSchema.dtd" [
+ <!ENTITY % p ''>
+ <!ENTITY % s ''>
+ <!ATTLIST schema
+ xmlns:svg CDATA #FIXED "http://www.w3.org/2000/svg"
+ xmlns:xlink CDATA #FIXED "http://www.w3.org/1999/xlink"
+ xmlns:xml CDATA #FIXED "http://www.w3.org/XML/1998/namespace"
+ >]>
+ <schema/>
+ EOL
+ prefixes = doc.root.prefixes.sort
+ correct = ['svg', 'xlink', 'xml']
+ assert_equal correct, prefixes
+ end
- def test_attlist_write
- file=File.new(fixture_path("foo.xml"))
- doc=Document.new file
- out = ''
- doc.write(out)
- end
+ def test_attlist_write
+ file=File.new(fixture_path("foo.xml"))
+ doc=Document.new file
+ out = ''
+ doc.write(out)
+ end
- def test_more_namespaces
- assert_raise( REXML::UndefinedNamespaceException,
- %Q{Should have gotten an Undefined Namespace error} ) {
- Document.new("<r><p><n:c/></p></r>")
- }
- doc2 = Document.new("<r xmlns:n='1'><p><n:c/></p></r>")
- es = XPath.match(doc2, '//c')
- assert_equal 0, es.size
- es = XPath.match(doc2, '//n:c')
- assert_equal 1, es.size
- doc2.root.add_namespace('m', '2')
- doc2.root.add_element("m:o")
- es = XPath.match(doc2, './/o')
- assert_equal 0, es.size
- es = XPath.match(doc2, '//n:c')
- assert_equal 1, es.size
- end
+ def test_more_namespaces
+ assert_raise( REXML::UndefinedNamespaceException,
+ %Q{Should have gotten an Undefined Namespace error} ) {
+ Document.new("<r><p><n:c/></p></r>")
+ }
+ doc2 = Document.new("<r xmlns:n='1'><p><n:c/></p></r>")
+ es = XPath.match(doc2, '//c')
+ assert_equal 0, es.size
+ es = XPath.match(doc2, '//n:c')
+ assert_equal 1, es.size
+ doc2.root.add_namespace('m', '2')
+ doc2.root.add_element("m:o")
+ es = XPath.match(doc2, './/o')
+ assert_equal 0, es.size
+ es = XPath.match(doc2, '//n:c')
+ assert_equal 1, es.size
+ end
- def test_ticket_51
- doc = REXML::Document.new <<-EOL
- <test xmlns='1' xmlns:x='1'>
- <a>X</a>
- <x:a>Y</x:a>
-
- <b xmlns='2'>
- <a>Z</a>
- </b>
- </test>
- EOL
-
- # The most common case. People not caring about the namespaces much.
- assert_equal( "XY", XPath.match( doc, "/test/a/text()" ).join )
- assert_equal( "XY", XPath.match( doc, "/test/x:a/text()" ).join )
- # Surprising? I don't think so, if you believe my definition of the "common case"
- assert_equal( "XYZ", XPath.match( doc, "//a/text()" ).join )
-
- # These are the uncommon cases. Namespaces are actually important, so we define our own
- # mappings, and pass them in.
- assert_equal( "XY", XPath.match( doc, "/f:test/f:a/text()", { "f" => "1" } ).join )
- # The namespaces are defined, and override the original mappings
- assert_equal( "", XPath.match( doc, "/test/a/text()", { "f" => "1" } ).join )
- assert_equal( "", XPath.match( doc, "/x:test/x:a/text()", { "f" => "1" } ).join )
- assert_equal( "", XPath.match( doc, "//a/text()", { "f" => "1" } ).join )
- end
+ def test_ticket_51
+ doc = REXML::Document.new <<-EOL
+ <test xmlns='1' xmlns:x='1'>
+ <a>X</a>
+ <x:a>Y</x:a>
+
+ <b xmlns='2'>
+ <a>Z</a>
+ </b>
+ </test>
+ EOL
+
+ # The most common case. People not caring about the namespaces much.
+ assert_equal( "XY", XPath.match( doc, "/test/a/text()" ).join )
+ assert_equal( "XY", XPath.match( doc, "/test/x:a/text()" ).join )
+ # Surprising? I don't think so, if you believe my definition of the "common case"
+ assert_equal( "XYZ", XPath.match( doc, "//a/text()" ).join )
+
+ # These are the uncommon cases. Namespaces are actually important, so we define our own
+ # mappings, and pass them in.
+ assert_equal( "XY", XPath.match( doc, "/f:test/f:a/text()", { "f" => "1" } ).join )
+ # The namespaces are defined, and override the original mappings
+ assert_equal( "", XPath.match( doc, "/test/a/text()", { "f" => "1" } ).join )
+ assert_equal( "", XPath.match( doc, "/x:test/x:a/text()", { "f" => "1" } ).join )
+ assert_equal( "", XPath.match( doc, "//a/text()", { "f" => "1" } ).join )
+ end
- def test_processing_instruction
- d = Document.new("<a><?foo bar?><?foo2 bar2?><b><?foo3 bar3?></b><?foo4 bar4?></a>")
- assert_equal 4, XPath.match(d, '//processing-instruction()' ).size
- match = XPath.match(d, "//processing-instruction('foo3')" )
- assert_equal 1, match.size
- assert_equal 'bar3', match[0].content
- end
+ def test_processing_instruction
+ d = Document.new("<a><?foo bar?><?foo2 bar2?><b><?foo3 bar3?></b><?foo4 bar4?></a>")
+ assert_equal 4, XPath.match(d, '//processing-instruction()' ).size
+ match = XPath.match(d, "//processing-instruction('foo3')" )
+ assert_equal 1, match.size
+ assert_equal 'bar3', match[0].content
+ end
- def test_oses_with_bad_EOLs
- Document.new("\n\n\n<?xml version='1.0'?>\n\n\n<a/>\n\n")
- end
+ def test_oses_with_bad_EOLs
+ Document.new("\n\n\n<?xml version='1.0'?>\n\n\n<a/>\n\n")
+ end
- # Contributed (with patch to fix bug) by Kouhei
- def test_ignore_whitespace
- source = "<a> <b/> abc <![CDATA[def]]> </a>"
+ # Contributed (with patch to fix bug) by Kouhei
+ def test_ignore_whitespace
+ source = "<a> <b/> abc <![CDATA[def]]> </a>"
- context_all = {:ignore_whitespace_nodes => :all}
- context_a = {:ignore_whitespace_nodes => %(a)}
- context_b = {:ignore_whitespace_nodes => %(b)}
+ context_all = {:ignore_whitespace_nodes => :all}
+ context_a = {:ignore_whitespace_nodes => %(a)}
+ context_b = {:ignore_whitespace_nodes => %(b)}
- tests = [[[" abc ", "def"], context_all],
- [[" abc ", "def"], context_a],
- [[" ", " abc ", "def", " "], context_b]]
+ tests = [[[" abc ", "def"], context_all],
+ [[" abc ", "def"], context_a],
+ [[" ", " abc ", "def", " "], context_b]]
- tests.each do |test|
- assert_equal(test[0], Document.new(source, test[1]).root.texts.collect{|x|
- x.to_s})
+ tests.each do |test|
+ assert_equal(test[0], Document.new(source, test[1]).root.texts.collect{|x|
+ x.to_s})
+ end
end
- end
- def test_0xD_in_preface
- doc = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\x0D<opml version=\"1.0\">\x0D</opml>"
- doc = Document.new doc
- end
+ def test_0xD_in_preface
+ doc = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\x0D<opml version=\"1.0\">\x0D</opml>"
+ doc = Document.new doc
+ end
- def test_hyphens_in_doctype
- doc = REXML::Document.new <<-EOQ
- <?xml version="1.0"?>
- <!DOCTYPE a-b-c>
- <a-b-c>
- <a/>
- </a-b-c>
- EOQ
+ def test_hyphens_in_doctype
+ doc = REXML::Document.new <<-EOQ
+ <?xml version="1.0"?>
+ <!DOCTYPE a-b-c>
+ <a-b-c>
+ <a/>
+ </a-b-c>
+ EOQ
- assert_equal('a-b-c', doc.doctype.name)
- end
+ assert_equal('a-b-c', doc.doctype.name)
+ end
- def test_accents
- docs = [
- %Q{<?xml version="1.0" encoding="ISO-8859-1"?>
+ def test_accents
+ docs = [
+ %Q{<?xml version="1.0" encoding="ISO-8859-1"?>
<gnuPod>
<files>
<file id="57" artist="Coralie Cl\357\277\275ent" />
</files>
</gnuPod>},
- '<?xml version="1.0" encoding="ISO-8859-1"?>
+ '<?xml version="1.0" encoding="ISO-8859-1"?>
<gnuPod>
<files>
<file id="71" album="Astrakan Caf" />
</files>
</gnuPod>',
- %Q{<?xml version="1.0" encoding="ISO-8859-1"?>
+ %Q{<?xml version="1.0" encoding="ISO-8859-1"?>
<gnuPod>
<files>
<file id="71" album="Astrakan Caf\357\277\275eria" />
</files>
</gnuPod>},
- %Q{<?xml version="1.0" encoding="ISO-8859-1"?>
+ %Q{<?xml version="1.0" encoding="ISO-8859-1"?>
<gnuPod>
<files>
<file id="71" album="Astrakan Caf\357\277\275" />
</files>
</gnuPod>} ]
- docs.each_with_index { |d,i|
- begin
- REXML::Document.new(d)
- rescue
- puts "#{i} => #{docs[i]}"
- raise
- end
- }
- end
+ docs.each_with_index { |d,i|
+ begin
+ REXML::Document.new(d)
+ rescue
+ puts "#{i} => #{docs[i]}"
+ raise
+ end
+ }
+ end
- def test_replace_text
- e = REXML::Element.new( "a" )
- e.add_text( "foo" )
- assert_equal( "<a>foo</a>", e.to_s )
- e[0].value = "bar"
- assert_equal( "<a>bar</a>", e.to_s )
- e[0].value = "<"
- assert_equal( "<a>&lt;</a>", e.to_s )
- assert_equal( "<", e[0].value )
- end
+ def test_replace_text
+ e = REXML::Element.new( "a" )
+ e.add_text( "foo" )
+ assert_equal( "<a>foo</a>", e.to_s )
+ e[0].value = "bar"
+ assert_equal( "<a>bar</a>", e.to_s )
+ e[0].value = "<"
+ assert_equal( "<a>&lt;</a>", e.to_s )
+ assert_equal( "<", e[0].value )
+ end
- def test_write_doctype
- ## XML Document and Declaration
- document = REXML::Document.new
- xmldecl = REXML::XMLDecl.new("1.0", "UTF-8")
- document.add(xmldecl)
- s = ""
- document.write(s)
+ def test_write_doctype
+ ## XML Document and Declaration
+ document = REXML::Document.new
+ xmldecl = REXML::XMLDecl.new("1.0", "UTF-8")
+ document.add(xmldecl)
+ s = ""
+ document.write(s)
- ## XML Doctype
- str = '<!DOCTYPE foo "bar">'
- source = REXML::Source.new(str)
- doctype = REXML::DocType.new(source)
- document.add(doctype)
- document.write(s)
+ ## XML Doctype
+ str = '<!DOCTYPE foo "bar">'
+ source = REXML::Source.new(str)
+ doctype = REXML::DocType.new(source)
+ document.add(doctype)
+ document.write(s)
- ## Element
- element = REXML::Element.new("hoge")
- document.add(element)
+ ## Element
+ element = REXML::Element.new("hoge")
+ document.add(element)
- document.write(s)
- end
+ document.write(s)
+ end
- def test_write_cdata
- src = "<a>A</a>"
- doc = REXML::Document.new( src )
- out = ""
- doc.write( out )
- assert_equal( src, out )
-
- src = "<a><![CDATA[A]]></a>"
- doc = REXML::Document.new( src )
- out = ""
- doc.write( out )
- assert_equal( src, out )
- end
+ def test_write_cdata
+ src = "<a>A</a>"
+ doc = REXML::Document.new( src )
+ out = ""
+ doc.write( out )
+ assert_equal( src, out )
+
+ src = "<a><![CDATA[A]]></a>"
+ doc = REXML::Document.new( src )
+ out = ""
+ doc.write( out )
+ assert_equal( src, out )
+ end
- def test_namespace_attributes
- source = <<-EOL
- <a xmlns:x="1">
- <x:b x:n="foo"/>
- </a>
- EOL
- d = Document.new( source )
- assert_equal( 'foo', REXML::XPath.first(d.root, "//x:b/@x:n").value )
- assert_equal( nil, REXML::XPath.first(d.root, "//x:b/@x:n", {}))
- end
+ def test_namespace_attributes
+ source = <<-EOL
+ <a xmlns:x="1">
+ <x:b x:n="foo"/>
+ </a>
+ EOL
+ d = Document.new( source )
+ assert_equal( 'foo', REXML::XPath.first(d.root, "//x:b/@x:n").value )
+ assert_equal( nil, REXML::XPath.first(d.root, "//x:b/@x:n", {}))
+ end
- def test_null_element_name
- a = REXML::Document.new
- assert_raise( RuntimeError ) {
- a.add_element( nil )
- }
- end
+ def test_null_element_name
+ a = REXML::Document.new
+ assert_raise( RuntimeError ) {
+ a.add_element( nil )
+ }
+ end
- def test_text_raw
- # From the REXML tutorial
- # (http://www.germane-software.com/software/rexml/test/data/tutorial.html)
- doc = Document.new <<-EOL
- <?xml version="1.0"?>
- <!DOCTYPE schema SYSTEM "XMLSchema.dtd" [
- <!ENTITY % s 'Sean'>
- ]>
- <a/>
- EOL
- a = doc.root
-
- # This makes sure that RAW text nodes don't have their entity strings
- # replaced
- t = Text.new "Sean", false, nil, true
- a.text = t
- assert_equal( "Sean", t.to_s )
- assert_equal( "Sean", t.value )
-
- # This makes sure that they do
- t = Text.new "Sean", false, nil, false
- a.text = t
- assert_equal( "&s;", t.to_s )
- assert_equal( "Sean", t.value )
-
- t = Text.new "&s;", false, nil, true
- a.text = t
- assert_equal( "&s;", t.to_s )
- assert_equal( "Sean", t.value )
-
- t = Text.new "&s;", false, nil, true
- a.text = t
- assert_equal( "&s;", t.to_s )
- assert_equal( "Sean", t.value )
-
- # Ticket #44
- t = REXML::Text.new( "&amp;", false, nil, true )
- assert_equal( "&amp;", t.to_s )
-
- t = REXML::Text.new("&amp;", false, false)
- assert_equal( "&amp;amp;", t.to_s )
- end
+ def test_text_raw
+ # From the REXML tutorial
+ # (http://www.germane-software.com/software/rexml/test/data/tutorial.html)
+ doc = Document.new <<-EOL
+ <?xml version="1.0"?>
+ <!DOCTYPE schema SYSTEM "XMLSchema.dtd" [
+ <!ENTITY % s 'Sean'>
+ ]>
+ <a/>
+ EOL
+ a = doc.root
+
+ # This makes sure that RAW text nodes don't have their entity strings
+ # replaced
+ t = Text.new "Sean", false, nil, true
+ a.text = t
+ assert_equal( "Sean", t.to_s )
+ assert_equal( "Sean", t.value )
+
+ # This makes sure that they do
+ t = Text.new "Sean", false, nil, false
+ a.text = t
+ assert_equal( "&s;", t.to_s )
+ assert_equal( "Sean", t.value )
+
+ t = Text.new "&s;", false, nil, true
+ a.text = t
+ assert_equal( "&s;", t.to_s )
+ assert_equal( "Sean", t.value )
+
+ t = Text.new "&s;", false, nil, true
+ a.text = t
+ assert_equal( "&s;", t.to_s )
+ assert_equal( "Sean", t.value )
+
+ # Ticket #44
+ t = REXML::Text.new( "&amp;", false, nil, true )
+ assert_equal( "&amp;", t.to_s )
+
+ t = REXML::Text.new("&amp;", false, false)
+ assert_equal( "&amp;amp;", t.to_s )
+ end
- def test_to_xpath
- doc = REXML::Document.new( %q{<tag1>
- <tag2 name="tag2"/>
- <tag2 name="tag2"/>
- </tag1>})
- names = %w{ /tag1/tag2[1] /tag1/tag2[2] }
- doc.root.elements.each_with_index {|el, i|
- assert_equal( names[i], el.xpath )
- }
- end
+ def test_to_xpath
+ doc = REXML::Document.new( %q{<tag1>
+ <tag2 name="tag2"/>
+ <tag2 name="tag2"/>
+ </tag1>})
+ names = %w{ /tag1/tag2[1] /tag1/tag2[2] }
+ doc.root.elements.each_with_index {|el, i|
+ assert_equal( names[i], el.xpath )
+ }
+ end
- def test_transitive
- doc = REXML::Document.new( "<a/>")
- s = ""
- doc.write( s, 0, true )
- end
+ def test_transitive
+ doc = REXML::Document.new( "<a/>")
+ s = ""
+ doc.write( s, 0, true )
+ end
- # This is issue #40
- def test_replace_with
- old = '<doc>old<foo/>old</doc>'
- d = REXML::Document.new(old).root
- new = REXML::Text.new('new',true,nil,true)
- child = d.children[2]
- child.replace_with(new)
- assert_equal( new, d.children[2] )
- end
+ # This is issue #40
+ def test_replace_with
+ old = '<doc>old<foo/>old</doc>'
+ d = REXML::Document.new(old).root
+ new = REXML::Text.new('new',true,nil,true)
+ child = d.children[2]
+ child.replace_with(new)
+ assert_equal( new, d.children[2] )
+ end
- def test_repeated_writes
- a = IO.read(fixture_path("iso8859-1.xml"))
- f = REXML::Formatters::Pretty.new
+ def test_repeated_writes
+ a = IO.read(fixture_path("iso8859-1.xml"))
+ f = REXML::Formatters::Pretty.new
- xmldoc = REXML::Document.new( a )
- a_andre = xmldoc.elements['//image'].attributes['caption']
+ xmldoc = REXML::Document.new( a )
+ a_andre = xmldoc.elements['//image'].attributes['caption']
- f.write(xmldoc,b="")
+ f.write(xmldoc,b="")
- xmldoc = REXML::Document.new(b)
- b_andre = xmldoc.elements['//image'].attributes['caption']
- assert_equal( a_andre, b_andre )
+ xmldoc = REXML::Document.new(b)
+ b_andre = xmldoc.elements['//image'].attributes['caption']
+ assert_equal( a_andre, b_andre )
- f.write(xmldoc,c="")
+ f.write(xmldoc,c="")
- xmldoc = REXML::Document.new(c)
- c_andre = xmldoc.elements['//image'].attributes['caption']
- assert_equal( b_andre, c_andre )
+ xmldoc = REXML::Document.new(c)
+ c_andre = xmldoc.elements['//image'].attributes['caption']
+ assert_equal( b_andre, c_andre )
- o = Output.new(d="","UTF-8")
- f.write(xmldoc,o)
- assert_not_equal( c, d )
- end
+ o = Output.new(d="","UTF-8")
+ f.write(xmldoc,o)
+ assert_not_equal( c, d )
+ end
- def test_pretty_format_long_text_finite
- n = 1_000_000
- long_text = 'aaaa ' * n
- xml = "<doc>#{long_text}</doc>"
- formatter = REXML::Formatters::Pretty.new
- document = nil
- begin
- document = REXML::Document.new(xml)
- rescue REXML::ParseException
- skip_message = "skip this test because we can't check Pretty#wrap " +
- "works without #<SystemStackError: stack level too deep> on " +
- "small memory system. #<RegexpError: failed to allocate memory> " +
- "will be raised on the system. See also [ruby-dev:42599]."
- return skip_message
- end
- output = ""
- formatter.write(document, output)
- assert_equal("<doc>\n" +
- ((" " + (" aaaa" * 15) + "\n") * (n / 15)) +
- " " + ("aaaa " * (n % 15)) + "\n" +
- "</doc>",
- output)
- end
+ def test_pretty_format_long_text_finite
+ n = 1_000_000
+ long_text = 'aaaa ' * n
+ xml = "<doc>#{long_text}</doc>"
+ formatter = REXML::Formatters::Pretty.new
+ document = nil
+ begin
+ document = REXML::Document.new(xml)
+ rescue REXML::ParseException
+ skip_message = "skip this test because we can't check Pretty#wrap " +
+ "works without #<SystemStackError: stack level too deep> on " +
+ "small memory system. #<RegexpError: failed to allocate memory> " +
+ "will be raised on the system. See also [ruby-dev:42599]."
+ return skip_message
+ end
+ output = ""
+ formatter.write(document, output)
+ assert_equal("<doc>\n" +
+ ((" " + (" aaaa" * 15) + "\n") * (n / 15)) +
+ " " + ("aaaa " * (n % 15)) + "\n" +
+ "</doc>",
+ output)
+ end
- def test_pretty_format_deep_indent
- n = 6
- elements = ""
- n.times do |i|
- elements << "<element#{i}>"
- elements << "element#{i} " * 5
- end
- (n - 1).downto(0) do |i|
- elements << "</element#{i}>"
- end
- xml = "<doc>#{elements}</doc>"
- document = REXML::Document.new(xml)
- formatter = REXML::Formatters::Pretty.new
- formatter.width = 20
- output = ""
- formatter.write(document, output)
- assert_equal(<<-XML.strip, output)
+ def test_pretty_format_deep_indent
+ n = 6
+ elements = ""
+ n.times do |i|
+ elements << "<element#{i}>"
+ elements << "element#{i} " * 5
+ end
+ (n - 1).downto(0) do |i|
+ elements << "</element#{i}>"
+ end
+ xml = "<doc>#{elements}</doc>"
+ document = REXML::Document.new(xml)
+ formatter = REXML::Formatters::Pretty.new
+ formatter.width = 20
+ output = ""
+ formatter.write(document, output)
+ assert_equal(<<-XML.strip, output)
<doc>
<element0>
element0
@@ -1212,114 +1212,114 @@ EOL
</element1>
</element0>
</doc>
- XML
- end
+ XML
+ end
- def test_ticket_58
- doc = REXML::Document.new
- doc << REXML::XMLDecl.default
- doc << REXML::Element.new("a")
+ def test_ticket_58
+ doc = REXML::Document.new
+ doc << REXML::XMLDecl.default
+ doc << REXML::Element.new("a")
- str = ""
- doc.write(str)
+ str = ""
+ doc.write(str)
- assert_equal("<a/>", str)
+ assert_equal("<a/>", str)
- doc = REXML::Document.new
- doc << REXML::XMLDecl.new("1.0", "UTF-8")
- doc << REXML::Element.new("a")
+ doc = REXML::Document.new
+ doc << REXML::XMLDecl.new("1.0", "UTF-8")
+ doc << REXML::Element.new("a")
- str = ""
- doc.write(str)
+ str = ""
+ doc.write(str)
- assert_equal("<?xml version='1.0' encoding='UTF-8'?><a/>", str)
- end
+ assert_equal("<?xml version='1.0' encoding='UTF-8'?><a/>", str)
+ end
- # Incomplete tags should generate an error
- def test_ticket_53
- assert_raise( REXML::ParseException ) {
- REXML::Document.new( "<a><b></a>" )
- }
- assert_raise( REXML::ParseException ) {
- REXML::Document.new( "<a><b>" )
- }
- assert_raise( REXML::ParseException ) {
- REXML::Document.new( "<a><b/>" )
- }
- end
+ # Incomplete tags should generate an error
+ def test_ticket_53
+ assert_raise( REXML::ParseException ) {
+ REXML::Document.new( "<a><b></a>" )
+ }
+ assert_raise( REXML::ParseException ) {
+ REXML::Document.new( "<a><b>" )
+ }
+ assert_raise( REXML::ParseException ) {
+ REXML::Document.new( "<a><b/>" )
+ }
+ end
- def test_ticket_52
- source = "<!-- this is a single line comment -->"
- d = REXML::Document.new(source)
- d.write(k="")
- assert_equal( source, k )
-
- source = "<a><!-- Comment --></a>"
- target = "<a>\n <!-- Comment -->\n</a>"
- d = REXML::Document.new(source)
- REXML::Formatters::Pretty.new(4).write(d,k="")
- assert_equal( target, k )
- end
+ def test_ticket_52
+ source = "<!-- this is a single line comment -->"
+ d = REXML::Document.new(source)
+ d.write(k="")
+ assert_equal( source, k )
+
+ source = "<a><!-- Comment --></a>"
+ target = "<a>\n <!-- Comment -->\n</a>"
+ d = REXML::Document.new(source)
+ REXML::Formatters::Pretty.new(4).write(d,k="")
+ assert_equal( target, k )
+ end
- def test_ticket_76
- src = "<div>at&t"
- assert_raise( ParseException, %Q{"#{src}" is invalid XML} ) {
- REXML::Document.new(src)
- }
- end
+ def test_ticket_76
+ src = "<div>at&t"
+ assert_raise( ParseException, %Q{"#{src}" is invalid XML} ) {
+ REXML::Document.new(src)
+ }
+ end
- def test_ticket_21
- src = "<foo bar=value/>"
- assert_raise( ParseException, "invalid XML should be caught" ) {
- Document.new(src)
- }
- begin
- Document.new(src)
- rescue
- assert_match( /missing attribute quote/, $!.message )
+ def test_ticket_21
+ src = "<foo bar=value/>"
+ assert_raise( ParseException, "invalid XML should be caught" ) {
+ Document.new(src)
+ }
+ begin
+ Document.new(src)
+ rescue
+ assert_match( /missing attribute quote/, $!.message )
+ end
end
- end
- def test_ticket_63
- Document.new(File.new(fixture_path("t63-1.xml")))
- end
+ def test_ticket_63
+ Document.new(File.new(fixture_path("t63-1.xml")))
+ end
- def test_ticket_75
- d = REXML::Document.new(File.new(fixture_path("t75.xml")))
- assert_equal("tree", d.root.name)
- end
+ def test_ticket_75
+ d = REXML::Document.new(File.new(fixture_path("t75.xml")))
+ assert_equal("tree", d.root.name)
+ end
- def test_ticket_48_part_II
- f = REXML::Formatters::Pretty.new
- #- rexml sanity check (bugs in ruby 1.8.4, ruby 1.8.6)
- xmldoc = Document.new("<test/>")
- xmldoc << XMLDecl.new(XMLDecl::DEFAULT_VERSION, "UTF-8")
- content = ['61c3a927223c3e26'].pack("H*")
- content.force_encoding('UTF-8') if content.respond_to?(:force_encoding)
- #- is some UTF-8 text but just to make sure my editor won't magically convert..
- xmldoc.root.add_attribute('attr', content)
- f.write(xmldoc,out=[])
-
- xmldoc = REXML::Document.new(out.join)
- sanity1 = xmldoc.root.attributes['attr']
- f.write(xmldoc,out=[])
-
- xmldoc = REXML::Document.new(out.join)
- sanity2 = xmldoc.root.attributes['attr']
- f.write(xmldoc,out=[])
-
- assert_equal( sanity1, sanity2 )
- end
+ def test_ticket_48_part_II
+ f = REXML::Formatters::Pretty.new
+ #- rexml sanity check (bugs in ruby 1.8.4, ruby 1.8.6)
+ xmldoc = Document.new("<test/>")
+ xmldoc << XMLDecl.new(XMLDecl::DEFAULT_VERSION, "UTF-8")
+ content = ['61c3a927223c3e26'].pack("H*")
+ content.force_encoding('UTF-8') if content.respond_to?(:force_encoding)
+ #- is some UTF-8 text but just to make sure my editor won't magically convert..
+ xmldoc.root.add_attribute('attr', content)
+ f.write(xmldoc,out=[])
+
+ xmldoc = REXML::Document.new(out.join)
+ sanity1 = xmldoc.root.attributes['attr']
+ f.write(xmldoc,out=[])
+
+ xmldoc = REXML::Document.new(out.join)
+ sanity2 = xmldoc.root.attributes['attr']
+ f.write(xmldoc,out=[])
+
+ assert_equal( sanity1, sanity2 )
+ end
- def test_ticket_88
- doc = REXML::Document.new("<?xml version=\"1.0\" encoding=\"shift_jis\"?>")
- assert_equal("<?xml version='1.0' encoding='SHIFT_JIS'?>", doc.to_s)
- doc = REXML::Document.new("<?xml version = \"1.0\" encoding = \"shift_jis\"?>")
- assert_equal("<?xml version='1.0' encoding='SHIFT_JIS'?>", doc.to_s)
- end
+ def test_ticket_88
+ doc = REXML::Document.new("<?xml version=\"1.0\" encoding=\"shift_jis\"?>")
+ assert_equal("<?xml version='1.0' encoding='SHIFT_JIS'?>", doc.to_s)
+ doc = REXML::Document.new("<?xml version = \"1.0\" encoding = \"shift_jis\"?>")
+ assert_equal("<?xml version='1.0' encoding='SHIFT_JIS'?>", doc.to_s)
+ end
- def test_ticket_85
- xml = <<ENDXML
+ def test_ticket_85
+ xml = <<ENDXML
<foo>
<bar>
<bob name='jimmy'/>
@@ -1327,138 +1327,138 @@ EOL
</foo>
ENDXML
- yml = "<foo>
+ yml = "<foo>
<bar>
<bob name='jimmy'/>
</bar>
</foo>"
- # The pretty printer ignores all whitespace, anyway so output1 == output2
- f = REXML::Formatters::Pretty.new( 2 )
- d = Document.new( xml, :ignore_whitespace_nodes=>:all )
- f.write( d, output1="" )
+ # The pretty printer ignores all whitespace, anyway so output1 == output2
+ f = REXML::Formatters::Pretty.new( 2 )
+ d = Document.new( xml, :ignore_whitespace_nodes=>:all )
+ f.write( d, output1="" )
- d = Document.new( xml )
- f.write( d, output2="" )
+ d = Document.new( xml )
+ f.write( d, output2="" )
- # Output directives should override whitespace directives.
- assert_equal( output1, output2 )
+ # Output directives should override whitespace directives.
+ assert_equal( output1, output2 )
- # The base case.
- d = Document.new(yml)
- f.write( d, output3="" )
+ # The base case.
+ d = Document.new(yml)
+ f.write( d, output3="" )
- assert_equal( output3.strip, output2.strip )
+ assert_equal( output3.strip, output2.strip )
- d = Document.new(yml)
- f.write( d, output4="" )
+ d = Document.new(yml)
+ f.write( d, output4="" )
- assert_equal( output3.strip, output4.strip )
- end
+ assert_equal( output3.strip, output4.strip )
+ end
- def test_ticket_91
- source="<root>
- <bah something='1' somethingelse='bah'>
- <something>great</something>
- </bah>
- </root>"
+ def test_ticket_91
+ source="<root>
+ <bah something='1' somethingelse='bah'>
+ <something>great</something>
+ </bah>
+ </root>"
expected="<root>
<bah something='1' somethingelse='bah'>
<something>great</something>
</bah>
<bah/>
</root>"
- d = Document.new( source )
- d.root.add_element( "bah" )
- p=REXML::Formatters::Pretty.new(2)
- p.compact = true # Don't add whitespace to text nodes unless necessary
- p.write(d,out="")
- assert_equal( expected, out )
- end
+ d = Document.new( source )
+ d.root.add_element( "bah" )
+ p=REXML::Formatters::Pretty.new(2)
+ p.compact = true # Don't add whitespace to text nodes unless necessary
+ p.write(d,out="")
+ assert_equal( expected, out )
+ end
- def test_ticket_95
- testd = REXML::Document.new "<a><b><c/><c/><c/></b></a>"
- testd.write(out1="")
- testd.elements["//c[2]"].xpath
- testd.write(out2="")
- assert_equal(out1,out2)
- end
+ def test_ticket_95
+ testd = REXML::Document.new "<a><b><c/><c/><c/></b></a>"
+ testd.write(out1="")
+ testd.elements["//c[2]"].xpath
+ testd.write(out2="")
+ assert_equal(out1,out2)
+ end
- def test_ticket_102
- doc = REXML::Document.new '<doc xmlns="ns"><item name="foo"/></doc>'
- assert_equal( "foo", doc.root.elements["item"].attribute("name","ns").to_s )
- assert_equal( "item", doc.root.elements["item[@name='foo']"].name )
- end
+ def test_ticket_102
+ doc = REXML::Document.new '<doc xmlns="ns"><item name="foo"/></doc>'
+ assert_equal( "foo", doc.root.elements["item"].attribute("name","ns").to_s )
+ assert_equal( "item", doc.root.elements["item[@name='foo']"].name )
+ end
- def test_ticket_14
- # Per .2.5 Node Tests of XPath spec
- assert_raise( REXML::UndefinedNamespaceException,
- %Q{Should have gotten an Undefined Namespace error} ) {
- Document.new("<a><n:b/></a>")
- }
- end
+ def test_ticket_14
+ # Per .2.5 Node Tests of XPath spec
+ assert_raise( REXML::UndefinedNamespaceException,
+ %Q{Should have gotten an Undefined Namespace error} ) {
+ Document.new("<a><n:b/></a>")
+ }
+ end
- # 5.7 Text Nodes
- # Character data is grouped into text nodes. As much character data as
- # possible is grouped into each text node: a text node never has an
- # immediately following or preceding sibling that is a text node. The
- # string-value of a text node is the character data. A text node always has
- # at least one character of data.
- def test_ticket_105
- d = Document.new("<a/>")
- d.root.add_text( "a" )
- d.root.add_text( "b" )
- assert_equal( 1, d.root.children.size )
- end
+ # 5.7 Text Nodes
+ # Character data is grouped into text nodes. As much character data as
+ # possible is grouped into each text node: a text node never has an
+ # immediately following or preceding sibling that is a text node. The
+ # string-value of a text node is the character data. A text node always has
+ # at least one character of data.
+ def test_ticket_105
+ d = Document.new("<a/>")
+ d.root.add_text( "a" )
+ d.root.add_text( "b" )
+ assert_equal( 1, d.root.children.size )
+ end
- # phantom namespace same as default namespace
- def test_ticket_121
- doc = REXML::Document.new(
- '<doc xmlns="ns" xmlns:phantom="ns"><item name="foo">text</item></doc>'
- )
- assert_equal 'text', doc.text( "/doc/item[@name='foo']" )
- assert_equal "name='foo'",
- doc.root.elements["item"].attribute("name", "ns").inspect
- assert_equal "<item name='foo'>text</item>",
- doc.root.elements["item[@name='foo']"].to_s
- end
+ # phantom namespace same as default namespace
+ def test_ticket_121
+ doc = REXML::Document.new(
+ '<doc xmlns="ns" xmlns:phantom="ns"><item name="foo">text</item></doc>'
+ )
+ assert_equal 'text', doc.text( "/doc/item[@name='foo']" )
+ assert_equal "name='foo'",
+ doc.root.elements["item"].attribute("name", "ns").inspect
+ assert_equal "<item name='foo'>text</item>",
+ doc.root.elements["item[@name='foo']"].to_s
+ end
- def test_ticket_135
- bean_element = REXML::Element.new("bean")
- textToAdd = "(&#38;(|(memberof=CN=somegroupabcdefgh,OU=OUsucks,DC=hookemhorns,DC=com)(mail=*someco.com))(acct=%u)(!(extraparameter:2.2.222.222222.2.2.222:=2)))"
- bean_element.add_element("prop", {"key"=> "filter"}).add_text(textToAdd)
- doc = REXML::Document.new
- doc.add_element(bean_element)
+ def test_ticket_135
+ bean_element = REXML::Element.new("bean")
+ textToAdd = "(&#38;(|(memberof=CN=somegroupabcdefgh,OU=OUsucks,DC=hookemhorns,DC=com)(mail=*someco.com))(acct=%u)(!(extraparameter:2.2.222.222222.2.2.222:=2)))"
+ bean_element.add_element("prop", {"key"=> "filter"}).add_text(textToAdd)
+ doc = REXML::Document.new
+ doc.add_element(bean_element)
- REXML::Formatters::Pretty.new(3).write( doc, out = "" )
+ REXML::Formatters::Pretty.new(3).write( doc, out = "" )
- assert_equal "<bean>\n <prop key='filter'>\n (&amp;#38;(|(memberof=CN=somegroupabcdefgh,OU=OUsucks,DC=hookemhorns,DC=com)(mail=*someco.com))(acct=%u)(!(extraparameter:2.2.222.222222.2.2.222:=2)))\n </prop>\n</bean>", out
- end
+ assert_equal "<bean>\n <prop key='filter'>\n (&amp;#38;(|(memberof=CN=somegroupabcdefgh,OU=OUsucks,DC=hookemhorns,DC=com)(mail=*someco.com))(acct=%u)(!(extraparameter:2.2.222.222222.2.2.222:=2)))\n </prop>\n</bean>", out
+ end
- def test_ticket_138
- doc = REXML::Document.new(
- '<svg xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" ' +
- 'inkscape:version="0.44" version="1.0"/>'
- )
- expected = {
- "inkscape" => attribute("xmlns:inkscape",
- "http://www.inkscape.org/namespaces/inkscape"),
- "version" => {
- "inkscape" => attribute("inkscape:version", "0.44"),
- "" => attribute("version", "1.0"),
- },
- }
- assert_equal(expected, doc.root.attributes)
- assert_equal(expected, REXML::Document.new(doc.root.to_s).root.attributes)
- end
+ def test_ticket_138
+ doc = REXML::Document.new(
+ '<svg xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" ' +
+ 'inkscape:version="0.44" version="1.0"/>'
+ )
+ expected = {
+ "inkscape" => attribute("xmlns:inkscape",
+ "http://www.inkscape.org/namespaces/inkscape"),
+ "version" => {
+ "inkscape" => attribute("inkscape:version", "0.44"),
+ "" => attribute("version", "1.0"),
+ },
+ }
+ assert_equal(expected, doc.root.attributes)
+ assert_equal(expected, REXML::Document.new(doc.root.to_s).root.attributes)
+ end
- def test_empty_doc
- assert(REXML::Document.new('').children.empty?)
- end
+ def test_empty_doc
+ assert(REXML::Document.new('').children.empty?)
+ end
- private
- def attribute(name, value)
- REXML::Attribute.new(name, value)
+ private
+ def attribute(name, value)
+ REXML::Attribute.new(name, value)
+ end
end
end
-end
diff --git a/test/rexml/test_doctype.rb b/test/rexml/test_doctype.rb
index 63c2ed9..0b3ea11 100644
--- a/test/rexml/test_doctype.rb
+++ b/test/rexml/test_doctype.rb
@@ -2,105 +2,105 @@ require 'test/unit'
require 'rexml/document'
module REXMLTests
-class TestDocTypeAccessor < Test::Unit::TestCase
-
- def setup
- @sysid = "urn:x-test:sysid1"
- @notid1 = "urn:x-test:notation1"
- @notid2 = "urn:x-test:notation2"
- document_string1 = <<-"XMLEND"
- <!DOCTYPE r SYSTEM "#{@sysid}" [
- <!NOTATION n1 SYSTEM "#{@notid1}">
- <!NOTATION n2 SYSTEM "#{@notid2}">
- ]>
- <r/>
- XMLEND
- @doctype1 = REXML::Document.new(document_string1).doctype
-
- @pubid = "TEST_ID"
- document_string2 = <<-"XMLEND"
- <!DOCTYPE r PUBLIC "#{@pubid}">
- <r/>
- XMLEND
- @doctype2 = REXML::Document.new(document_string2).doctype
-
- document_string3 = <<-"XMLEND"
- <!DOCTYPE r PUBLIC "#{@pubid}" "#{@sysid}">
- <r/>
- XMLEND
- @doctype3 = REXML::Document.new(document_string3).doctype
+ class TestDocTypeAccessor < Test::Unit::TestCase
+
+ def setup
+ @sysid = "urn:x-test:sysid1"
+ @notid1 = "urn:x-test:notation1"
+ @notid2 = "urn:x-test:notation2"
+ document_string1 = <<-"XMLEND"
+ <!DOCTYPE r SYSTEM "#{@sysid}" [
+ <!NOTATION n1 SYSTEM "#{@notid1}">
+ <!NOTATION n2 SYSTEM "#{@notid2}">
+ ]>
+ <r/>
+ XMLEND
+ @doctype1 = REXML::Document.new(document_string1).doctype
+
+ @pubid = "TEST_ID"
+ document_string2 = <<-"XMLEND"
+ <!DOCTYPE r PUBLIC "#{@pubid}">
+ <r/>
+ XMLEND
+ @doctype2 = REXML::Document.new(document_string2).doctype
+
+ document_string3 = <<-"XMLEND"
+ <!DOCTYPE r PUBLIC "#{@pubid}" "#{@sysid}">
+ <r/>
+ XMLEND
+ @doctype3 = REXML::Document.new(document_string3).doctype
+
+ end
+
+ def test_public
+ assert_equal(nil, @doctype1.public)
+ assert_equal(@pubid, @doctype2.public)
+ assert_equal(@pubid, @doctype3.public)
+ end
+
+ def test_system
+ assert_equal(@sysid, @doctype1.system)
+ assert_equal(nil, @doctype2.system)
+ assert_equal(@sysid, @doctype3.system)
+ end
+
+ def test_notation
+ assert_equal(@notid1, @doctype1.notation("n1").system)
+ assert_equal(@notid2, @doctype1.notation("n2").system)
+ end
+
+ def test_notations
+ notations = @doctype1.notations
+ assert_equal(2, notations.length)
+ assert_equal(@notid1, find_notation(notations, "n1").system)
+ assert_equal(@notid2, find_notation(notations, "n2").system)
+ end
+
+ def find_notation(notations, name)
+ notations.find { |notation|
+ name == notation.name
+ }
+ end
end
- def test_public
- assert_equal(nil, @doctype1.public)
- assert_equal(@pubid, @doctype2.public)
- assert_equal(@pubid, @doctype3.public)
+ class TestNotationDeclPublic < Test::Unit::TestCase
+ def setup
+ @name = "vrml"
+ @id = "VRML 1.0"
+ @uri = "http://www.web3d.org/"
+ end
+
+ def test_to_s
+ assert_equal("<!NOTATION #{@name} PUBLIC \"#{@id}\">",
+ decl(@id, nil).to_s)
+ end
+
+ def test_to_s_with_uri
+ assert_equal("<!NOTATION #{@name} PUBLIC \"#{@id}\" \"#{@uri}\">",
+ decl(@id, @uri).to_s)
+ end
+
+ private
+ def decl(id, uri)
+ REXML::NotationDecl.new(@name, "PUBLIC", id, uri)
+ end
end
- def test_system
- assert_equal(@sysid, @doctype1.system)
- assert_equal(nil, @doctype2.system)
- assert_equal(@sysid, @doctype3.system)
+ class TestNotationDeclSystem < Test::Unit::TestCase
+ def setup
+ @name = "gif"
+ @id = "gif viewer"
+ end
+
+ def test_to_s
+ assert_equal("<!NOTATION #{@name} SYSTEM \"#{@id}\">",
+ decl(@id).to_s)
+ end
+
+ private
+ def decl(id)
+ REXML::NotationDecl.new(@name, "SYSTEM", id, nil)
+ end
end
-
- def test_notation
- assert_equal(@notid1, @doctype1.notation("n1").system)
- assert_equal(@notid2, @doctype1.notation("n2").system)
- end
-
- def test_notations
- notations = @doctype1.notations
- assert_equal(2, notations.length)
- assert_equal(@notid1, find_notation(notations, "n1").system)
- assert_equal(@notid2, find_notation(notations, "n2").system)
- end
-
- def find_notation(notations, name)
- notations.find { |notation|
- name == notation.name
- }
- end
-
-end
-
-class TestNotationDeclPublic < Test::Unit::TestCase
- def setup
- @name = "vrml"
- @id = "VRML 1.0"
- @uri = "http://www.web3d.org/"
- end
-
- def test_to_s
- assert_equal("<!NOTATION #{@name} PUBLIC \"#{@id}\">",
- decl(@id, nil).to_s)
- end
-
- def test_to_s_with_uri
- assert_equal("<!NOTATION #{@name} PUBLIC \"#{@id}\" \"#{@uri}\">",
- decl(@id, @uri).to_s)
- end
-
- private
- def decl(id, uri)
- REXML::NotationDecl.new(@name, "PUBLIC", id, uri)
- end
-end
-
-class TestNotationDeclSystem < Test::Unit::TestCase
- def setup
- @name = "gif"
- @id = "gif viewer"
- end
-
- def test_to_s
- assert_equal("<!NOTATION #{@name} SYSTEM \"#{@id}\">",
- decl(@id).to_s)
- end
-
- private
- def decl(id)
- REXML::NotationDecl.new(@name, "SYSTEM", id, nil)
- end
-end
end
diff --git a/test/rexml/test_elements.rb b/test/rexml/test_elements.rb
index 6a9b3bb..f253a75 100644
--- a/test/rexml/test_elements.rb
+++ b/test/rexml/test_elements.rb
@@ -2,117 +2,117 @@ require 'test/unit/testcase'
require 'rexml/document'
module REXMLTests
-class ElementsTester < Test::Unit::TestCase
- include REXML
- def test_accessor
- doc = Document.new '<a><b/><c id="1"/><c id="2"/><d/></a>'
- assert_equal 'b', doc.root.elements[1].name
- assert_equal '1', doc.root.elements['c'].attributes['id']
- assert_equal '2', doc.root.elements[2,'c'].attributes['id']
- end
+ class ElementsTester < Test::Unit::TestCase
+ include REXML
+ def test_accessor
+ doc = Document.new '<a><b/><c id="1"/><c id="2"/><d/></a>'
+ assert_equal 'b', doc.root.elements[1].name
+ assert_equal '1', doc.root.elements['c'].attributes['id']
+ assert_equal '2', doc.root.elements[2,'c'].attributes['id']
+ end
- def test_indexing
- doc = Document.new '<a/>'
- doc.root.elements[10] = Element.new('b')
- assert_equal 'b', doc.root.elements[1].name
- doc.root.elements[1] = Element.new('c')
- assert_equal 'c', doc.root.elements[1].name
- doc.root.elements['c'] = Element.new('d')
- assert_equal 'd', doc.root.elements[1].name
- end
+ def test_indexing
+ doc = Document.new '<a/>'
+ doc.root.elements[10] = Element.new('b')
+ assert_equal 'b', doc.root.elements[1].name
+ doc.root.elements[1] = Element.new('c')
+ assert_equal 'c', doc.root.elements[1].name
+ doc.root.elements['c'] = Element.new('d')
+ assert_equal 'd', doc.root.elements[1].name
+ end
- def test_delete
- doc = Document.new '<a><b/><c/><c id="1"/></a>'
- block = proc { |str|
- out = ''
- doc.write out
- assert_equal str, out
- }
- b = doc.root.elements[1]
- doc.root.elements.delete b
- block.call( "<a><c/><c id='1'/></a>" )
- doc.elements.delete("a/c[@id='1']")
- block.call( '<a><c/></a>' )
- doc.root.elements.delete 1
- block.call( '<a/>' )
- end
+ def test_delete
+ doc = Document.new '<a><b/><c/><c id="1"/></a>'
+ block = proc { |str|
+ out = ''
+ doc.write out
+ assert_equal str, out
+ }
+ b = doc.root.elements[1]
+ doc.root.elements.delete b
+ block.call( "<a><c/><c id='1'/></a>" )
+ doc.elements.delete("a/c[@id='1']")
+ block.call( '<a><c/></a>' )
+ doc.root.elements.delete 1
+ block.call( '<a/>' )
+ end
- def test_delete_all
- doc = Document.new '<a><c/><c/><c/><c/></a>'
- deleted = doc.elements.delete_all 'a/c'
- assert_equal 4, deleted.size
- end
+ def test_delete_all
+ doc = Document.new '<a><c/><c/><c/><c/></a>'
+ deleted = doc.elements.delete_all 'a/c'
+ assert_equal 4, deleted.size
+ end
- def test_ticket_36
- doc = Document.new( "<a xmlns:xi='foo'><b><xi:c id='1'/></b><xi:c id='2'/></a>" )
+ def test_ticket_36
+ doc = Document.new( "<a xmlns:xi='foo'><b><xi:c id='1'/></b><xi:c id='2'/></a>" )
- deleted = doc.root.elements.delete_all( "xi:c" )
- assert_equal( 1, deleted.size )
+ deleted = doc.root.elements.delete_all( "xi:c" )
+ assert_equal( 1, deleted.size )
- doc = Document.new( "<a xmlns:xi='foo'><b><xi:c id='1'/></b><xi:c id='2'/></a>" )
- deleted = doc.root.elements.delete_all( "//xi:c" )
- assert_equal( 2, deleted.size )
- end
+ doc = Document.new( "<a xmlns:xi='foo'><b><xi:c id='1'/></b><xi:c id='2'/></a>" )
+ deleted = doc.root.elements.delete_all( "//xi:c" )
+ assert_equal( 2, deleted.size )
+ end
- def test_add
- a = Element.new 'a'
- a.elements.add Element.new('b')
- assert_equal 'b', a.elements[1].name
- a.elements.add 'c'
- assert_equal 'c', a.elements[2].name
- end
+ def test_add
+ a = Element.new 'a'
+ a.elements.add Element.new('b')
+ assert_equal 'b', a.elements[1].name
+ a.elements.add 'c'
+ assert_equal 'c', a.elements[2].name
+ end
- def test_size
- doc = Document.new '<a>sean<b/>elliott<b/>russell<b/></a>'
- assert_equal 6, doc.root.size
- assert_equal 3, doc.root.elements.size
- end
+ def test_size
+ doc = Document.new '<a>sean<b/>elliott<b/>russell<b/></a>'
+ assert_equal 6, doc.root.size
+ assert_equal 3, doc.root.elements.size
+ end
- def test_each
- doc = Document.new '<a><b/><c/><d/>sean<b/><c/><d/></a>'
- count = 0
- block = proc {|e| count += 1}
- doc.root.elements.each(&block)
- assert_equal 6, count
- count = 0
- doc.root.elements.each('b', &block)
- assert_equal 2, count
- count = 0
- doc.root.elements.each('child::node()', &block)
- assert_equal 6, count
- count = 0
- XPath.each(doc.root, 'child::node()', &block)
- assert_equal 7, count
- end
+ def test_each
+ doc = Document.new '<a><b/><c/><d/>sean<b/><c/><d/></a>'
+ count = 0
+ block = proc {|e| count += 1}
+ doc.root.elements.each(&block)
+ assert_equal 6, count
+ count = 0
+ doc.root.elements.each('b', &block)
+ assert_equal 2, count
+ count = 0
+ doc.root.elements.each('child::node()', &block)
+ assert_equal 6, count
+ count = 0
+ XPath.each(doc.root, 'child::node()', &block)
+ assert_equal 7, count
+ end
- def test_each_with_frozen_condition
- doc = Document.new('<books><book name="Ruby"/><book name="XML"/></books>')
- names = []
- doc.root.elements.each('book'.freeze) do |element|
- names << element.attributes["name"]
+ def test_each_with_frozen_condition
+ doc = Document.new('<books><book name="Ruby"/><book name="XML"/></books>')
+ names = []
+ doc.root.elements.each('book'.freeze) do |element|
+ names << element.attributes["name"]
+ end
+ assert_equal(["Ruby", "XML"], names)
end
- assert_equal(["Ruby", "XML"], names)
- end
- def test_to_a
- doc = Document.new '<a>sean<b/>elliott<c/></a>'
- assert_equal 2, doc.root.elements.to_a.size
- assert_equal 2, doc.root.elements.to_a("child::node()").size
- assert_equal 4, XPath.match(doc.root, "child::node()").size
- end
+ def test_to_a
+ doc = Document.new '<a>sean<b/>elliott<c/></a>'
+ assert_equal 2, doc.root.elements.to_a.size
+ assert_equal 2, doc.root.elements.to_a("child::node()").size
+ assert_equal 4, XPath.match(doc.root, "child::node()").size
+ end
- def test_collect
- doc = Document.new( "<a><b id='1'/><b id='2'/></a>" )
- r = doc.elements.collect( "/a/b" ) { |e| e.attributes["id"].to_i }
- assert_equal( [1,2], r )
- end
+ def test_collect
+ doc = Document.new( "<a><b id='1'/><b id='2'/></a>" )
+ r = doc.elements.collect( "/a/b" ) { |e| e.attributes["id"].to_i }
+ assert_equal( [1,2], r )
+ end
- def test_inject
- doc = Document.new( "<a><b id='1'/><b id='2'/></a>" )
- r = doc.elements.inject( "/a/b", 3 ) { |s, e|
- s + e.attributes["id"].to_i
- }
- assert_equal 6, r
+ def test_inject
+ doc = Document.new( "<a><b id='1'/><b id='2'/></a>" )
+ r = doc.elements.inject( "/a/b", 3 ) { |s, e|
+ s + e.attributes["id"].to_i
+ }
+ assert_equal 6, r
+ end
end
end
-end
diff --git a/test/rexml/test_encoding.rb b/test/rexml/test_encoding.rb
index a084067..8205d0f 100644
--- a/test/rexml/test_encoding.rb
+++ b/test/rexml/test_encoding.rb
@@ -6,91 +6,91 @@ require 'rexml/source'
require 'rexml/document'
module REXMLTests
-class EncodingTester < Test::Unit::TestCase
- include REXMLTestUtils
- include REXML
+ class EncodingTester < Test::Unit::TestCase
+ include REXMLTestUtils
+ include REXML
- def setup
- @encoded_root = "<a><b>\346</b></a>"
- @encoded = "<?xml version='1.0' encoding='ISO-8859-3'?>"+
- @encoded_root
- @not_encoded = "<a><b>ĉ</b></a>"
- end
+ def setup
+ @encoded_root = "<a><b>\346</b></a>"
+ @encoded = "<?xml version='1.0' encoding='ISO-8859-3'?>"+
+ @encoded_root
+ @not_encoded = "<a><b>ĉ</b></a>"
+ end
- # Given an encoded document, try to write out to that encoding
- def test_encoded_in_encoded_out
- doc = Document.new( @encoded )
- doc.write( out="" )
- out.force_encoding(::Encoding::ASCII_8BIT)
- assert_equal( @encoded, out )
- end
+ # Given an encoded document, try to write out to that encoding
+ def test_encoded_in_encoded_out
+ doc = Document.new( @encoded )
+ doc.write( out="" )
+ out.force_encoding(::Encoding::ASCII_8BIT)
+ assert_equal( @encoded, out )
+ end
- # Given an encoded document, try to change the encoding and write it out
- def test_encoded_in_change_out
- doc = Document.new( @encoded )
- doc.xml_decl.encoding = "UTF-8"
- assert_equal("UTF-8", doc.encoding)
- REXML::Formatters::Default.new.write( doc.root, out="" )
- out.force_encoding(::Encoding::ASCII_8BIT)
- assert_equal( @not_encoded, out )
- char = XPath.first( doc, "/a/b/text()" ).to_s
- char.force_encoding(::Encoding::ASCII_8BIT)
- assert_equal( "ĉ", char )
- end
+ # Given an encoded document, try to change the encoding and write it out
+ def test_encoded_in_change_out
+ doc = Document.new( @encoded )
+ doc.xml_decl.encoding = "UTF-8"
+ assert_equal("UTF-8", doc.encoding)
+ REXML::Formatters::Default.new.write( doc.root, out="" )
+ out.force_encoding(::Encoding::ASCII_8BIT)
+ assert_equal( @not_encoded, out )
+ char = XPath.first( doc, "/a/b/text()" ).to_s
+ char.force_encoding(::Encoding::ASCII_8BIT)
+ assert_equal( "ĉ", char )
+ end
- # * Given an encoded document, try to write it to a different encoding
- def test_encoded_in_different_out
- doc = Document.new( @encoded )
- REXML::Formatters::Default.new.write( doc.root, Output.new( out="", "UTF-8" ) )
- out.force_encoding(::Encoding::ASCII_8BIT)
- assert_equal( @not_encoded, out )
- end
+ # * Given an encoded document, try to write it to a different encoding
+ def test_encoded_in_different_out
+ doc = Document.new( @encoded )
+ REXML::Formatters::Default.new.write( doc.root, Output.new( out="", "UTF-8" ) )
+ out.force_encoding(::Encoding::ASCII_8BIT)
+ assert_equal( @not_encoded, out )
+ end
- # * Given a non-encoded document, change the encoding
- def test_in_change_out
- doc = Document.new( @not_encoded )
- doc.xml_decl.encoding = "ISO-8859-3"
- assert_equal("ISO-8859-3", doc.encoding)
- doc.write( out="" )
- out.force_encoding(::Encoding::ASCII_8BIT)
- assert_equal( @encoded, out )
- end
+ # * Given a non-encoded document, change the encoding
+ def test_in_change_out
+ doc = Document.new( @not_encoded )
+ doc.xml_decl.encoding = "ISO-8859-3"
+ assert_equal("ISO-8859-3", doc.encoding)
+ doc.write( out="" )
+ out.force_encoding(::Encoding::ASCII_8BIT)
+ assert_equal( @encoded, out )
+ end
- # * Given a non-encoded document, write to a different encoding
- def test_in_different_out
- doc = Document.new( @not_encoded )
- doc.write( Output.new( out="", "ISO-8859-3" ) )
- out.force_encoding(::Encoding::ASCII_8BIT)
- assert_equal( "<?xml version='1.0'?>#{@encoded_root}", out )
- end
+ # * Given a non-encoded document, write to a different encoding
+ def test_in_different_out
+ doc = Document.new( @not_encoded )
+ doc.write( Output.new( out="", "ISO-8859-3" ) )
+ out.force_encoding(::Encoding::ASCII_8BIT)
+ assert_equal( "<?xml version='1.0'?>#{@encoded_root}", out )
+ end
- # * Given an encoded document, accessing text and attribute nodes
- # should provide UTF-8 text.
- def test_in_different_access
- doc = Document.new <<-EOL
- <?xml version='1.0' encoding='ISO-8859-1'?>
- <a a="\xFF">\xFF</a>
- EOL
- expect = "\303\277"
- expect.force_encoding(::Encoding::UTF_8)
- assert_equal( expect, doc.elements['a'].attributes['a'] )
- assert_equal( expect, doc.elements['a'].text )
- end
+ # * Given an encoded document, accessing text and attribute nodes
+ # should provide UTF-8 text.
+ def test_in_different_access
+ doc = Document.new <<-EOL
+ <?xml version='1.0' encoding='ISO-8859-1'?>
+ <a a="\xFF">\xFF</a>
+ EOL
+ expect = "\303\277"
+ expect.force_encoding(::Encoding::UTF_8)
+ assert_equal( expect, doc.elements['a'].attributes['a'] )
+ assert_equal( expect, doc.elements['a'].text )
+ end
- def test_ticket_89
- doc = Document.new <<-EOL
- <?xml version="1.0" encoding="CP-1252" ?>
- <xml><foo></foo></xml>
- EOL
+ def test_ticket_89
+ doc = Document.new <<-EOL
+ <?xml version="1.0" encoding="CP-1252" ?>
+ <xml><foo></foo></xml>
+ EOL
- REXML::Document.new doc
- end
+ REXML::Document.new doc
+ end
- def test_ticket_110
- utf16 = REXML::Document.new(File.new(fixture_path("ticket_110_utf16.xml")))
- assert_equal(utf16.encoding, "UTF-16")
- assert( utf16[0].kind_of?(REXML::XMLDecl))
+ def test_ticket_110
+ utf16 = REXML::Document.new(File.new(fixture_path("ticket_110_utf16.xml")))
+ assert_equal(utf16.encoding, "UTF-16")
+ assert( utf16[0].kind_of?(REXML::XMLDecl))
+ end
end
end
-end
diff --git a/test/rexml/test_entity.rb b/test/rexml/test_entity.rb
index 0027223..820e4f2 100644
--- a/test/rexml/test_entity.rb
+++ b/test/rexml/test_entity.rb
@@ -5,185 +5,185 @@ require 'rexml/entity'
require 'rexml/source'
module REXMLTests
-class EntityTester < Test::Unit::TestCase
- def test_parse_general_decl
- simple = "<!ENTITY foo 'bar'>"
- simple =~ /#{REXML::Entity::GEDECL}/
- assert $&
- assert_equal simple, $&
-
- REXML::Entity::ENTITYDECL =~ simple
- assert REXML::Entity::matches?(simple)
- match = REXML::Entity::ENTITYDECL.match(simple)
- assert_equal 'foo', match[1]
- assert_equal "'bar'", match[2]
-
- simple = '<!ENTITY Pub-Status
- "This is a pre-release of the specification.">'
- assert REXML::Entity::matches?(simple)
- match = REXML::Entity::ENTITYDECL.match(simple)
- assert_equal 'Pub-Status', match[1]
- assert_equal '"This is a pre-release of the specification."', match[2]
-
- txt = '"This is a
- pre-release of <the> specification."'
- simple = "<!ENTITY Pub-Status
- #{txt}>"
- assert REXML::Entity::matches?(simple)
- match = REXML::Entity::ENTITYDECL.match(simple)
- assert_equal 'Pub-Status', match[1]
- assert_equal txt, match[2]
- end
+ class EntityTester < Test::Unit::TestCase
+ def test_parse_general_decl
+ simple = "<!ENTITY foo 'bar'>"
+ simple =~ /#{REXML::Entity::GEDECL}/
+ assert $&
+ assert_equal simple, $&
+
+ REXML::Entity::ENTITYDECL =~ simple
+ assert REXML::Entity::matches?(simple)
+ match = REXML::Entity::ENTITYDECL.match(simple)
+ assert_equal 'foo', match[1]
+ assert_equal "'bar'", match[2]
+
+ simple = '<!ENTITY Pub-Status
+ "This is a pre-release of the specification.">'
+ assert REXML::Entity::matches?(simple)
+ match = REXML::Entity::ENTITYDECL.match(simple)
+ assert_equal 'Pub-Status', match[1]
+ assert_equal '"This is a pre-release of the specification."', match[2]
+
+ txt = '"This is a
+ pre-release of <the> specification."'
+ simple = "<!ENTITY Pub-Status
+ #{txt}>"
+ assert REXML::Entity::matches?(simple)
+ match = REXML::Entity::ENTITYDECL.match(simple)
+ assert_equal 'Pub-Status', match[1]
+ assert_equal txt, match[2]
+ end
- def test_parse_external_decl
- zero = '<!ENTITY open-hatch SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml" >'
- one = '<!ENTITY open-hatch
- SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">'
- two = '<!ENTITY open-hatch
- PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN"
- "http://www.textuality.com/boilerplate/OpenHatch.xml">'
- three = '<!ENTITY hatch-pic
- SYSTEM "../grafix/OpenHatch.gif"
- NDATA gif >'
- assert REXML::Entity::matches?(zero)
- assert REXML::Entity::matches?(one)
- assert REXML::Entity::matches?(two)
- assert REXML::Entity::matches?(three)
- end
+ def test_parse_external_decl
+ zero = '<!ENTITY open-hatch SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml" >'
+ one = '<!ENTITY open-hatch
+ SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">'
+ two = '<!ENTITY open-hatch
+ PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN"
+ "http://www.textuality.com/boilerplate/OpenHatch.xml">'
+ three = '<!ENTITY hatch-pic
+ SYSTEM "../grafix/OpenHatch.gif"
+ NDATA gif >'
+ assert REXML::Entity::matches?(zero)
+ assert REXML::Entity::matches?(one)
+ assert REXML::Entity::matches?(two)
+ assert REXML::Entity::matches?(three)
+ end
- def test_parse_entity
- one = %q{<!ENTITY % YN '"Yes"'>}
- two = %q{<!ENTITY WhatHeSaid "He said %YN;">}
- assert REXML::Entity::matches?(one)
- assert REXML::Entity::matches?(two)
- end
+ def test_parse_entity
+ one = %q{<!ENTITY % YN '"Yes"'>}
+ two = %q{<!ENTITY WhatHeSaid "He said %YN;">}
+ assert REXML::Entity::matches?(one)
+ assert REXML::Entity::matches?(two)
+ end
- def test_constructor
- one = [ %q{<!ENTITY % YN '"Yes"'>},
- %q{<!ENTITY % YN2 "Yes">},
- %q{<!ENTITY WhatHeSaid "He said %YN;">},
- '<!ENTITY open-hatch
- SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">',
- '<!ENTITY open-hatch2
- PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN"
- "http://www.textuality.com/boilerplate/OpenHatch.xml">',
- '<!ENTITY hatch-pic
- SYSTEM "../grafix/OpenHatch.gif"
- NDATA gif>' ]
- source = %q{<!DOCTYPE foo [
- <!ENTITY % YN '"Yes"'>
- <!ENTITY % YN2 "Yes">
- <!ENTITY WhatHeSaid "He said %YN;">
- <!ENTITY open-hatch
- SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">
- <!ENTITY open-hatch2
- PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN"
- "http://www.textuality.com/boilerplate/OpenHatch.xml">
- <!ENTITY hatch-pic
- SYSTEM "../grafix/OpenHatch.gif"
- NDATA gif>
- ]>}
-
- d = REXML::Document.new( source )
- dt = d.doctype
- c = 0
- dt.each do |child|
- if child.kind_of? REXML::Entity
- str = one[c].tr("\r\n\t", ' ').squeeze(" ")
- assert_equal str, child.to_s
- c+=1
+ def test_constructor
+ one = [ %q{<!ENTITY % YN '"Yes"'>},
+ %q{<!ENTITY % YN2 "Yes">},
+ %q{<!ENTITY WhatHeSaid "He said %YN;">},
+ '<!ENTITY open-hatch
+ SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">',
+ '<!ENTITY open-hatch2
+ PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN"
+ "http://www.textuality.com/boilerplate/OpenHatch.xml">',
+ '<!ENTITY hatch-pic
+ SYSTEM "../grafix/OpenHatch.gif"
+ NDATA gif>' ]
+ source = %q{<!DOCTYPE foo [
+ <!ENTITY % YN '"Yes"'>
+ <!ENTITY % YN2 "Yes">
+ <!ENTITY WhatHeSaid "He said %YN;">
+ <!ENTITY open-hatch
+ SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml">
+ <!ENTITY open-hatch2
+ PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN"
+ "http://www.textuality.com/boilerplate/OpenHatch.xml">
+ <!ENTITY hatch-pic
+ SYSTEM "../grafix/OpenHatch.gif"
+ NDATA gif>
+ ]>}
+
+ d = REXML::Document.new( source )
+ dt = d.doctype
+ c = 0
+ dt.each do |child|
+ if child.kind_of? REXML::Entity
+ str = one[c].tr("\r\n\t", ' ').squeeze(" ")
+ assert_equal str, child.to_s
+ c+=1
+ end
end
end
- end
- def test_replace_entities
- source = "<!DOCTYPE blah [\n<!ENTITY foo \"bar\">\n]><a>&foo;</a>"
- doc = REXML::Document.new(source)
- assert_equal 'bar', doc.root.text
- out = ''
- doc.write out
- assert_equal source, out
- end
+ def test_replace_entities
+ source = "<!DOCTYPE blah [\n<!ENTITY foo \"bar\">\n]><a>&foo;</a>"
+ doc = REXML::Document.new(source)
+ assert_equal 'bar', doc.root.text
+ out = ''
+ doc.write out
+ assert_equal source, out
+ end
- def test_entity_string_limit
- template = '<!DOCTYPE bomb [ <!ENTITY a "^" > ]> <bomb>$</bomb>'
- len = 5120 # 5k per entity
- template.sub!(/\^/, "B" * len)
-
- # 10k is OK
- entities = '&a;' * 2 # 5k entity * 2 = 10k
- xmldoc = REXML::Document.new(template.sub(/\$/, entities))
- assert_equal(len * 2, xmldoc.root.text.bytesize)
-
- # above 10k explodes
- entities = '&a;' * 3 # 5k entity * 2 = 15k
- xmldoc = REXML::Document.new(template.sub(/\$/, entities))
- assert_raises(RuntimeError) do
- xmldoc.root.text
+ def test_entity_string_limit
+ template = '<!DOCTYPE bomb [ <!ENTITY a "^" > ]> <bomb>$</bomb>'
+ len = 5120 # 5k per entity
+ template.sub!(/\^/, "B" * len)
+
+ # 10k is OK
+ entities = '&a;' * 2 # 5k entity * 2 = 10k
+ xmldoc = REXML::Document.new(template.sub(/\$/, entities))
+ assert_equal(len * 2, xmldoc.root.text.bytesize)
+
+ # above 10k explodes
+ entities = '&a;' * 3 # 5k entity * 2 = 15k
+ xmldoc = REXML::Document.new(template.sub(/\$/, entities))
+ assert_raises(RuntimeError) do
+ xmldoc.root.text
+ end
end
- end
- def test_raw
- source = '<!DOCTYPE foo [
+ def test_raw
+ source = '<!DOCTYPE foo [
<!ENTITY ent "replace">
]><a>replace &ent;</a>'
- doc = REXML::Document.new( source, {:raw=>:all})
- assert_equal('replace &ent;', doc.root.get_text.to_s)
- assert_equal(source, doc.to_s)
- end
+ doc = REXML::Document.new( source, {:raw=>:all})
+ assert_equal('replace &ent;', doc.root.get_text.to_s)
+ assert_equal(source, doc.to_s)
+ end
- def test_lazy_evaluation
- source = '<!DOCTYPE foo [
+ def test_lazy_evaluation
+ source = '<!DOCTYPE foo [
<!ENTITY ent "replace">
]><a>replace &ent;</a>'
- doc = REXML::Document.new( source )
- assert_equal(source, doc.to_s)
- assert_equal("replace replace", doc.root.text)
- assert_equal(source, doc.to_s)
- end
+ doc = REXML::Document.new( source )
+ assert_equal(source, doc.to_s)
+ assert_equal("replace replace", doc.root.text)
+ assert_equal(source, doc.to_s)
+ end
- # Contributed (not only test, but bug fix!!) by Kouhei Sutou
- def test_entity_replacement
- source = %q{<!DOCTYPE foo [
- <!ENTITY % YN '"Yes"'>
- <!ENTITY WhatHeSaid "He said %YN;">]>
- <a>&WhatHeSaid;</a>}
-
- d = REXML::Document.new( source )
- dt = d.doctype
- assert_equal( '"Yes"', dt.entities[ "YN" ].value )
- assert_equal( 'He said "Yes"', dt.entities[ "WhatHeSaid" ].value )
- assert_equal( 'He said "Yes"', d.elements[1].text )
- end
+ # Contributed (not only test, but bug fix!!) by Kouhei Sutou
+ def test_entity_replacement
+ source = %q{<!DOCTYPE foo [
+ <!ENTITY % YN '"Yes"'>
+ <!ENTITY WhatHeSaid "He said %YN;">]>
+ <a>&WhatHeSaid;</a>}
+
+ d = REXML::Document.new( source )
+ dt = d.doctype
+ assert_equal( '"Yes"', dt.entities[ "YN" ].value )
+ assert_equal( 'He said "Yes"', dt.entities[ "WhatHeSaid" ].value )
+ assert_equal( 'He said "Yes"', d.elements[1].text )
+ end
- # More unit tests from Kouhei. I looove users who give me unit tests.
- def test_entity_insertions
- assert_equal("&amp;", REXML::Text.new("&amp;", false, nil, true).to_s)
- #assert_equal("&", REXML::Text.new("&amp;", false, false).to_s)
- end
+ # More unit tests from Kouhei. I looove users who give me unit tests.
+ def test_entity_insertions
+ assert_equal("&amp;", REXML::Text.new("&amp;", false, nil, true).to_s)
+ #assert_equal("&", REXML::Text.new("&amp;", false, false).to_s)
+ end
- def test_single_pass_unnormalization # ticket 123
- assert_equal '&amp;&', REXML::Text::unnormalize('&#38;amp;&amp;')
- end
+ def test_single_pass_unnormalization # ticket 123
+ assert_equal '&amp;&', REXML::Text::unnormalize('&#38;amp;&amp;')
+ end
- def test_entity_filter
- document = REXML::Document.new(<<-XML)
+ def test_entity_filter
+ document = REXML::Document.new(<<-XML)
<!DOCTYPE root [
<!ENTITY copy "(c)">
<!ENTITY release-year "2013">
]>
<root/>
XML
- respect_whitespace = false
- parent = document.root
- raw = false
- entity_filter = ["copy"]
- assert_equal("(c) &release-year;",
- REXML::Text.new("(c) 2013",
- respect_whitespace,
- parent,
- raw,
- entity_filter).to_s)
+ respect_whitespace = false
+ parent = document.root
+ raw = false
+ entity_filter = ["copy"]
+ assert_equal("(c) &release-year;",
+ REXML::Text.new("(c) 2013",
+ respect_whitespace,
+ parent,
+ raw,
+ entity_filter).to_s)
+ end
end
end
-end
diff --git a/test/rexml/test_functions.rb b/test/rexml/test_functions.rb
index da9a986..bf501ff 100644
--- a/test/rexml/test_functions.rb
+++ b/test/rexml/test_functions.rb
@@ -3,222 +3,222 @@ require "test/unit/testcase"
require "rexml/document"
module REXMLTests
-class FunctionsTester < Test::Unit::TestCase
- include REXML
- def test_functions
- # trivial text() test
- # confuse-a-function
- source = "<a>more <b id='1'/><b id='2'>dumb</b><b id='3'/><c/> text</a>"
- doc = Document.new source
- res = ""
- XPath::each(doc.root, "text()") {|val| res << val.to_s}
- assert_equal "more text", res
-
- res = XPath::first(doc.root, "b[last()]")
- assert_equal '3', res.attributes['id']
- res = XPath::first(doc.root, "b[position()=2]")
- assert_equal '2', res.attributes['id']
- res = XPath::first(doc.root, "*[name()='c']")
- assert_equal "c", res.name
- end
+ class FunctionsTester < Test::Unit::TestCase
+ include REXML
+ def test_functions
+ # trivial text() test
+ # confuse-a-function
+ source = "<a>more <b id='1'/><b id='2'>dumb</b><b id='3'/><c/> text</a>"
+ doc = Document.new source
+ res = ""
+ XPath::each(doc.root, "text()") {|val| res << val.to_s}
+ assert_equal "more text", res
+
+ res = XPath::first(doc.root, "b[last()]")
+ assert_equal '3', res.attributes['id']
+ res = XPath::first(doc.root, "b[position()=2]")
+ assert_equal '2', res.attributes['id']
+ res = XPath::first(doc.root, "*[name()='c']")
+ assert_equal "c", res.name
+ end
- # Contributed by Mike Stok
- def test_starts_with
- source = <<-EOF
- <foo>
- <a href="mailto:a@b.c">a@b.c</a>
- <a href="http://www.foo.com">http://www.foo.com</a>
- </foo>
- EOF
- doc = Document.new source
- mailtos = doc.elements.to_a("//a[starts-with(@href, 'mailto:')]")
- assert_equal 1, mailtos.size
- assert_equal "mailto:a@b.c", mailtos[0].attributes['href']
-
- ailtos = doc.elements.to_a("//a[starts-with(@href, 'ailto:')]")
- assert_equal 0, ailtos.size
- end
+ # Contributed by Mike Stok
+ def test_starts_with
+ source = <<-EOF
+ <foo>
+ <a href="mailto:a@b.c">a@b.c</a>
+ <a href="http://www.foo.com">http://www.foo.com</a>
+ </foo>
+ EOF
+ doc = Document.new source
+ mailtos = doc.elements.to_a("//a[starts-with(@href, 'mailto:')]")
+ assert_equal 1, mailtos.size
+ assert_equal "mailto:a@b.c", mailtos[0].attributes['href']
+
+ ailtos = doc.elements.to_a("//a[starts-with(@href, 'ailto:')]")
+ assert_equal 0, ailtos.size
+ end
- def test_string_length
- doc = Document.new <<-EOF
- <AAA>
- <Q/>
- <SSSS/>
- <BB/>
- <CCC/>
- <DDDDDDDD/>
- <EEEE/>
- </AAA>
- EOF
- assert doc, "create doc"
-
- set = doc.elements.to_a("//*[string-length(name()) = 3]")
- assert_equal 2, set.size, "nodes with names length = 3"
-
- set = doc.elements.to_a("//*[string-length(name()) < 3]")
- assert_equal 2, set.size, "nodes with names length < 3"
-
- set = doc.elements.to_a("//*[string-length(name()) > 3]")
- assert_equal 3, set.size, "nodes with names length > 3"
- end
+ def test_string_length
+ doc = Document.new <<-EOF
+ <AAA>
+ <Q/>
+ <SSSS/>
+ <BB/>
+ <CCC/>
+ <DDDDDDDD/>
+ <EEEE/>
+ </AAA>
+ EOF
+ assert doc, "create doc"
+
+ set = doc.elements.to_a("//*[string-length(name()) = 3]")
+ assert_equal 2, set.size, "nodes with names length = 3"
+
+ set = doc.elements.to_a("//*[string-length(name()) < 3]")
+ assert_equal 2, set.size, "nodes with names length < 3"
+
+ set = doc.elements.to_a("//*[string-length(name()) > 3]")
+ assert_equal 3, set.size, "nodes with names length > 3"
+ end
- # Test provided by Mike Stok
- def test_contains
- source = <<-EOF
- <foo>
- <a href="mailto:a@b.c">a@b.c</a>
- <a href="http://www.foo.com">http://www.foo.com</a>
- </foo>
- EOF
- doc = Document.new source
-
- [['o', 2], ['foo', 1], ['bar', 0]].each { |test|
- search, expected = test
- set = doc.elements.to_a("//a[contains(@href, '#{search}')]")
- assert_equal expected, set.size
- }
- end
+ # Test provided by Mike Stok
+ def test_contains
+ source = <<-EOF
+ <foo>
+ <a href="mailto:a@b.c">a@b.c</a>
+ <a href="http://www.foo.com">http://www.foo.com</a>
+ </foo>
+ EOF
+ doc = Document.new source
+
+ [['o', 2], ['foo', 1], ['bar', 0]].each { |test|
+ search, expected = test
+ set = doc.elements.to_a("//a[contains(@href, '#{search}')]")
+ assert_equal expected, set.size
+ }
+ end
- # Mike Stok and Sean Russell
- def test_substring
- # examples from http://www.w3.org/TR/xpath#function-substring
- doc = Document.new('<test string="12345" />')
-
- #puts XPath.first(d, 'node()[0 + 1]')
- #d = Document.new("<a b='1'/>")
- #puts XPath.first(d, 'a[0 mod 0]')
- [ [1.5, 2.6, '234'],
- [0, 3, '12'],
- [0, '0 div 0', ''],
- [1, '0 div 0', ''],
- ['-42', '1 div 0', '12345'],
- ['-1 div 0', '1 div 0', '']
- ].each { |start, length, expected|
- set = doc.elements.to_a("//test[substring(@string, #{start}, #{length}) = '#{expected}']")
- assert_equal 1, set.size, "#{start}, #{length}, '#{expected}'"
- }
- end
+ # Mike Stok and Sean Russell
+ def test_substring
+ # examples from http://www.w3.org/TR/xpath#function-substring
+ doc = Document.new('<test string="12345" />')
+
+ #puts XPath.first(d, 'node()[0 + 1]')
+ #d = Document.new("<a b='1'/>")
+ #puts XPath.first(d, 'a[0 mod 0]')
+ [ [1.5, 2.6, '234'],
+ [0, 3, '12'],
+ [0, '0 div 0', ''],
+ [1, '0 div 0', ''],
+ ['-42', '1 div 0', '12345'],
+ ['-1 div 0', '1 div 0', '']
+ ].each { |start, length, expected|
+ set = doc.elements.to_a("//test[substring(@string, #{start}, #{length}) = '#{expected}']")
+ assert_equal 1, set.size, "#{start}, #{length}, '#{expected}'"
+ }
+ end
- def test_substring_angrez
- testString = REXML::Functions::substring_after("helloworld","hello")
- assert_equal( 'world', testString )
- end
+ def test_substring_angrez
+ testString = REXML::Functions::substring_after("helloworld","hello")
+ assert_equal( 'world', testString )
+ end
- def test_translate
- source = <<-EOF
- <doc>
- <case name='w3c one' result='BAr' /> <!-- w3c -->
- <case name='w3c two' result='AAA' /> <!-- w3c -->
- <case name='alchemy' result="gold" /> <!-- mike -->
- <case name='vbxml one' result='A Space Odyssey' />
- <case name='vbxml two' result='AbCdEf' />
- </doc>
- EOF
-
- doc = Document.new(source)
-
- [ ['bar', 'abc', 'ABC', 'w3c one'],
- ['--aaa--','abc-','ABC', 'w3c two'],
- ['lead', 'dear language', 'doll groover', 'alchemy'],
- ['A Space Odissei', 'i', 'y', 'vbxml one'],
- ['abcdefg', 'aceg', 'ACE', 'vbxml two'],
- ].each { |arg1, arg2, arg3, name|
- translate = "translate('#{arg1}', '#{arg2}', '#{arg3}')"
- set = doc.elements.to_a("//case[@result = #{translate}]")
- assert_equal 1, set.size, translate
- assert_equal name, set[0].attributes['name']
- }
- end
+ def test_translate
+ source = <<-EOF
+ <doc>
+ <case name='w3c one' result='BAr' /> <!-- w3c -->
+ <case name='w3c two' result='AAA' /> <!-- w3c -->
+ <case name='alchemy' result="gold" /> <!-- mike -->
+ <case name='vbxml one' result='A Space Odyssey' />
+ <case name='vbxml two' result='AbCdEf' />
+ </doc>
+ EOF
+
+ doc = Document.new(source)
+
+ [ ['bar', 'abc', 'ABC', 'w3c one'],
+ ['--aaa--','abc-','ABC', 'w3c two'],
+ ['lead', 'dear language', 'doll groover', 'alchemy'],
+ ['A Space Odissei', 'i', 'y', 'vbxml one'],
+ ['abcdefg', 'aceg', 'ACE', 'vbxml two'],
+ ].each { |arg1, arg2, arg3, name|
+ translate = "translate('#{arg1}', '#{arg2}', '#{arg3}')"
+ set = doc.elements.to_a("//case[@result = #{translate}]")
+ assert_equal 1, set.size, translate
+ assert_equal name, set[0].attributes['name']
+ }
+ end
- def test_name
- d = REXML::Document.new("<a xmlns:x='foo'><b/><x:b/></a>")
- assert_equal 1, d.root.elements.to_a('*[name() = "b"]').size
- assert_equal 1, d.elements.to_a('//*[name() = "x:b"]').size
- end
+ def test_name
+ d = REXML::Document.new("<a xmlns:x='foo'><b/><x:b/></a>")
+ assert_equal 1, d.root.elements.to_a('*[name() = "b"]').size
+ assert_equal 1, d.elements.to_a('//*[name() = "x:b"]').size
+ end
- def test_local_name
- d = REXML::Document.new("<a xmlns:x='foo'><b/><x:b/></a>")
- assert_equal 2, d.root.elements.to_a('*[local_name() = "b"]').size
- assert_equal 2, d.elements.to_a('//*[local_name() = "b"]').size
- end
+ def test_local_name
+ d = REXML::Document.new("<a xmlns:x='foo'><b/><x:b/></a>")
+ assert_equal 2, d.root.elements.to_a('*[local_name() = "b"]').size
+ assert_equal 2, d.elements.to_a('//*[local_name() = "b"]').size
+ end
- def test_substring2
- doc = Document.new('<test string="12345" />')
- assert_equal(1,doc.elements.to_a("//test[substring(@string,2)='2345']").size)
- end
+ def test_substring2
+ doc = Document.new('<test string="12345" />')
+ assert_equal(1,doc.elements.to_a("//test[substring(@string,2)='2345']").size)
+ end
- # Submitted by Kouhei
- def test_floor_ceiling_round
- source = "<a><b id='1'/><b id='2'/><b id='3'/></a>"
- doc = REXML::Document.new(source)
-
- id_1 = doc.elements["/a/b[@id='1']"]
- id_2 = doc.elements["/a/b[@id='2']"]
- id_3 = doc.elements["/a/b[@id='3']"]
-
- good = {
- "floor" => [[], [id_1], [id_2], [id_3]],
- "ceiling" => [[id_1], [id_2], [id_3], []],
- "round" => [[id_1], [id_2], [id_3], []]
- }
- good.each do |key, value|
- (0..3).each do |i|
- xpath = "//b[number(@id) = #{key}(#{i+0.5})]"
- assert_equal(value[i], REXML::XPath.match(doc, xpath))
+ # Submitted by Kouhei
+ def test_floor_ceiling_round
+ source = "<a><b id='1'/><b id='2'/><b id='3'/></a>"
+ doc = REXML::Document.new(source)
+
+ id_1 = doc.elements["/a/b[@id='1']"]
+ id_2 = doc.elements["/a/b[@id='2']"]
+ id_3 = doc.elements["/a/b[@id='3']"]
+
+ good = {
+ "floor" => [[], [id_1], [id_2], [id_3]],
+ "ceiling" => [[id_1], [id_2], [id_3], []],
+ "round" => [[id_1], [id_2], [id_3], []]
+ }
+ good.each do |key, value|
+ (0..3).each do |i|
+ xpath = "//b[number(@id) = #{key}(#{i+0.5})]"
+ assert_equal(value[i], REXML::XPath.match(doc, xpath))
+ end
end
- end
- good["round"] = [[], [id_1], [id_2], [id_3]]
- good.each do |key, value|
- (0..3).each do |i|
- xpath = "//b[number(@id) = #{key}(#{i+0.4})]"
- assert_equal(value[i], REXML::XPath.match(doc, xpath))
+ good["round"] = [[], [id_1], [id_2], [id_3]]
+ good.each do |key, value|
+ (0..3).each do |i|
+ xpath = "//b[number(@id) = #{key}(#{i+0.4})]"
+ assert_equal(value[i], REXML::XPath.match(doc, xpath))
+ end
end
end
- end
- # Submitted by Kou
- def test_lang
- d = Document.new(<<-XML)
- <a xml:lang="en">
- <b xml:lang="ja">
- <c xml:lang="fr"/>
- <d/>
- <e xml:lang="ja-JP"/>
- <f xml:lang="en-US"/>
- </b>
- </a>
- XML
-
- assert_equal(1, d.elements.to_a("//*[lang('fr')]").size)
- assert_equal(3, d.elements.to_a("//*[lang('ja')]").size)
- assert_equal(2, d.elements.to_a("//*[lang('en')]").size)
- assert_equal(1, d.elements.to_a("//*[lang('en-us')]").size)
-
- d = Document.new(<<-XML)
- <root>
- <para xml:lang="en"/>
- <div xml:lang="en"><para/></div>
- <para xml:lang="EN"/>
- <para xml:lang="en-us"/>
- </root>
- XML
-
- assert_equal(5, d.elements.to_a("//*[lang('en')]").size)
- end
+ # Submitted by Kou
+ def test_lang
+ d = Document.new(<<-XML)
+ <a xml:lang="en">
+ <b xml:lang="ja">
+ <c xml:lang="fr"/>
+ <d/>
+ <e xml:lang="ja-JP"/>
+ <f xml:lang="en-US"/>
+ </b>
+ </a>
+ XML
+
+ assert_equal(1, d.elements.to_a("//*[lang('fr')]").size)
+ assert_equal(3, d.elements.to_a("//*[lang('ja')]").size)
+ assert_equal(2, d.elements.to_a("//*[lang('en')]").size)
+ assert_equal(1, d.elements.to_a("//*[lang('en-us')]").size)
+
+ d = Document.new(<<-XML)
+ <root>
+ <para xml:lang="en"/>
+ <div xml:lang="en"><para/></div>
+ <para xml:lang="EN"/>
+ <para xml:lang="en-us"/>
+ </root>
+ XML
+
+ assert_equal(5, d.elements.to_a("//*[lang('en')]").size)
+ end
- def test_ticket_60
- document = REXML::Document.new("<a><b>A</b><b>1</b></a>")
- assert_equal( "A", REXML::XPath.first(document, '//b[.="A"]').text )
- assert_equal( "1", REXML::XPath.first(document, '//b[.="1"]').text )
- end
+ def test_ticket_60
+ document = REXML::Document.new("<a><b>A</b><b>1</b></a>")
+ assert_equal( "A", REXML::XPath.first(document, '//b[.="A"]').text )
+ assert_equal( "1", REXML::XPath.first(document, '//b[.="1"]').text )
+ end
- def test_normalize_space
- source = "<a><!--COMMENT A--><b><!-- COMMENT A --></b></a>"
- doc = REXML::Document.new(source)
- predicate = "string(.)=normalize_space('\nCOMMENT \n A \n\n ')"
- m = REXML::XPath.match(doc, "//comment()[#{predicate}]")
- assert_equal( [REXML::Comment.new("COMMENT A")], m )
+ def test_normalize_space
+ source = "<a><!--COMMENT A--><b><!-- COMMENT A --></b></a>"
+ doc = REXML::Document.new(source)
+ predicate = "string(.)=normalize_space('\nCOMMENT \n A \n\n ')"
+ m = REXML::XPath.match(doc, "//comment()[#{predicate}]")
+ assert_equal( [REXML::Comment.new("COMMENT A")], m )
+ end
end
end
-end
diff --git a/test/rexml/test_functions_number.rb b/test/rexml/test_functions_number.rb
index c2124a5..0b5ec92 100644
--- a/test/rexml/test_functions_number.rb
+++ b/test/rexml/test_functions_number.rb
@@ -3,32 +3,32 @@ require 'test/unit'
require 'rexml/functions'
module REXMLTests
-class TC_Rexml_Functions_Number < Test::Unit::TestCase
+ class TC_Rexml_Functions_Number < Test::Unit::TestCase
- def test_functions_number_int
- telem = REXML::Element.new("elem")
- telem.text="9"
- assert_equal(9, REXML::Functions::number(telem))
+ def test_functions_number_int
+ telem = REXML::Element.new("elem")
+ telem.text="9"
+ assert_equal(9, REXML::Functions::number(telem))
+ end
+ def test_functions_number_float
+ telem = REXML::Element.new("elem")
+ telem.text="10.4"
+ assert_equal(10.4, REXML::Functions::number(telem))
+ end
+ def test_functions_number_negative_int
+ telem = REXML::Element.new("elem")
+ telem.text="-9"
+ assert_equal(-9, REXML::Functions::number(telem))
+ end
+ def test_functions_number_negative_float
+ telem = REXML::Element.new("elem")
+ telem.text="-9.13"
+ assert_equal(-9.13, REXML::Functions::number(telem))
+ end
+ #def test_functions_number_scientific_notation
+ # telem = REXML::Element.new("elem")
+ # telem.text="9.13E12"
+ # assert_equal(9.13E12, REXML::Functions::number(telem))
+ #end
end
- def test_functions_number_float
- telem = REXML::Element.new("elem")
- telem.text="10.4"
- assert_equal(10.4, REXML::Functions::number(telem))
- end
- def test_functions_number_negative_int
- telem = REXML::Element.new("elem")
- telem.text="-9"
- assert_equal(-9, REXML::Functions::number(telem))
- end
- def test_functions_number_negative_float
- telem = REXML::Element.new("elem")
- telem.text="-9.13"
- assert_equal(-9.13, REXML::Functions::number(telem))
- end
- #def test_functions_number_scientific_notation
- # telem = REXML::Element.new("elem")
- # telem.text="9.13E12"
- # assert_equal(9.13E12, REXML::Functions::number(telem))
- #end
-end
end
diff --git a/test/rexml/test_jaxen.rb b/test/rexml/test_jaxen.rb
index a5053aa..ab66139 100644
--- a/test/rexml/test_jaxen.rb
+++ b/test/rexml/test_jaxen.rb
@@ -7,122 +7,122 @@ require "rexml/xpath"
# ryan.a.cox@gmail.com
module REXMLTests
-class JaxenTester < Test::Unit::TestCase
- include REXMLTestUtils
- include REXML
+ class JaxenTester < Test::Unit::TestCase
+ include REXMLTestUtils
+ include REXML
- def test_axis ; test("axis") ; end
- def test_basic ; test("basic") ; end
- def test_basicupdate ; test("basicupdate") ; end
- def test_contents ; test("contents") ; end
- def test_defaultNamespace ; test("defaultNamespace") ; end
- def test_fibo ; test("fibo") ; end
- def test_id ; test("id") ; end
- def test_jaxen24 ; test("jaxen24") ; end
- def test_lang ; test("lang") ; end
- def test_message ; test("message") ; end
- def test_moreover ; test("moreover") ; end
- def test_much_ado ; test("much_ado") ; end
- def test_namespaces ; test("namespaces") ; end
- def test_nitf ; test("nitf") ; end
- def test_numbers ; test("numbers") ; end
- def test_pi ; test("pi") ; end
- def test_pi2 ; test("pi2") ; end
- def test_simple ; test("simple") ; end
- def test_testNamespaces ; test("testNamespaces") ; end
- def test_text ; test("text") ; end
- def test_underscore ; test("underscore") ; end
- def test_web ; test("web") ; end
- def test_web2 ; test("web2") ; end
+ def test_axis ; test("axis") ; end
+ def test_basic ; test("basic") ; end
+ def test_basicupdate ; test("basicupdate") ; end
+ def test_contents ; test("contents") ; end
+ def test_defaultNamespace ; test("defaultNamespace") ; end
+ def test_fibo ; test("fibo") ; end
+ def test_id ; test("id") ; end
+ def test_jaxen24 ; test("jaxen24") ; end
+ def test_lang ; test("lang") ; end
+ def test_message ; test("message") ; end
+ def test_moreover ; test("moreover") ; end
+ def test_much_ado ; test("much_ado") ; end
+ def test_namespaces ; test("namespaces") ; end
+ def test_nitf ; test("nitf") ; end
+ def test_numbers ; test("numbers") ; end
+ def test_pi ; test("pi") ; end
+ def test_pi2 ; test("pi2") ; end
+ def test_simple ; test("simple") ; end
+ def test_testNamespaces ; test("testNamespaces") ; end
+ def test_text ; test("text") ; end
+ def test_underscore ; test("underscore") ; end
+ def test_web ; test("web") ; end
+ def test_web2 ; test("web2") ; end
- private
- def test( fname )
-# Dir.entries( xml_dir ).each { |fname|
-# if fname =~ /\.xml$/
- file = File.new(fixture_path(fname+".xml"))
- doc = Document.new( file )
- XPath.each( doc, "/tests/document" ) {|e| handleDocument(e)}
-# end
-# }
- end
+ private
+ def test( fname )
+# Dir.entries( xml_dir ).each { |fname|
+# if fname =~ /\.xml$/
+ file = File.new(fixture_path(fname+".xml"))
+ doc = Document.new( file )
+ XPath.each( doc, "/tests/document" ) {|e| handleDocument(e)}
+# end
+# }
+ end
- # processes a tests/document/context node
- def handleContext( testDoc, ctxElement)
- testCtx = XPath.match( testDoc, ctxElement.attributes["select"] )[0]
- namespaces = {}
- if testCtx.class == Element
- testCtx.prefixes.each { |pre| handleNamespace( testCtx, pre, namespaces ) }
+ # processes a tests/document/context node
+ def handleContext( testDoc, ctxElement)
+ testCtx = XPath.match( testDoc, ctxElement.attributes["select"] )[0]
+ namespaces = {}
+ if testCtx.class == Element
+ testCtx.prefixes.each { |pre| handleNamespace( testCtx, pre, namespaces ) }
+ end
+ variables = {}
+ XPath.each( ctxElement, "@*[namespace-uri() = 'http://jaxen.org/test-harness/var']") { |attrib| handleVariable(testCtx, variables, attrib) }
+ XPath.each( ctxElement, "valueOf") { |e| handleValueOf(testCtx, variables, namespaces, e) }
+ XPath.each( ctxElement, "test[not(@exception) or (@exception != 'true') ]") { |e| handleNominalTest(testCtx,variables, namespaces, e) }
+ XPath.each( ctxElement, "test[@exception = 'true']") { |e| handleExceptionalTest(testCtx,variables, namespaces, e) }
end
- variables = {}
- XPath.each( ctxElement, "@*[namespace-uri() = 'http://jaxen.org/test-harness/var']") { |attrib| handleVariable(testCtx, variables, attrib) }
- XPath.each( ctxElement, "valueOf") { |e| handleValueOf(testCtx, variables, namespaces, e) }
- XPath.each( ctxElement, "test[not(@exception) or (@exception != 'true') ]") { |e| handleNominalTest(testCtx,variables, namespaces, e) }
- XPath.each( ctxElement, "test[@exception = 'true']") { |e| handleExceptionalTest(testCtx,variables, namespaces, e) }
- end
- # processes a tests/document/context/valueOf or tests/document/context/test/valueOf node
- def handleValueOf(ctx,variables, namespaces, valueOfElement)
- expected = valueOfElement.text
- got = XPath.match( ctx, valueOfElement.attributes["select"], namespaces, variables )[0]
- assert_true( (got.nil? && expected.nil?) || !got.nil? )
- case got.class
- when Element
- assert_equal( got.class, Element )
- when Attribute, Text, Comment, TrueClass, FalseClass
- assert_equal( expected, got.to_s )
- when Instruction
- assert_equal( expected, got.content )
- when Fixnum
- assert_equal( exected.to_f, got )
- when String
- # normalize values for comparison
- got = "" if got == nil or got == ""
- expected = "" if expected == nil or expected == ""
- assert_equal( expected, got )
- else
- assert_fail( "Wassup?" )
+ # processes a tests/document/context/valueOf or tests/document/context/test/valueOf node
+ def handleValueOf(ctx,variables, namespaces, valueOfElement)
+ expected = valueOfElement.text
+ got = XPath.match( ctx, valueOfElement.attributes["select"], namespaces, variables )[0]
+ assert_true( (got.nil? && expected.nil?) || !got.nil? )
+ case got.class
+ when Element
+ assert_equal( got.class, Element )
+ when Attribute, Text, Comment, TrueClass, FalseClass
+ assert_equal( expected, got.to_s )
+ when Instruction
+ assert_equal( expected, got.content )
+ when Fixnum
+ assert_equal( exected.to_f, got )
+ when String
+ # normalize values for comparison
+ got = "" if got == nil or got == ""
+ expected = "" if expected == nil or expected == ""
+ assert_equal( expected, got )
+ else
+ assert_fail( "Wassup?" )
+ end
end
- end
- # processes a tests/document/context/test node ( where @exception is false or doesn't exist )
- def handleNominalTest(ctx, variables, namespaces, testElement)
- expected = testElement.attributes["count"]
- got = XPath.match( ctx, testElement.attributes["select"], namespaces, variables )
- # might be a test with no count attribute, but nested valueOf elements
- assert( expected == got.size.to_s ) if !expected.nil?
+ # processes a tests/document/context/test node ( where @exception is false or doesn't exist )
+ def handleNominalTest(ctx, variables, namespaces, testElement)
+ expected = testElement.attributes["count"]
+ got = XPath.match( ctx, testElement.attributes["select"], namespaces, variables )
+ # might be a test with no count attribute, but nested valueOf elements
+ assert( expected == got.size.to_s ) if !expected.nil?
- XPath.each( testElement, "valueOf") { |e|
- handleValueOf(got, variables, namespaces, e)
- }
- end
+ XPath.each( testElement, "valueOf") { |e|
+ handleValueOf(got, variables, namespaces, e)
+ }
+ end
- # processes a tests/document/context/test node ( where @exception is true )
- def handleExceptionalTest(ctx, variables, namespaces, testElement)
- assert_raise( Exception ) {
- XPath.match( ctx, testElement.attributes["select"], namespaces, variables )
- }
- end
+ # processes a tests/document/context/test node ( where @exception is true )
+ def handleExceptionalTest(ctx, variables, namespaces, testElement)
+ assert_raise( Exception ) {
+ XPath.match( ctx, testElement.attributes["select"], namespaces, variables )
+ }
+ end
- # processes a tests/document node
- def handleDocument(docElement)
- puts "- Processing document: #{docElement.attributes['url']}"
- testFile = File.new( docElement.attributes["url"] )
- testDoc = Document.new testFile
- XPath.each( docElement, "context") { |e| handleContext(testDoc, e) }
- end
+ # processes a tests/document node
+ def handleDocument(docElement)
+ puts "- Processing document: #{docElement.attributes['url']}"
+ testFile = File.new( docElement.attributes["url"] )
+ testDoc = Document.new testFile
+ XPath.each( docElement, "context") { |e| handleContext(testDoc, e) }
+ end
- # processes a variable definition in a namespace like <test var:foo="bar">
- def handleVariable( ctx, variables, attrib )
- puts "--- Found attribute: #{attrib.name}"
- variables[attrib.name] = attrib.value
- end
+ # processes a variable definition in a namespace like <test var:foo="bar">
+ def handleVariable( ctx, variables, attrib )
+ puts "--- Found attribute: #{attrib.name}"
+ variables[attrib.name] = attrib.value
+ end
- # processes a namespace definition like <test xmlns:foo="fiz:bang:bam">
- def handleNamespace( ctx, prefix, namespaces )
- puts "--- Found namespace: #{prefix}"
- namespaces[prefix] = ctx.namespaces[prefix]
- end
+ # processes a namespace definition like <test xmlns:foo="fiz:bang:bam">
+ def handleNamespace( ctx, prefix, namespaces )
+ puts "--- Found namespace: #{prefix}"
+ namespaces[prefix] = ctx.namespaces[prefix]
+ end
-end
+ end
end
diff --git a/test/rexml/test_light.rb b/test/rexml/test_light.rb
index c47b9a6..b775eb7 100644
--- a/test/rexml/test_light.rb
+++ b/test/rexml/test_light.rb
@@ -3,104 +3,104 @@ require "rexml/light/node"
require "rexml/parsers/lightparser"
module REXMLTests
-class LightTester < Test::Unit::TestCase
- include REXMLTestUtils
- include REXML::Light
+ class LightTester < Test::Unit::TestCase
+ include REXMLTestUtils
+ include REXML::Light
- def test_parse_large
- xml_string = fixture_path("documentation.xml")
- parser = REXML::Parsers::LightParser.new(xml_string)
- tag, content = parser.parse
- assert_equal([:document, :text], [tag, content.first])
- end
+ def test_parse_large
+ xml_string = fixture_path("documentation.xml")
+ parser = REXML::Parsers::LightParser.new(xml_string)
+ tag, content = parser.parse
+ assert_equal([:document, :text], [tag, content.first])
+ end
- # FIXME INCOMPLETE
- # This is because the light API is not yet ready to be used to produce
- # trees.
+ # FIXME INCOMPLETE
+ # This is because the light API is not yet ready to be used to produce
+ # trees.
=begin
- def test_add_element
- doc = Node.new
- foo = doc.add_element( 'foo' )
- assert_equal( "foo", foo.name )
- end
+ def test_add_element
+ doc = Node.new
+ foo = doc.add_element( 'foo' )
+ assert_equal( "foo", foo.name )
+ end
- def test_add_attribute
- foo = Node.new( "a" )
- foo["attr"] = "bar"
- assert_equal( "bar", foo["attr"] )
- end
+ def test_add_attribute
+ foo = Node.new( "a" )
+ foo["attr"] = "bar"
+ assert_equal( "bar", foo["attr"] )
+ end
- def test_write_document
- r = make_small_document
- assert_equal( "<a><b/><c/></a>", r.to_s )
- end
+ def test_write_document
+ r = make_small_document
+ assert_equal( "<a><b/><c/></a>", r.to_s )
+ end
- def test_add_attribute_under_namespace
- foo = Node.new("a")
- foo["attr", "a"] = "1"
- foo["attr", "b"] = "2"
- foo["attr"] = "3"
- assert_equal( '1', foo['attr', 'a'] )
- assert_equal( '2', foo['attr', 'b'] )
- assert_equal( '3', foo['attr'] )
- end
+ def test_add_attribute_under_namespace
+ foo = Node.new("a")
+ foo["attr", "a"] = "1"
+ foo["attr", "b"] = "2"
+ foo["attr"] = "3"
+ assert_equal( '1', foo['attr', 'a'] )
+ assert_equal( '2', foo['attr', 'b'] )
+ assert_equal( '3', foo['attr'] )
+ end
- def test_change_namespace_of_element
- foo = Node.new
- assert_equal( '', foo.namespace )
- foo.namespace = 'a'
- assert_equal( 'a', foo.namespace )
- end
+ def test_change_namespace_of_element
+ foo = Node.new
+ assert_equal( '', foo.namespace )
+ foo.namespace = 'a'
+ assert_equal( 'a', foo.namespace )
+ end
- def test_access_child_elements
- foo = make_small_document
- assert_equal( 1, foo.size )
- a = foo[0]
- assert_equal( 2, a.size )
- assert_equal( 'b', a[0].name )
- assert_equal( 'c', a[1].name )
- end
+ def test_access_child_elements
+ foo = make_small_document
+ assert_equal( 1, foo.size )
+ a = foo[0]
+ assert_equal( 2, a.size )
+ assert_equal( 'b', a[0].name )
+ assert_equal( 'c', a[1].name )
+ end
- def test_itterate_over_children
- foo = make_small_document
- ctr = 0
- foo[0].each { ctr += 1 }
- assert_equal( 2, ctr )
- end
+ def test_itterate_over_children
+ foo = make_small_document
+ ctr = 0
+ foo[0].each { ctr += 1 }
+ assert_equal( 2, ctr )
+ end
- def test_add_text
- foo = Node.new( "a" )
- foo.add_text( "Sean" )
- sean = foo[0]
- assert( sean.node_type == :text )
- end
+ def test_add_text
+ foo = Node.new( "a" )
+ foo.add_text( "Sean" )
+ sean = foo[0]
+ assert( sean.node_type == :text )
+ end
- def test_add_instruction
- foo = Node.new( "a" )
- foo.add_instruction( "target", "value" )
- assert( foo[0].node_type == :processing_instruction )
- end
+ def test_add_instruction
+ foo = Node.new( "a" )
+ foo.add_instruction( "target", "value" )
+ assert( foo[0].node_type == :processing_instruction )
+ end
- def test_add_comment
- foo = Node.new( "a" )
- foo.add_comment( "target", "value" )
- assert( foo[0].node_type == :comment )
- end
+ def test_add_comment
+ foo = Node.new( "a" )
+ foo.add_comment( "target", "value" )
+ assert( foo[0].node_type == :comment )
+ end
- def test_get_root
- foo = Node.new( 'a' )
- 10.times { foo = foo.add_element('b') }
- assert_equals( 'b', foo.name )
- assert_equals( 'a', foo.root.name )
- end
+ def test_get_root
+ foo = Node.new( 'a' )
+ 10.times { foo = foo.add_element('b') }
+ assert_equals( 'b', foo.name )
+ assert_equals( 'a', foo.root.name )
+ end
- def make_small_document
- r = Node.new
- a = r.add_element( "a" )
- a.add_element( 'b' )
- a.add_element( 'c' )
- r
- end
+ def make_small_document
+ r = Node.new
+ a = r.add_element( "a" )
+ a.add_element( 'b' )
+ a.add_element( 'c' )
+ r
+ end
=end
-end
+ end
end
diff --git a/test/rexml/test_lightparser.rb b/test/rexml/test_lightparser.rb
index d492e0b..4aa465b 100644
--- a/test/rexml/test_lightparser.rb
+++ b/test/rexml/test_lightparser.rb
@@ -2,13 +2,13 @@ require_relative 'rexml_test_utils'
require 'rexml/parsers/lightparser'
module REXMLTests
-class LightParserTester < Test::Unit::TestCase
- include REXMLTestUtils
- include REXML
- def test_parsing
- f = File.new(fixture_path("documentation.xml"))
- parser = REXML::Parsers::LightParser.new( f )
- parser.parse
+ class LightParserTester < Test::Unit::TestCase
+ include REXMLTestUtils
+ include REXML
+ def test_parsing
+ f = File.new(fixture_path("documentation.xml"))
+ parser = REXML::Parsers::LightParser.new( f )
+ parser.parse
+ end
end
end
-end
diff --git a/test/rexml/test_listener.rb b/test/rexml/test_listener.rb
index 3d5c17e..ea84e0e 100644
--- a/test/rexml/test_listener.rb
+++ b/test/rexml/test_listener.rb
@@ -6,126 +6,126 @@ require 'rexml/document'
require 'rexml/streamlistener'
module REXMLTests
-class BaseTester < Test::Unit::TestCase
- include REXMLTestUtils
- def test_empty
- return unless defined? @listener
- # Empty.
- t1 = %Q{<string></string>}
- assert_equal( "", @listener.parse( t1 ),
- "Empty" )
- end
-
- def test_space
- return unless defined? @listener
- # Space.
- t2 = %Q{<string> </string>}
- assert_equal( " ", @listener.parse( t2 ),
- "Space" )
- end
-
- def test_whitespace
- return unless defined? @listener
- # Whitespaces.
- t3 = %Q{<string>RE\n \t \n \t XML</string>}
- assert_equal( "RE\n \t \n \t XML", @listener.parse( t3 ),
- "Whitespaces" )
- end
-
- def test_leading_trailing_whitespace
- return unless defined? @listener
- # Leading and trailing whitespaces.
- t4 = %Q{<string> REXML </string>}
- assert_equal( " REXML ", @listener.parse( t4 ),
- "Leading and trailing whitespaces" )
- end
+ class BaseTester < Test::Unit::TestCase
+ include REXMLTestUtils
+ def test_empty
+ return unless defined? @listener
+ # Empty.
+ t1 = %Q{<string></string>}
+ assert_equal( "", @listener.parse( t1 ),
+ "Empty" )
+ end
- def test_entity_reference
- return unless defined? @listener
- # Entity reference.
- t5 = %Q{<string>&lt;&gt;&amp;lt;&amp;gt;</string>}
- assert_equal( "<>&lt;&gt;", @listener.parse( t5 ),
- "Entity reference" )
- end
+ def test_space
+ return unless defined? @listener
+ # Space.
+ t2 = %Q{<string> </string>}
+ assert_equal( " ", @listener.parse( t2 ),
+ "Space" )
+ end
- def test_character_reference
- return unless defined? @listener
- # Character reference.
- t6 = %Q{<string>&#xd;</string>}
- assert_equal( "\r", @listener.parse( t6 ),
- "Character reference." )
- end
+ def test_whitespace
+ return unless defined? @listener
+ # Whitespaces.
+ t3 = %Q{<string>RE\n \t \n \t XML</string>}
+ assert_equal( "RE\n \t \n \t XML", @listener.parse( t3 ),
+ "Whitespaces" )
+ end
- def test_cr
- return unless defined? @listener
- # CR.
- t7 = %Q{<string> \r\n \r \n </string>}
- assert_equal( " \n \n \n ".unpack("C*").inspect,
- @listener.parse( t7 ).unpack("C*").inspect, "CR" )
- end
+ def test_leading_trailing_whitespace
+ return unless defined? @listener
+ # Leading and trailing whitespaces.
+ t4 = %Q{<string> REXML </string>}
+ assert_equal( " REXML ", @listener.parse( t4 ),
+ "Leading and trailing whitespaces" )
+ end
- # The accent bug, and the code that exhibits the bug, was contributed by
- # Guilhem Vellut
- class AccentListener
- def tag_start(name,attributes)
- #p name
- #p attributes
+ def test_entity_reference
+ return unless defined? @listener
+ # Entity reference.
+ t5 = %Q{<string>&lt;&gt;&amp;lt;&amp;gt;</string>}
+ assert_equal( "<>&lt;&gt;", @listener.parse( t5 ),
+ "Entity reference" )
end
- def tag_end(name)
- #p "/"+name
+
+ def test_character_reference
+ return unless defined? @listener
+ # Character reference.
+ t6 = %Q{<string>&#xd;</string>}
+ assert_equal( "\r", @listener.parse( t6 ),
+ "Character reference." )
end
- def xmldecl(a,b,c)
- #puts "#{a} #{b} #{c}"
+
+ def test_cr
+ return unless defined? @listener
+ # CR.
+ t7 = %Q{<string> \r\n \r \n </string>}
+ assert_equal( " \n \n \n ".unpack("C*").inspect,
+ @listener.parse( t7 ).unpack("C*").inspect, "CR" )
end
- def text(tx)
- #p tx
+
+ # The accent bug, and the code that exhibits the bug, was contributed by
+ # Guilhem Vellut
+ class AccentListener
+ def tag_start(name,attributes)
+ #p name
+ #p attributes
+ end
+ def tag_end(name)
+ #p "/"+name
+ end
+ def xmldecl(a,b,c)
+ #puts "#{a} #{b} #{c}"
+ end
+ def text(tx)
+ #p tx
+ end
end
- end
- def test_accents
- source = %[<?xml version="1.0" encoding="ISO-8859-1"?>
+ def test_accents
+ source = %[<?xml version="1.0" encoding="ISO-8859-1"?>
<g>
<f a="\xE9" />
</g>]
- doc = REXML::Document.new( source )
- a = doc.elements['/g/f'].attribute('a')
- if a.value.respond_to? :force_encoding
- a.value.force_encoding('binary')
- end
- assert_equal( "\xC3\xA9", a.value)
- doc = REXML::Document.parse_stream(
- File::new(fixture_path("stream_accents.xml")),
- AccentListener::new
- )
+ doc = REXML::Document.new( source )
+ a = doc.elements['/g/f'].attribute('a')
+ if a.value.respond_to? :force_encoding
+ a.value.force_encoding('binary')
+ end
+ assert_equal( "\xC3\xA9", a.value)
+ doc = REXML::Document.parse_stream(
+ File::new(fixture_path("stream_accents.xml")),
+ AccentListener::new
+ )
+ end
end
-end
-class MyREXMLListener
- include REXML::StreamListener
+ class MyREXMLListener
+ include REXML::StreamListener
- def initialize
- @text = nil
- end
+ def initialize
+ @text = nil
+ end
- def parse( stringOrReadable )
- @text = ""
- REXML::Document.parse_stream( stringOrReadable, self )
- @text
- end
+ def parse( stringOrReadable )
+ @text = ""
+ REXML::Document.parse_stream( stringOrReadable, self )
+ @text
+ end
- def text( text )
- @text << text
+ def text( text )
+ @text << text
+ end
end
-end
-class REXMLTester < BaseTester
- def setup
- @listener = MyREXMLListener.new
- end
+ class REXMLTester < BaseTester
+ def setup
+ @listener = MyREXMLListener.new
+ end
- def test_character_reference_2
- t6 = %Q{<string>&#xd;</string>}
- assert_equal( t6.strip, REXML::Document.new(t6).to_s )
+ def test_character_reference_2
+ t6 = %Q{<string>&#xd;</string>}
+ assert_equal( t6.strip, REXML::Document.new(t6).to_s )
+ end
end
end
-end
diff --git a/test/rexml/test_martin_fowler.rb b/test/rexml/test_martin_fowler.rb
index 3025c74..26db110 100644
--- a/test/rexml/test_martin_fowler.rb
+++ b/test/rexml/test_martin_fowler.rb
@@ -2,8 +2,8 @@ require 'test/unit'
require 'rexml/document'
module REXMLTests
-class OrderTester < Test::Unit::TestCase
- DOC = <<END
+ class OrderTester < Test::Unit::TestCase
+ DOC = <<END
<paper>
<title>Remove this element and figs order differently</title>
<figure src="fig1"/>
@@ -17,23 +17,23 @@ class OrderTester < Test::Unit::TestCase
</paper>
END
- def initialize n
- @doc = REXML::Document.new(DOC)
- @figs = REXML::XPath.match(@doc,'//figure')
- @names = @figs.collect {|f| f.attributes['src']}
- super
+ def initialize n
+ @doc = REXML::Document.new(DOC)
+ @figs = REXML::XPath.match(@doc,'//figure')
+ @names = @figs.collect {|f| f.attributes['src']}
+ super
+ end
+ def test_fig1
+ assert_equal 'fig1', @figs[0].attributes['src']
+ end
+ def test_fig2
+ assert_equal 'fig2', @figs[1].attributes['src']
+ end
+ def test_fig3
+ assert_equal 'fig3', @figs[2].attributes['src']
+ end
+ def test_fig4
+ assert_equal 'fig4', @figs[3].attributes['src']
+ end
end
- def test_fig1
- assert_equal 'fig1', @figs[0].attributes['src']
- end
- def test_fig2
- assert_equal 'fig2', @figs[1].attributes['src']
- end
- def test_fig3
- assert_equal 'fig3', @figs[2].attributes['src']
- end
- def test_fig4
- assert_equal 'fig4', @figs[3].attributes['src']
- end
-end
end
diff --git a/test/rexml/test_namespace.rb b/test/rexml/test_namespace.rb
index 01d496f..f5cd294 100644
--- a/test/rexml/test_namespace.rb
+++ b/test/rexml/test_namespace.rb
@@ -3,38 +3,38 @@ require_relative "rexml_test_utils"
require "rexml/document"
module REXMLTests
-class TestNamespace < Test::Unit::TestCase
- include REXMLTestUtils
- include REXML
+ class TestNamespace < Test::Unit::TestCase
+ include REXMLTestUtils
+ include REXML
- def setup
- @xsa_source = <<-EOL
- <?xml version="1.0"?>
- <?xsl stylesheet="blah.xsl"?>
- <!-- The first line tests the XMLDecl, the second tests PI.
- The next line tests DocType. This line tests comments. -->
- <!DOCTYPE xsa PUBLIC
- "-//LM Garshol//DTD XML Software Autoupdate 1.0//EN//XML"
- "http://www.garshol.priv.no/download/xsa/xsa.dtd">
+ def setup
+ @xsa_source = <<-EOL
+ <?xml version="1.0"?>
+ <?xsl stylesheet="blah.xsl"?>
+ <!-- The first line tests the XMLDecl, the second tests PI.
+ The next line tests DocType. This line tests comments. -->
+ <!DOCTYPE xsa PUBLIC
+ "-//LM Garshol//DTD XML Software Autoupdate 1.0//EN//XML"
+ "http://www.garshol.priv.no/download/xsa/xsa.dtd">
- <xsa>
- <vendor id="blah">
- <name>Lars Marius Garshol</name>
- <email>larsga@garshol.priv.no</email>
- <url>http://www.stud.ifi.uio.no/~lmariusg/</url>
- </vendor>
- </xsa>
- EOL
- end
+ <xsa>
+ <vendor id="blah">
+ <name>Lars Marius Garshol</name>
+ <email>larsga@garshol.priv.no</email>
+ <url>http://www.stud.ifi.uio.no/~lmariusg/</url>
+ </vendor>
+ </xsa>
+ EOL
+ end
- def test_xml_namespace
- xml = <<-XML
+ def test_xml_namespace
+ xml = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<root xmlns:xml="http://www.w3.org/XML/1998/namespace" />
XML
- document = Document.new(xml)
- assert_equal("http://www.w3.org/XML/1998/namespace",
- document.root.namespace("xml"))
+ document = Document.new(xml)
+ assert_equal("http://www.w3.org/XML/1998/namespace",
+ document.root.namespace("xml"))
+ end
end
end
-end
diff --git a/test/rexml/test_order.rb b/test/rexml/test_order.rb
index 9559c46..628e75d 100644
--- a/test/rexml/test_order.rb
+++ b/test/rexml/test_order.rb
@@ -6,10 +6,10 @@ rescue LoadError
end
module REXMLTests
-class OrderTester < Test::Unit::TestCase
- include REXMLTestUtils
+ class OrderTester < Test::Unit::TestCase
+ include REXMLTestUtils
- TESTDOC = <<END
+ TESTDOC = <<END
<a>
<b/>
<x id='1'/>
@@ -21,87 +21,87 @@ class OrderTester < Test::Unit::TestCase
</a>
END
- def setup
- @doc = REXML::Document.new(TESTDOC)
- @items = REXML::XPath.match(@doc,'//x')
- end
- def test_first_element
- assert_equal '1', @items[0].attributes['id']
- end
- def test_second_element
- assert_equal '2', @items[1].attributes['id']
- end
- def test_third_element
- assert_equal '3', @items[2].attributes['id']
- end
- def test_order
- d = REXML::Document.new( "<a><x id='1'/><x id='2'/><x id='3'/>
- <x id='4'/><x id='5'/></a>" )
- items = REXML::XPath.match( d, '//x' )
- assert_equal( %w{1 2 3 4 5}, items.collect{|e| e.attributes['id']} )
- d = REXML::Document.new( "<a>
- <x><z><y id='1'/><y id='2'/></z><y id='3'/></x>
- <x><y id='4'/></x></a>" )
- items = REXML::XPath.match( d, '//y' )
- assert_equal( %w{1 2 3 4}, items.collect{|e| e.attributes['id']} )
- end
- # Provided by Tom Talbott
- def test_more_ordering
- doc = REXML::Document.new(Zlib::GzipReader.open(fixture_path('LostineRiver.kml.gz'), encoding: 'utf-8'))
- actual = [
- "Head south from Phinney Ave N",
- "Turn left at N 36th St",
- "Turn right at Fremont Ave N",
- "Continue on 4th Ave N",
- "Turn left at Westlake Ave N",
- "Bear right at 9th Ave N",
- "Turn left at Mercer St",
- "Take the I-5 ramp",
- "Take the I-5 S ramp",
- "Take the I-90 E exit #164 to Bellevue/Spokane/4th Ave S.",
- "Take the I-90 E ramp to Bellevue/Spokane",
- "Take exit #137 to Wanapum Dam/Richland",
- "Bear right at WA-26",
- "Bear right and head toward WA-243",
- "Continue on WA-243",
- "Bear right at WA-24",
- "Continue on WA-240",
- "Turn right at WA-240 E",
- "Take the I-182 W ramp to Yakima (I-82)/Pendleton",
- "Take the I-82 E ramp to Umatilla/Pendleton",
- "Take the I-84 E ramp to Pendleton",
- "Take the OR-82 exit #261 to La Grande/Elgin",
- "Turn right at Island Ave",
- "Continue on W 1st St",
- "Turn left at N McAlister Rd",
- "Bear right at OR-82",
- "Continue on Wallowa Lake Hwy",
- "Continue on OR-82",
- "Continue on Ruckman Ave",
- "Continue on OR-82",
- "Continue on S 8th Ave",
- "Turn right at Albany St",
- "Continue on OR-82",
- "Continue on Wallowa Lake Hwy",
- "Continue on N Madison St",
- "Bear left at W 1st St",
- "Continue on Wallowa Lake Hwy",
- "Continue on Water St",
- "Bear right at Lostine River Rd",
- "Bear right and head toward Lostine River Rd",
- "Turn right at Lostine River Rd",
- "Continue on NF-8210",
- "Turn right and head toward NF-8210",
- "Turn right at NF-8210",
- "",
- "Route"
- ]
- count = 0
- REXML::XPath.each( doc, "//Placemark") { |element|
- n = element.elements["name"].text.squeeze(" ")
- assert_equal( actual[count], n ) unless n =~ /Arrive at/
- count += 1
- }
- end if defined?(Zlib::GzipReader)
-end
+ def setup
+ @doc = REXML::Document.new(TESTDOC)
+ @items = REXML::XPath.match(@doc,'//x')
+ end
+ def test_first_element
+ assert_equal '1', @items[0].attributes['id']
+ end
+ def test_second_element
+ assert_equal '2', @items[1].attributes['id']
+ end
+ def test_third_element
+ assert_equal '3', @items[2].attributes['id']
+ end
+ def test_order
+ d = REXML::Document.new( "<a><x id='1'/><x id='2'/><x id='3'/>
+ <x id='4'/><x id='5'/></a>" )
+ items = REXML::XPath.match( d, '//x' )
+ assert_equal( %w{1 2 3 4 5}, items.collect{|e| e.attributes['id']} )
+ d = REXML::Document.new( "<a>
+ <x><z><y id='1'/><y id='2'/></z><y id='3'/></x>
+ <x><y id='4'/></x></a>" )
+ items = REXML::XPath.match( d, '//y' )
+ assert_equal( %w{1 2 3 4}, items.collect{|e| e.attributes['id']} )
+ end
+ # Provided by Tom Talbott
+ def test_more_ordering
+ doc = REXML::Document.new(Zlib::GzipReader.open(fixture_path('LostineRiver.kml.gz'), encoding: 'utf-8'))
+ actual = [
+ "Head south from Phinney Ave N",
+ "Turn left at N 36th St",
+ "Turn right at Fremont Ave N",
+ "Continue on 4th Ave N",
+ "Turn left at Westlake Ave N",
+ "Bear right at 9th Ave N",
+ "Turn left at Mercer St",
+ "Take the I-5 ramp",
+ "Take the I-5 S ramp",
+ "Take the I-90 E exit #164 to Bellevue/Spokane/4th Ave S.",
+ "Take the I-90 E ramp to Bellevue/Spokane",
+ "Take exit #137 to Wanapum Dam/Richland",
+ "Bear right at WA-26",
+ "Bear right and head toward WA-243",
+ "Continue on WA-243",
+ "Bear right at WA-24",
+ "Continue on WA-240",
+ "Turn right at WA-240 E",
+ "Take the I-182 W ramp to Yakima (I-82)/Pendleton",
+ "Take the I-82 E ramp to Umatilla/Pendleton",
+ "Take the I-84 E ramp to Pendleton",
+ "Take the OR-82 exit #261 to La Grande/Elgin",
+ "Turn right at Island Ave",
+ "Continue on W 1st St",
+ "Turn left at N McAlister Rd",
+ "Bear right at OR-82",
+ "Continue on Wallowa Lake Hwy",
+ "Continue on OR-82",
+ "Continue on Ruckman Ave",
+ "Continue on OR-82",
+ "Continue on S 8th Ave",
+ "Turn right at Albany St",
+ "Continue on OR-82",
+ "Continue on Wallowa Lake Hwy",
+ "Continue on N Madison St",
+ "Bear left at W 1st St",
+ "Continue on Wallowa Lake Hwy",
+ "Continue on Water St",
+ "Bear right at Lostine River Rd",
+ "Bear right and head toward Lostine River Rd",
+ "Turn right at Lostine River Rd",
+ "Continue on NF-8210",
+ "Turn right and head toward NF-8210",
+ "Turn right at NF-8210",
+ "",
+ "Route"
+ ]
+ count = 0
+ REXML::XPath.each( doc, "//Placemark") { |element|
+ n = element.elements["name"].text.squeeze(" ")
+ assert_equal( actual[count], n ) unless n =~ /Arrive at/
+ count += 1
+ }
+ end if defined?(Zlib::GzipReader)
+ end
end
diff --git a/test/rexml/test_preceding_sibling.rb b/test/rexml/test_preceding_sibling.rb
index c05eedb..54fdd5b 100644
--- a/test/rexml/test_preceding_sibling.rb
+++ b/test/rexml/test_preceding_sibling.rb
@@ -3,38 +3,38 @@ require 'test/unit'
require 'rexml/document'
module REXMLTests
-# daz - for report by Dan Kohn in:
-# http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/156328
-class XPathTesterDd < Test::Unit::TestCase
- include REXML
+ # daz - for report by Dan Kohn in:
+ # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/156328
+ class XPathTesterDd < Test::Unit::TestCase
+ include REXML
- def setup
- @@docDd = Document.new(<<-EOS, :ignore_whitespace_nodes => :all)
- <a>
- <b x='ab01A'>
- <c y='abc01A'>Success</c>
- </b>
- <b x='ab02A' y='ab02B'>
- <c>abc02C</c>
- </b>
- </a>
- EOS
- end
+ def setup
+ @@docDd = Document.new(<<-EOS, :ignore_whitespace_nodes => :all)
+ <a>
+ <b x='ab01A'>
+ <c y='abc01A'>Success</c>
+ </b>
+ <b x='ab02A' y='ab02B'>
+ <c>abc02C</c>
+ </b>
+ </a>
+ EOS
+ end
- def test_Dd_preceding_sibling_children
- arr = []
- XPath.each(@@docDd, "//b[@x='ab02A']/preceding-sibling::b/child::*") do |cell|
- arr << cell.texts.join
+ def test_Dd_preceding_sibling_children
+ arr = []
+ XPath.each(@@docDd, "//b[@x='ab02A']/preceding-sibling::b/child::*") do |cell|
+ arr << cell.texts.join
+ end
+ assert_equal( 'Success', arr.join )
end
- assert_equal( 'Success', arr.join )
- end
- def test_Dd_preceding_sibling_all
- arr = []
- XPath.each(@@docDd, "//b[@x='ab02A']/preceding-sibling::*") do |cell|
- arr << cell.to_s
+ def test_Dd_preceding_sibling_all
+ arr = []
+ XPath.each(@@docDd, "//b[@x='ab02A']/preceding-sibling::*") do |cell|
+ arr << cell.to_s
+ end
+ assert_equal( "<b x='ab01A'><c y='abc01A'>Success</c></b>", arr.join )
end
- assert_equal( "<b x='ab01A'><c y='abc01A'>Success</c></b>", arr.join )
end
end
-end
diff --git a/test/rexml/test_pullparser.rb b/test/rexml/test_pullparser.rb
index 83751f2..db336a1 100644
--- a/test/rexml/test_pullparser.rb
+++ b/test/rexml/test_pullparser.rb
@@ -3,100 +3,100 @@ require "test/unit/testcase"
require 'rexml/parsers/pullparser'
module REXMLTests
-class PullParserTester < Test::Unit::TestCase
- include REXML
- def test_basics
- source = '<?xml version="1.0"?>
- <!DOCTYPE blah>
- <a>foo &lt;<b attribute="value">bar</b> nooo</a>'
- parser = REXML::Parsers::PullParser.new(source)
- res = { :text=>0 }
- until parser.empty?
- results = parser.pull
- res[ :xmldecl ] = true if results.xmldecl?
- res[ :doctype ] = true if results.doctype?
- res[ :a ] = true if results.start_element? and results[0] == 'a'
- if results.start_element? and results[0] == 'b'
- res[ :b ] = true
- assert_equal 'value', results[1]['attribute']
+ class PullParserTester < Test::Unit::TestCase
+ include REXML
+ def test_basics
+ source = '<?xml version="1.0"?>
+ <!DOCTYPE blah>
+ <a>foo &lt;<b attribute="value">bar</b> nooo</a>'
+ parser = REXML::Parsers::PullParser.new(source)
+ res = { :text=>0 }
+ until parser.empty?
+ results = parser.pull
+ res[ :xmldecl ] = true if results.xmldecl?
+ res[ :doctype ] = true if results.doctype?
+ res[ :a ] = true if results.start_element? and results[0] == 'a'
+ if results.start_element? and results[0] == 'b'
+ res[ :b ] = true
+ assert_equal 'value', results[1]['attribute']
+ end
+ res[ :text ] += 1 if results.text?
end
- res[ :text ] += 1 if results.text?
+ [ :xmldecl, :doctype, :a, :b ].each { |tag|
+ assert res[tag] , "#{tag} wasn't processed"
+ }
+ assert_equal 4, res[ :text ]
+ rescue ParseException
+ puts $!
end
- [ :xmldecl, :doctype, :a, :b ].each { |tag|
- assert res[tag] , "#{tag} wasn't processed"
- }
- assert_equal 4, res[ :text ]
- rescue ParseException
- puts $!
- end
- def test_bad_document
- source = "<a><b></a>"
- parser = REXML::Parsers::PullParser.new(source)
- assert_raise(ParseException, "Parsing should have failed") {
- parser.pull while parser.has_next?
- }
- end
+ def test_bad_document
+ source = "<a><b></a>"
+ parser = REXML::Parsers::PullParser.new(source)
+ assert_raise(ParseException, "Parsing should have failed") {
+ parser.pull while parser.has_next?
+ }
+ end
- def test_entity_replacement
- source = '<!DOCTYPE foo [
- <!ENTITY la "1234">
- <!ENTITY lala "--&la;--">
- <!ENTITY lalal "&la;&la;">
- ]><a><la>&la;</la><lala>&lala;</lala></a>'
- pp = REXML::Parsers::PullParser.new( source )
- el_name = ''
- while pp.has_next?
- event = pp.pull
- case event.event_type
- when :start_element
- el_name = event[0]
- when :text
- case el_name
- when 'la'
- assert_equal('1234', event[1])
- when 'lala'
- assert_equal('--1234--', event[1])
+ def test_entity_replacement
+ source = '<!DOCTYPE foo [
+ <!ENTITY la "1234">
+ <!ENTITY lala "--&la;--">
+ <!ENTITY lalal "&la;&la;">
+ ]><a><la>&la;</la><lala>&lala;</lala></a>'
+ pp = REXML::Parsers::PullParser.new( source )
+ el_name = ''
+ while pp.has_next?
+ event = pp.pull
+ case event.event_type
+ when :start_element
+ el_name = event[0]
+ when :text
+ case el_name
+ when 'la'
+ assert_equal('1234', event[1])
+ when 'lala'
+ assert_equal('--1234--', event[1])
+ end
end
end
end
- end
- def test_peek_unshift
- source = "<a><b/></a>"
- REXML::Parsers::PullParser.new(source)
- # FINISH ME!
- end
+ def test_peek_unshift
+ source = "<a><b/></a>"
+ REXML::Parsers::PullParser.new(source)
+ # FINISH ME!
+ end
- def test_inspect
- xml = '<a id="1"><b id="2">Hey</b></a>'
- parser = Parsers::PullParser.new( xml )
- while parser.has_next?
- pull_event = parser.pull
- if pull_event.start_element?
- peek = parser.peek()
- peek.inspect
+ def test_inspect
+ xml = '<a id="1"><b id="2">Hey</b></a>'
+ parser = Parsers::PullParser.new( xml )
+ while parser.has_next?
+ pull_event = parser.pull
+ if pull_event.start_element?
+ peek = parser.peek()
+ peek.inspect
+ end
end
end
- end
- def test_peek
- xml = '<a id="1"><b id="2">Hey</b></a>'
- parser = Parsers::PullParser.new( xml )
- names = %w{ a b }
- while parser.has_next?
- pull_event = parser.pull
- if pull_event.start_element?
- assert_equal( :start_element, pull_event.event_type )
- assert_equal( names.shift, pull_event[0] )
- if names[0] == 'b'
- peek = parser.peek()
- assert_equal( :start_element, peek.event_type )
- assert_equal( names[0], peek[0] )
+ def test_peek
+ xml = '<a id="1"><b id="2">Hey</b></a>'
+ parser = Parsers::PullParser.new( xml )
+ names = %w{ a b }
+ while parser.has_next?
+ pull_event = parser.pull
+ if pull_event.start_element?
+ assert_equal( :start_element, pull_event.event_type )
+ assert_equal( names.shift, pull_event[0] )
+ if names[0] == 'b'
+ peek = parser.peek()
+ assert_equal( :start_element, peek.event_type )
+ assert_equal( names[0], peek[0] )
+ end
end
end
+ assert_equal( 0, names.length )
end
- assert_equal( 0, names.length )
end
end
-end
diff --git a/test/rexml/test_rexml_issuezilla.rb b/test/rexml/test_rexml_issuezilla.rb
index 59649ae..8098646 100644
--- a/test/rexml/test_rexml_issuezilla.rb
+++ b/test/rexml/test_rexml_issuezilla.rb
@@ -2,15 +2,15 @@ require_relative 'rexml_test_utils'
require 'rexml/document'
module REXMLTests
-class TestIssuezillaParsing < Test::Unit::TestCase
- include REXMLTestUtils
- def test_rexml
- doc = REXML::Document.new(File.new(fixture_path("ofbiz-issues-full-177.xml")))
- ctr = 1
- doc.root.each_element('//issue') do |issue|
- assert_equal( ctr, issue.elements['issue_id'].text.to_i )
- ctr += 1
+ class TestIssuezillaParsing < Test::Unit::TestCase
+ include REXMLTestUtils
+ def test_rexml
+ doc = REXML::Document.new(File.new(fixture_path("ofbiz-issues-full-177.xml")))
+ ctr = 1
+ doc.root.each_element('//issue') do |issue|
+ assert_equal( ctr, issue.elements['issue_id'].text.to_i )
+ ctr += 1
+ end
end
end
end
-end
diff --git a/test/rexml/test_sax.rb b/test/rexml/test_sax.rb
index 5cf1ec1..f7e6695 100644
--- a/test/rexml/test_sax.rb
+++ b/test/rexml/test_sax.rb
@@ -4,277 +4,277 @@ require 'rexml/parsers/sax2parser'
require 'rexml/document'
module REXMLTests
-class SAX2Tester < Test::Unit::TestCase
- include REXMLTestUtils
- include REXML
- def test_characters
- d = Document.new( "<A>@blah@</A>" )
- txt = d.root.text
- p = Parsers::SAX2Parser.new "<A>@blah@</A>"
- p.listen(:characters) {|x| assert_equal txt, x}
- p.listen(:characters, ["A"]) {|x| assert_equal txt,x}
- p.parse
- end
+ class SAX2Tester < Test::Unit::TestCase
+ include REXMLTestUtils
+ include REXML
+ def test_characters
+ d = Document.new( "<A>@blah@</A>" )
+ txt = d.root.text
+ p = Parsers::SAX2Parser.new "<A>@blah@</A>"
+ p.listen(:characters) {|x| assert_equal txt, x}
+ p.listen(:characters, ["A"]) {|x| assert_equal txt,x}
+ p.parse
+ end
- def test_entity_replacement
- source = '<!DOCTYPE foo [
- <!ENTITY la "1234">
- <!ENTITY lala "--&la;--">
- <!ENTITY lalal "&la;&la;">
- ]><a><la>&la;</la><lala>&lala;</lala></a>'
- sax = Parsers::SAX2Parser.new( source )
- results = []
- sax.listen(:characters) {|x| results << x }
- sax.parse
- assert_equal 2, results.size
- assert_equal '1234', results[0]
- assert_equal '--1234--', results[1]
- end
+ def test_entity_replacement
+ source = '<!DOCTYPE foo [
+ <!ENTITY la "1234">
+ <!ENTITY lala "--&la;--">
+ <!ENTITY lalal "&la;&la;">
+ ]><a><la>&la;</la><lala>&lala;</lala></a>'
+ sax = Parsers::SAX2Parser.new( source )
+ results = []
+ sax.listen(:characters) {|x| results << x }
+ sax.parse
+ assert_equal 2, results.size
+ assert_equal '1234', results[0]
+ assert_equal '--1234--', results[1]
+ end
- def test_sax2
- f = File.new(fixture_path("documentation.xml"))
- parser = Parsers::SAX2Parser.new( f )
- # Listen to all events on the following elements
- count = 0
- blok = proc { |uri,localname,qname,attributes|
- assert %w{ bugs todo }.include?(localname),
- "Mismatched name; we got '#{qname}'\nArgs were:\n\tURI: #{uri}\n\tLOCALNAME: #{localname}\n\tQNAME: #{qname}\n\tATTRIBUTES: #{attributes.inspect}\n\tSELF=#{blok}"
- count += 1
- }
+ def test_sax2
+ f = File.new(fixture_path("documentation.xml"))
+ parser = Parsers::SAX2Parser.new( f )
+ # Listen to all events on the following elements
+ count = 0
+ blok = proc { |uri,localname,qname,attributes|
+ assert %w{ bugs todo }.include?(localname),
+ "Mismatched name; we got '#{qname}'\nArgs were:\n\tURI: #{uri}\n\tLOCALNAME: #{localname}\n\tQNAME: #{qname}\n\tATTRIBUTES: #{attributes.inspect}\n\tSELF=#{blok}"
+ count += 1
+ }
- start_document = 0
- end_document = 0
- parser.listen( :start_document ) { start_document += 1 }
- parser.listen( :end_document ) { end_document += 1 }
- parser.listen( :start_element, %w{ changelog bugs todo }, &blok )
- # Listen to all events on the following elements. Synonymous with
- # listen( :start_element, %w{ ... } )
- parser.listen( %w{ changelog bugs todo }, &blok )
- # Listen for all start element events
- parser.listen( :start_element ) { |uri,localname,qname,attributes|
- }
- listener = MySAX2Listener.new
- # Listen for all events
- parser.listen( listener )
- # Listen for all events on the given elements. Does not include children
- # events. Regular expressions work as well!
- parser.listen( %w{ /change/ bugs todo }, listener )
- # Test the deafening method
- blok = proc { |uri,localname,qname,attributes|
- assert_fail "This listener should have been deafened!"
- }
- parser.listen( %w{ changelog }, &blok )
- parser.deafen( &blok )
+ start_document = 0
+ end_document = 0
+ parser.listen( :start_document ) { start_document += 1 }
+ parser.listen( :end_document ) { end_document += 1 }
+ parser.listen( :start_element, %w{ changelog bugs todo }, &blok )
+ # Listen to all events on the following elements. Synonymous with
+ # listen( :start_element, %w{ ... } )
+ parser.listen( %w{ changelog bugs todo }, &blok )
+ # Listen for all start element events
+ parser.listen( :start_element ) { |uri,localname,qname,attributes|
+ }
+ listener = MySAX2Listener.new
+ # Listen for all events
+ parser.listen( listener )
+ # Listen for all events on the given elements. Does not include children
+ # events. Regular expressions work as well!
+ parser.listen( %w{ /change/ bugs todo }, listener )
+ # Test the deafening method
+ blok = proc { |uri,localname,qname,attributes|
+ assert_fail "This listener should have been deafened!"
+ }
+ parser.listen( %w{ changelog }, &blok )
+ parser.deafen( &blok )
- tc = 0
- parser.listen( :characters, %w{version} ) {|text|
- assert(text=~/@ANT_VERSION@/, "version was '#{text}'")
- tc += 1
- }
+ tc = 0
+ parser.listen( :characters, %w{version} ) {|text|
+ assert(text=~/@ANT_VERSION@/, "version was '#{text}'")
+ tc += 1
+ }
- begin
- parser.parse
- rescue => exception
- if exception.kind_of? Test::Unit::AssertionFailedError
- raise exception
+ begin
+ parser.parse
+ rescue => exception
+ if exception.kind_of? Test::Unit::AssertionFailedError
+ raise exception
+ end
+ puts $!
+ puts exception.backtrace
end
- puts $!
- puts exception.backtrace
+ assert_equal 2, count
+ assert_equal 1, tc
+ assert_equal 1, start_document
+ assert_equal 1, end_document
end
- assert_equal 2, count
- assert_equal 1, tc
- assert_equal 1, start_document
- assert_equal 1, end_document
- end
- # used by test_simple_doctype_listener
- # submitted by Jeff Barczewski
- class SimpleDoctypeListener
- include REXML::SAX2Listener
- attr_reader :name, :pub_sys, :long_name, :uri
+ # used by test_simple_doctype_listener
+ # submitted by Jeff Barczewski
+ class SimpleDoctypeListener
+ include REXML::SAX2Listener
+ attr_reader :name, :pub_sys, :long_name, :uri
- def initialize
- @name = @pub_sys = @long_name = @uri = nil
- end
+ def initialize
+ @name = @pub_sys = @long_name = @uri = nil
+ end
- def doctype(name, pub_sys, long_name, uri)
- @name = name
- @pub_sys = pub_sys
- @long_name = long_name
- @uri = uri
+ def doctype(name, pub_sys, long_name, uri)
+ @name = name
+ @pub_sys = pub_sys
+ @long_name = long_name
+ @uri = uri
+ end
end
- end
- # test simple non-entity doctype in sax listener
- # submitted by Jeff Barczewski
- def test_simple_doctype_listener
- xml = <<-END
- <?xml version="1.0"?>
- <!DOCTYPE greeting PUBLIC "Hello Greeting DTD" "http://foo/hello.dtd">
- <greeting>Hello, world!</greeting>
- END
- parser = Parsers::SAX2Parser.new(xml)
- dtl = SimpleDoctypeListener.new
- parser.listen(dtl)
- tname = nil
- tpub_sys = nil
- tlong_name = nil
- turi = nil
- parser.listen(:doctype) do |name, pub_sys, long_name, uri|
- tname = name
- tpub_sys = pub_sys
- tlong_name = long_name
- turi = uri
+ # test simple non-entity doctype in sax listener
+ # submitted by Jeff Barczewski
+ def test_simple_doctype_listener
+ xml = <<-END
+ <?xml version="1.0"?>
+ <!DOCTYPE greeting PUBLIC "Hello Greeting DTD" "http://foo/hello.dtd">
+ <greeting>Hello, world!</greeting>
+ END
+ parser = Parsers::SAX2Parser.new(xml)
+ dtl = SimpleDoctypeListener.new
+ parser.listen(dtl)
+ tname = nil
+ tpub_sys = nil
+ tlong_name = nil
+ turi = nil
+ parser.listen(:doctype) do |name, pub_sys, long_name, uri|
+ tname = name
+ tpub_sys = pub_sys
+ tlong_name = long_name
+ turi = uri
+ end
+ parser.parse
+ assert_equal 'greeting', tname, 'simple doctype block listener failed - incorrect name'
+ assert_equal 'PUBLIC', tpub_sys, 'simple doctype block listener failed - incorrect pub_sys'
+ assert_equal 'Hello Greeting DTD', tlong_name, 'simple doctype block listener failed - incorrect long_name'
+ assert_equal 'http://foo/hello.dtd', turi, 'simple doctype block listener failed - incorrect uri'
+ assert_equal 'greeting', dtl.name, 'simple doctype listener failed - incorrect name'
+ assert_equal 'PUBLIC', dtl.pub_sys, 'simple doctype listener failed - incorrect pub_sys'
+ assert_equal 'Hello Greeting DTD', dtl.long_name, 'simple doctype listener failed - incorrect long_name'
+ assert_equal 'http://foo/hello.dtd', dtl.uri, 'simple doctype listener failed - incorrect uri'
end
- parser.parse
- assert_equal 'greeting', tname, 'simple doctype block listener failed - incorrect name'
- assert_equal 'PUBLIC', tpub_sys, 'simple doctype block listener failed - incorrect pub_sys'
- assert_equal 'Hello Greeting DTD', tlong_name, 'simple doctype block listener failed - incorrect long_name'
- assert_equal 'http://foo/hello.dtd', turi, 'simple doctype block listener failed - incorrect uri'
- assert_equal 'greeting', dtl.name, 'simple doctype listener failed - incorrect name'
- assert_equal 'PUBLIC', dtl.pub_sys, 'simple doctype listener failed - incorrect pub_sys'
- assert_equal 'Hello Greeting DTD', dtl.long_name, 'simple doctype listener failed - incorrect long_name'
- assert_equal 'http://foo/hello.dtd', dtl.uri, 'simple doctype listener failed - incorrect uri'
- end
- # test doctype with missing name, should throw ParseException
- # submitted by Jeff Barczewseki
- def test_doctype_with_mising_name_throws_exception
- xml = <<-END
- <?xml version="1.0"?>
- <!DOCTYPE >
- <greeting>Hello, world!</greeting>
- END
- parser = Parsers::SAX2Parser.new(xml)
- assert_raise(REXML::ParseException, 'doctype missing name did not throw ParseException') do
- parser.parse
+ # test doctype with missing name, should throw ParseException
+ # submitted by Jeff Barczewseki
+ def test_doctype_with_mising_name_throws_exception
+ xml = <<-END
+ <?xml version="1.0"?>
+ <!DOCTYPE >
+ <greeting>Hello, world!</greeting>
+ END
+ parser = Parsers::SAX2Parser.new(xml)
+ assert_raise(REXML::ParseException, 'doctype missing name did not throw ParseException') do
+ parser.parse
+ end
end
- end
- class KouListener
- include REXML::SAX2Listener
- attr_accessor :sdoc, :edoc
- attr_reader :selem, :decl, :pi
- def initialize
- @sdoc = @edoc = @selem = false
- @decl = 0
- @pi = 0
- end
- def start_document
- @sdoc = true
- end
- def end_document
- @edoc = true
- end
- def xmldecl( *arg )
- @decl += 1
- end
- def processing_instruction( *arg )
- @pi += 1
- end
- def start_element( *arg )
- @selem = true
+ class KouListener
+ include REXML::SAX2Listener
+ attr_accessor :sdoc, :edoc
+ attr_reader :selem, :decl, :pi
+ def initialize
+ @sdoc = @edoc = @selem = false
+ @decl = 0
+ @pi = 0
+ end
+ def start_document
+ @sdoc = true
+ end
+ def end_document
+ @edoc = true
+ end
+ def xmldecl( *arg )
+ @decl += 1
+ end
+ def processing_instruction( *arg )
+ @pi += 1
+ end
+ def start_element( *arg )
+ @selem = true
+ end
end
- end
- # Submitted by Kou
- def test_begin_end_document
- parser = Parsers::SAX2Parser.new("<a/>")
+ # Submitted by Kou
+ def test_begin_end_document
+ parser = Parsers::SAX2Parser.new("<a/>")
- kl = KouListener.new
- parser.listen(kl)
- sd = false
- ed = false
- parser.listen(:start_document) { sd = true }
- parser.listen(:end_document) { ed = true }
+ kl = KouListener.new
+ parser.listen(kl)
+ sd = false
+ ed = false
+ parser.listen(:start_document) { sd = true }
+ parser.listen(:end_document) { ed = true }
- parser.parse
- assert( sd, ':start_document block failed' )
- assert( ed, ':end_document block failed' )
- assert( kl.sdoc, ':start_document listener failed' )
- assert( kl.edoc, ':end_document listener failed' )
- end
+ parser.parse
+ assert( sd, ':start_document block failed' )
+ assert( ed, ':end_document block failed' )
+ assert( kl.sdoc, ':start_document listener failed' )
+ assert( kl.edoc, ':end_document listener failed' )
+ end
- # Submitted by Kou
- def test_listen_before_start
- # FIXME: the following comment should be a test for validity. (The xml declaration
- # is invalid).
- #parser = Parsers::SAX2Parser.new( "<?xml ?><?pi?><a><?pi?></a>")
- parser = Parsers::SAX2Parser.new( "<?xml version='1.0'?><?pi?><a><?pi?></a>")
- k1 = KouListener.new
- parser.listen( k1 )
- xmldecl = false
- pi = 0
- parser.listen( :xmldecl ) { xmldecl = true }
- parser.listen( :processing_instruction ) { pi += 1 }
+ # Submitted by Kou
+ def test_listen_before_start
+ # FIXME: the following comment should be a test for validity. (The xml declaration
+ # is invalid).
+ #parser = Parsers::SAX2Parser.new( "<?xml ?><?pi?><a><?pi?></a>")
+ parser = Parsers::SAX2Parser.new( "<?xml version='1.0'?><?pi?><a><?pi?></a>")
+ k1 = KouListener.new
+ parser.listen( k1 )
+ xmldecl = false
+ pi = 0
+ parser.listen( :xmldecl ) { xmldecl = true }
+ parser.listen( :processing_instruction ) { pi += 1 }
- parser.parse
+ parser.parse
- assert( xmldecl, ':xmldecl failed' )
- assert_equal( 2, pi, ':processing_instruction failed' )
- assert( k1.decl, 'Listener for xmldecl failed' )
- assert_equal( 2, k1.pi, 'Listener for processing instruction failed' )
- end
+ assert( xmldecl, ':xmldecl failed' )
+ assert_equal( 2, pi, ':processing_instruction failed' )
+ assert( k1.decl, 'Listener for xmldecl failed' )
+ assert_equal( 2, k1.pi, 'Listener for processing instruction failed' )
+ end
- def test_socket
- require 'socket'
+ def test_socket
+ require 'socket'
- server = TCPServer.new('127.0.0.1', 0)
- socket = TCPSocket.new('127.0.0.1', server.addr[1])
+ server = TCPServer.new('127.0.0.1', 0)
+ socket = TCPSocket.new('127.0.0.1', server.addr[1])
- ok = false
- session = server.accept
- session << '<foo>'
- parser = REXML::Parsers::SAX2Parser.new(socket)
- Fiber.new do
- parser.listen(:start_element) do
- ok = true
- Fiber.yield
- end
- parser.parse
- end.resume
- assert(ok)
- end
+ ok = false
+ session = server.accept
+ session << '<foo>'
+ parser = REXML::Parsers::SAX2Parser.new(socket)
+ Fiber.new do
+ parser.listen(:start_element) do
+ ok = true
+ Fiber.yield
+ end
+ parser.parse
+ end.resume
+ assert(ok)
+ end
- def test_char_ref_sax2()
- parser = REXML::Parsers::SAX2Parser.new('<ABC>&#252;</ABC>')
- result = nil
- parser.listen(:characters) {|text| result = text.unpack('U*')}
- parser.parse()
- assert_equal(1, result.size)
- assert_equal(252, result[0])
- end
+ def test_char_ref_sax2()
+ parser = REXML::Parsers::SAX2Parser.new('<ABC>&#252;</ABC>')
+ result = nil
+ parser.listen(:characters) {|text| result = text.unpack('U*')}
+ parser.parse()
+ assert_equal(1, result.size)
+ assert_equal(252, result[0])
+ end
- def test_char_ref_dom()
- doc = REXML::Document.new('<ABC>&#252;</ABC>')
- result = doc.root.text.unpack('U*')
- assert_equal(1, result.size)
- assert_equal(252, result[0])
- end
+ def test_char_ref_dom()
+ doc = REXML::Document.new('<ABC>&#252;</ABC>')
+ result = doc.root.text.unpack('U*')
+ assert_equal(1, result.size)
+ assert_equal(252, result[0])
+ end
- class Ticket68
- include REXML::SAX2Listener
- end
- def test_ticket_68
- parser = REXML::Parsers::SAX2Parser.new(File.new(fixture_path('ticket_68.xml')))
- parser.listen( Ticket68.new )
- begin
- parser.parse
- rescue
- p parser.source.position
- p parser.source.current_line
- puts $!.backtrace.join("\n")
- flunk $!.message
+ class Ticket68
+ include REXML::SAX2Listener
+ end
+ def test_ticket_68
+ parser = REXML::Parsers::SAX2Parser.new(File.new(fixture_path('ticket_68.xml')))
+ parser.listen( Ticket68.new )
+ begin
+ parser.parse
+ rescue
+ p parser.source.position
+ p parser.source.current_line
+ puts $!.backtrace.join("\n")
+ flunk $!.message
+ end
end
end
-end
-class MySAX2Listener
- include REXML::SAX2Listener
-end
+ class MySAX2Listener
+ include REXML::SAX2Listener
+ end
end
diff --git a/test/rexml/test_stream.rb b/test/rexml/test_stream.rb
index d9e622f..3164d91 100644
--- a/test/rexml/test_stream.rb
+++ b/test/rexml/test_stream.rb
@@ -4,126 +4,126 @@ require 'rexml/streamlistener'
require 'stringio'
module REXMLTests
-class MyListener
- include REXML::StreamListener
-end
+ class MyListener
+ include REXML::StreamListener
+ end
-class StreamTester < Test::Unit::TestCase
- # Submitted by Han Holl
- def test_listener
- data = %Q{<session1 user="han" password="rootWeiler" />\n<session2 user="han" password="rootWeiler" />}
+ class StreamTester < Test::Unit::TestCase
+ # Submitted by Han Holl
+ def test_listener
+ data = %Q{<session1 user="han" password="rootWeiler" />\n<session2 user="han" password="rootWeiler" />}
- b = RequestReader.new( data )
- b = RequestReader.new( data )
- end
+ b = RequestReader.new( data )
+ b = RequestReader.new( data )
+ end
- def test_ticket_49
- source = StringIO.new( <<-EOL )
- <!DOCTYPE foo [
- <!ENTITY ent "replace">
- ]>
- <a>&ent;</a>
- EOL
- REXML::Document.parse_stream(source, MyListener.new)
- end
+ def test_ticket_49
+ source = StringIO.new( <<-EOL )
+ <!DOCTYPE foo [
+ <!ENTITY ent "replace">
+ ]>
+ <a>&ent;</a>
+ EOL
+ REXML::Document.parse_stream(source, MyListener.new)
+ end
- def test_ticket_10
- source = StringIO.new( <<-EOL )
- <!DOCTYPE foo [
- <!ENTITY ent "replace">
- <!ATTLIST a
- xmlns:human CDATA #FIXED "http://www.foo.com/human">
- <!ELEMENT bar (#PCDATA)>
- <!NOTATION n1 PUBLIC "-//HM//NOTATION TEST1//EN" 'urn:x-henrikmartensson.org:test5'>
- ]>
- <a/>
- EOL
- listener = MyListener.new
- class << listener
- attr_accessor :events
- def entitydecl( content )
- @events[ :entitydecl ] = true
- end
- def attlistdecl( element_name, attributes, raw_content )
- @events[ :attlistdecl ] = true
- end
- def elementdecl( content )
- @events[ :elementdecl ] = true
+ def test_ticket_10
+ source = StringIO.new( <<-EOL )
+ <!DOCTYPE foo [
+ <!ENTITY ent "replace">
+ <!ATTLIST a
+ xmlns:human CDATA #FIXED "http://www.foo.com/human">
+ <!ELEMENT bar (#PCDATA)>
+ <!NOTATION n1 PUBLIC "-//HM//NOTATION TEST1//EN" 'urn:x-henrikmartensson.org:test5'>
+ ]>
+ <a/>
+ EOL
+ listener = MyListener.new
+ class << listener
+ attr_accessor :events
+ def entitydecl( content )
+ @events[ :entitydecl ] = true
+ end
+ def attlistdecl( element_name, attributes, raw_content )
+ @events[ :attlistdecl ] = true
+ end
+ def elementdecl( content )
+ @events[ :elementdecl ] = true
+ end
+ def notationdecl( content )
+ @events[ :notationdecl ] = true
+ end
end
- def notationdecl( content )
- @events[ :notationdecl ] = true
- end
- end
- listener.events = {}
+ listener.events = {}
- REXML::Document.parse_stream( source, listener )
+ REXML::Document.parse_stream( source, listener )
- assert( listener.events[:entitydecl] )
- assert( listener.events[:attlistdecl] )
- assert( listener.events[:elementdecl] )
- assert( listener.events[:notationdecl] )
- end
+ assert( listener.events[:entitydecl] )
+ assert( listener.events[:attlistdecl] )
+ assert( listener.events[:elementdecl] )
+ assert( listener.events[:notationdecl] )
+ end
- def test_entity
- listener = MyListener.new
- class << listener
- attr_accessor :entities
- def entity(content)
- @entities << content
+ def test_entity
+ listener = MyListener.new
+ class << listener
+ attr_accessor :entities
+ def entity(content)
+ @entities << content
+ end
end
- end
- listener.entities = []
+ listener.entities = []
- source = StringIO.new(<<-XML)
+ source = StringIO.new(<<-XML)
<!DOCTYPE root [
<!ENTITY % ISOLat2
SYSTEM "http://www.xml.com/iso/isolat2-xml.entities" >
%ISOLat2;
]>
<root/>
- XML
- REXML::Document.parse_stream(source, listener)
+ XML
+ REXML::Document.parse_stream(source, listener)
- assert_equal(["ISOLat2"], listener.entities)
+ assert_equal(["ISOLat2"], listener.entities)
+ end
end
-end
-# For test_listener
-class RequestReader
- attr_reader :doc
- def initialize(io)
- @stack = []
- @doc = nil
- catch(:fini) do
- REXML::Document.parse_stream(io, self)
- raise IOError
+ # For test_listener
+ class RequestReader
+ attr_reader :doc
+ def initialize(io)
+ @stack = []
+ @doc = nil
+ catch(:fini) do
+ REXML::Document.parse_stream(io, self)
+ raise IOError
+ end
end
- end
- def tag_start(name, args)
- if @doc
- @stack.push(REXML::Element.new(name, @stack.last))
- else
- @doc = REXML::Document.new("<#{name}/>")
- @stack.push(@doc.root)
+ def tag_start(name, args)
+ if @doc
+ @stack.push(REXML::Element.new(name, @stack.last))
+ else
+ @doc = REXML::Document.new("<#{name}/>")
+ @stack.push(@doc.root)
+ end
+ args.each do |attr,val|
+ @stack.last.add_attribute(attr, val)
+ end
end
- args.each do |attr,val|
- @stack.last.add_attribute(attr, val)
+ def tag_end(name, *args)
+ @stack.pop
+ throw(:fini) if @stack.empty?
+ end
+ def text(str)
+ @stack.last.text = str
+ end
+ def comment(str)
+ end
+ def doctype( name, pub_sys, long_name, uri )
+ end
+ def doctype_end
end
end
- def tag_end(name, *args)
- @stack.pop
- throw(:fini) if @stack.empty?
- end
- def text(str)
- @stack.last.text = str
- end
- def comment(str)
- end
- def doctype( name, pub_sys, long_name, uri )
- end
- def doctype_end
- end
-end
end
diff --git a/test/rexml/test_text.rb b/test/rexml/test_text.rb
index 9aa0e2f..52ee11e 100644
--- a/test/rexml/test_text.rb
+++ b/test/rexml/test_text.rb
@@ -1,21 +1,21 @@
require "rexml/text"
module REXMLTests
-class TextTester < Test::Unit::TestCase
- include REXML
+ class TextTester < Test::Unit::TestCase
+ include REXML
- def test_shift_operator_chain
- text = Text.new("original\r\n")
- text << "append1\r\n" << "append2\r\n"
- assert_equal("original\nappend1\nappend2\n", text.to_s)
- end
+ def test_shift_operator_chain
+ text = Text.new("original\r\n")
+ text << "append1\r\n" << "append2\r\n"
+ assert_equal("original\nappend1\nappend2\n", text.to_s)
+ end
- def test_shift_operator_cache
- text = Text.new("original\r\n")
- text << "append1\r\n" << "append2\r\n"
- assert_equal("original\nappend1\nappend2\n", text.to_s)
- text << "append3\r\n" << "append4\r\n"
- assert_equal("original\nappend1\nappend2\nappend3\nappend4\n", text.to_s)
+ def test_shift_operator_cache
+ text = Text.new("original\r\n")
+ text << "append1\r\n" << "append2\r\n"
+ assert_equal("original\nappend1\nappend2\n", text.to_s)
+ text << "append3\r\n" << "append4\r\n"
+ assert_equal("original\nappend1\nappend2\nappend3\nappend4\n", text.to_s)
+ end
end
end
-end
diff --git a/test/rexml/test_ticket_80.rb b/test/rexml/test_ticket_80.rb
index bd58881..ffeece5 100644
--- a/test/rexml/test_ticket_80.rb
+++ b/test/rexml/test_ticket_80.rb
@@ -10,9 +10,9 @@ require 'test/unit'
require 'rexml/document'
module REXMLTests
-class Ticket80 < Test::Unit::TestCase
+ class Ticket80 < Test::Unit::TestCase
- @@xmlstr = '<?xml version="1.0"?>
+ @@xmlstr = '<?xml version="1.0"?>
<root xmlns="urn:some-xml-ns" xmlns:other="urn:some-other-xml-ns">
<l1-foo>
<l2 value="foo-01"/>
@@ -28,29 +28,29 @@ class Ticket80 < Test::Unit::TestCase
</l1-bar>
</root>'
- #----------------------------------------------------------------------------
- def test_xpathNamespacedChildWildcard
- # tests the "prefix:*" node test syntax
- out = Array.new
- REXML::XPath.each( REXML::Document.new(@@xmlstr),
- '/ns:root/ns:*/ns:l2/@value',
- { 'ns' => 'urn:some-xml-ns' } ) do |node| out.push node.value ; end
- chk = [ 'foo-01', 'foo-02', 'foo-03', 'bar-01', 'bar-02' ]
- assert_equal chk, out
- end
+ #----------------------------------------------------------------------------
+ def test_xpathNamespacedChildWildcard
+ # tests the "prefix:*" node test syntax
+ out = Array.new
+ REXML::XPath.each( REXML::Document.new(@@xmlstr),
+ '/ns:root/ns:*/ns:l2/@value',
+ { 'ns' => 'urn:some-xml-ns' } ) do |node| out.push node.value ; end
+ chk = [ 'foo-01', 'foo-02', 'foo-03', 'bar-01', 'bar-02' ]
+ assert_equal chk, out
+ end
- #----------------------------------------------------------------------------
- def test_xpathNamespacedChildWildcardWorkaround
- # tests a workaround for the "prefix:*" node test syntax
- out = Array.new
- REXML::XPath.each( REXML::Document.new(@@xmlstr),
- '/ns:root/*[namespace-uri()="urn:some-xml-ns"]/ns:l2/@value',
- { 'ns' => 'urn:some-xml-ns' } ) do |node| out.push node.value ; end
- chk = [ 'foo-01', 'foo-02', 'foo-03', 'bar-01', 'bar-02' ]
- assert_equal chk, out
- end
+ #----------------------------------------------------------------------------
+ def test_xpathNamespacedChildWildcardWorkaround
+ # tests a workaround for the "prefix:*" node test syntax
+ out = Array.new
+ REXML::XPath.each( REXML::Document.new(@@xmlstr),
+ '/ns:root/*[namespace-uri()="urn:some-xml-ns"]/ns:l2/@value',
+ { 'ns' => 'urn:some-xml-ns' } ) do |node| out.push node.value ; end
+ chk = [ 'foo-01', 'foo-02', 'foo-03', 'bar-01', 'bar-02' ]
+ assert_equal chk, out
+ end
-end
+ end
end
#------------------------------------------------------------------------------
diff --git a/test/rexml/test_validation_rng.rb b/test/rexml/test_validation_rng.rb
index 67abe20..8989fe2 100644
--- a/test/rexml/test_validation_rng.rb
+++ b/test/rexml/test_validation_rng.rb
@@ -4,11 +4,11 @@ require "rexml/document"
require "rexml/validation/relaxng"
module REXMLTests
-class RNGValidation < Test::Unit::TestCase
- include REXML
+ class RNGValidation < Test::Unit::TestCase
+ include REXML
- def test_validate
- rng = %q{
+ def test_validate
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -25,16 +25,16 @@ class RNGValidation < Test::Unit::TestCase
</element>
</element>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- no_error( validator, %q{<A><B><C X="x"><E/><E/></C><D/></B></A>} )
- error( validator, %q{<A><B><D/><C X="x"/></B></A>} )
- end
+ no_error( validator, %q{<A><B><C X="x"><E/><E/></C><D/></B></A>} )
+ error( validator, %q{<A><B><D/><C X="x"/></B></A>} )
+ end
- def test_sequence
- rng = %q{
+ def test_sequence
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -46,18 +46,18 @@ class RNGValidation < Test::Unit::TestCase
</element>
</element>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B><C/><C/><D/></B></A>} )
- error( validator, %q{<A><B><D/><C/></B></A>} )
- error( validator, %q{<A><C/><D/></A>} )
- no_error( validator, %q{<A><B><C/><D/></B></A>} )
- end
+ error( validator, %q{<A><B><C/><C/><D/></B></A>} )
+ error( validator, %q{<A><B><D/><C/></B></A>} )
+ error( validator, %q{<A><C/><D/></A>} )
+ no_error( validator, %q{<A><B><C/><D/></B></A>} )
+ end
- def test_choice
- rng = %q{
+ def test_choice
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -71,16 +71,16 @@ class RNGValidation < Test::Unit::TestCase
</choice>
</element>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B><C/><D/></B></A>} )
- no_error( validator, %q{<A><B><D/></B></A>} )
- no_error( validator, %q{<A><B><C/></B></A>} )
- end
+ error( validator, %q{<A><B><C/><D/></B></A>} )
+ no_error( validator, %q{<A><B><D/></B></A>} )
+ no_error( validator, %q{<A><B><C/></B></A>} )
+ end
- def test_optional
- rng = %q{
+ def test_optional
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -91,17 +91,17 @@ class RNGValidation < Test::Unit::TestCase
</optional>
</element>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- no_error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A><B><C/></B></A>} )
- error( validator, %q{<A><B><D/></B></A>} )
- error( validator, %q{<A><B><C/><C/></B></A>} )
- end
+ no_error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A><B><C/></B></A>} )
+ error( validator, %q{<A><B><D/></B></A>} )
+ error( validator, %q{<A><B><C/><C/></B></A>} )
+ end
- def test_zero_or_more
- rng = %q{
+ def test_zero_or_more
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -112,15 +112,15 @@ class RNGValidation < Test::Unit::TestCase
</zeroOrMore>
</element>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
- no_error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A><B><C/></B></A>} )
- no_error( validator, %q{<A><B><C/><C/><C/></B></A>} )
- error( validator, %q{<A><B><D/></B></A>} )
- error( validator, %q{<A></A>} )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
+ no_error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A><B><C/></B></A>} )
+ no_error( validator, %q{<A><B><C/><C/><C/></B></A>} )
+ error( validator, %q{<A><B><D/></B></A>} )
+ error( validator, %q{<A></A>} )
- rng = %q{
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -134,17 +134,17 @@ class RNGValidation < Test::Unit::TestCase
</zeroOrMore>
</element>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- no_error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A><B><C/><D/></B></A>} )
- no_error( validator, %q{<A><B><C/><D/><C/><D/></B></A>} )
- error( validator, %q{<A><B><D/></B></A>} )
- end
+ no_error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A><B><C/><D/></B></A>} )
+ no_error( validator, %q{<A><B><C/><D/><C/><D/></B></A>} )
+ error( validator, %q{<A><B><D/></B></A>} )
+ end
- def test_one_or_more
- rng = %q{
+ def test_one_or_more
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -155,34 +155,34 @@ class RNGValidation < Test::Unit::TestCase
</oneOrMore>
</element>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
-
- error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A><B><C/></B></A>} )
- no_error( validator, %q{<A><B><C/><C/><C/></B></A>} )
- error( validator, %q{<A><B><D/></B></A>} )
- error( validator, %q{<A></A>} )
- end
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
+
+ error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A><B><C/></B></A>} )
+ no_error( validator, %q{<A><B><C/><C/><C/></B></A>} )
+ error( validator, %q{<A><B><D/></B></A>} )
+ error( validator, %q{<A></A>} )
+ end
- def test_attribute
- rng = %q{
+ def test_attribute
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<attribute name="X"/>
<attribute name="Y"/>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/></A>} )
- error( validator, %q{<A/>} )
- error( validator, %q{<A X=""/>} )
- no_error( validator, %q{<A X="1" Y="1"/>} )
- end
+ error( validator, %q{<A><B/></A>} )
+ error( validator, %q{<A/>} )
+ error( validator, %q{<A X=""/>} )
+ no_error( validator, %q{<A X="1" Y="1"/>} )
+ end
- def test_choice_attributes
- rng = %q{
+ def test_choice_attributes
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<choice>
@@ -190,17 +190,17 @@ class RNGValidation < Test::Unit::TestCase
<attribute name="Y"/>
</choice>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A X="1" Y="1"/>} )
- error( validator, %q{<A/>} )
- no_error( validator, %q{<A X="1"/>})
- no_error( validator, %q{<A Y="1"/>} )
- end
+ error( validator, %q{<A X="1" Y="1"/>} )
+ error( validator, %q{<A/>} )
+ no_error( validator, %q{<A X="1"/>})
+ no_error( validator, %q{<A Y="1"/>} )
+ end
- def test_choice_attribute_element
- rng = %q{
+ def test_choice_attribute_element
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<choice>
@@ -208,45 +208,45 @@ class RNGValidation < Test::Unit::TestCase
<element name="B"/>
</choice>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A X="1"><B/></A>} )
- error( validator, %q{<A/>} )
- no_error( validator, %q{<A X="1"/>})
- no_error( validator, %q{<A><B/></A>} )
- end
+ error( validator, %q{<A X="1"><B/></A>} )
+ error( validator, %q{<A/>} )
+ no_error( validator, %q{<A X="1"/>})
+ no_error( validator, %q{<A><B/></A>} )
+ end
- def test_empty
- rng = %q{
+ def test_empty
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<empty/>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/></A>} )
- error( validator, %q{<A>Text</A>} )
- no_error( validator, %q{<A/>})
- end
+ error( validator, %q{<A><B/></A>} )
+ error( validator, %q{<A>Text</A>} )
+ no_error( validator, %q{<A/>})
+ end
- def test_text_val
- rng = %q{
+ def test_text_val
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<text/>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A>Text</A>} )
- error( validator, %q{<A/>})
- end
+ error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A>Text</A>} )
+ error( validator, %q{<A/>})
+ end
- def test_choice_text
- rng = %q{
+ def test_choice_text
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<choice>
@@ -254,17 +254,17 @@ class RNGValidation < Test::Unit::TestCase
<text/>
</choice>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/>Text</A>} )
- error( validator, %q{<A>Text<B/></A>} )
- no_error( validator, %q{<A>Text</A>} )
- no_error( validator, %q{<A><B/></A>} )
- end
+ error( validator, %q{<A><B/>Text</A>} )
+ error( validator, %q{<A>Text<B/></A>} )
+ no_error( validator, %q{<A>Text</A>} )
+ no_error( validator, %q{<A><B/></A>} )
+ end
- def test_group
- rng = %q{
+ def test_group
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<choice>
@@ -275,15 +275,15 @@ class RNGValidation < Test::Unit::TestCase
</group>
</choice>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/><C/></A>} )
- error( validator, %q{<A><C/></A>} )
- no_error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A><C/><D/></A>} )
+ error( validator, %q{<A><B/><C/></A>} )
+ error( validator, %q{<A><C/></A>} )
+ no_error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A><C/><D/></A>} )
- rng = %q{
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B"/>
@@ -292,33 +292,33 @@ class RNGValidation < Test::Unit::TestCase
<element name="D"/>
</group>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/><C/></A>} )
- error( validator, %q{<A><B/><D/></A>} )
- error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A><B/><C/><D/></A>} )
- end
+ error( validator, %q{<A><B/><C/></A>} )
+ error( validator, %q{<A><B/><D/></A>} )
+ error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A><B/><C/><D/></A>} )
+ end
- def test_value
- # Values as text nodes
- rng = %q{
+ def test_value
+ # Values as text nodes
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
<value>VaLuE</value>
</element>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B>X</B></A>} )
- error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A><B>VaLuE</B></A>} )
+ error( validator, %q{<A><B>X</B></A>} )
+ error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A><B>VaLuE</B></A>} )
- # Values as text nodes, via choice
- rng = %q{
+ # Values as text nodes, via choice
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -328,32 +328,32 @@ class RNGValidation < Test::Unit::TestCase
</choice>
</element>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/></A>} )
- error( validator, %q{<A><B>XYZ</B></A>} )
- no_error( validator, %q{<A><B>Option 1</B></A>} )
- no_error( validator, %q{<A><B>Option 2</B></A>} )
+ error( validator, %q{<A><B/></A>} )
+ error( validator, %q{<A><B>XYZ</B></A>} )
+ no_error( validator, %q{<A><B>Option 1</B></A>} )
+ no_error( validator, %q{<A><B>Option 2</B></A>} )
- # Attribute values
- rng = %q{
+ # Attribute values
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<attribute name="B">
<value>VaLuE</value>
</attribute>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A/>} )
- error( validator, %q{<A B=""/>} )
- error( validator, %q{<A B="Lala"/>} )
- no_error( validator, %q{<A B="VaLuE"/>} )
+ error( validator, %q{<A/>} )
+ error( validator, %q{<A B=""/>} )
+ error( validator, %q{<A B="Lala"/>} )
+ no_error( validator, %q{<A B="VaLuE"/>} )
- # Attribute values via choice
- rng = %q{
+ # Attribute values via choice
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<attribute name="B">
@@ -363,17 +363,17 @@ class RNGValidation < Test::Unit::TestCase
</choice>
</attribute>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A B=""/>} )
- error( validator, %q{<A B="Value"/>} )
- no_error( validator, %q{<A B="Option 1"></A>} )
- no_error( validator, %q{<A B="Option 2"/>} )
- end
+ error( validator, %q{<A B=""/>} )
+ error( validator, %q{<A B="Value"/>} )
+ no_error( validator, %q{<A B="Option 1"></A>} )
+ no_error( validator, %q{<A B="Option 2"/>} )
+ end
- def test_interleave
- rng = %q{
+ def test_interleave
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -384,20 +384,20 @@ class RNGValidation < Test::Unit::TestCase
</interleave>
</element>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
-
- error( validator, %q{<A><B><C/></B></A>} )
- error( validator, %q{<A><B><C/><D/><C/></B></A>} )
- no_error( validator, %q{<A><B><C/><D/><E/></B></A>} )
- no_error( validator, %q{<A><B><E/><D/><C/></B></A>} )
- no_error( validator, %q{<A><B><D/><C/><E/></B></A>} )
- no_error( validator, %q{<A><B><E/><C/><D/></B></A>} )
- error( validator, %q{<A><B><E/><C/><D/><C/></B></A>} )
- end
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- def test_mixed
- rng = %q{
+ error( validator, %q{<A><B><C/></B></A>} )
+ error( validator, %q{<A><B><C/><D/><C/></B></A>} )
+ no_error( validator, %q{<A><B><C/><D/><E/></B></A>} )
+ no_error( validator, %q{<A><B><E/><D/><C/></B></A>} )
+ no_error( validator, %q{<A><B><D/><C/><E/></B></A>} )
+ no_error( validator, %q{<A><B><E/><C/><D/></B></A>} )
+ error( validator, %q{<A><B><E/><C/><D/><C/></B></A>} )
+ end
+
+ def test_mixed
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<element name="A" xmlns="http://relaxng.org/ns/structure/1.0">
<element name="B">
@@ -406,15 +406,15 @@ class RNGValidation < Test::Unit::TestCase
</mixed>
</element>
</element>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- no_error( validator, %q{<A><B>Text<D/></B></A>} )
- no_error( validator, %q{<A><B><D/>Text</B></A>} )
- end
+ no_error( validator, %q{<A><B>Text<D/></B></A>} )
+ no_error( validator, %q{<A><B><D/>Text</B></A>} )
+ end
- def test_ref_sequence
- rng = %q{
+ def test_ref_sequence
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -430,15 +430,15 @@ class RNGValidation < Test::Unit::TestCase
</element>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- no_error( validator, %q{<A><B X=''/><B X=''/></A>} )
- error( validator, %q{<A><B X=''/></A>} )
- end
+ no_error( validator, %q{<A><B X=''/><B X=''/></A>} )
+ error( validator, %q{<A><B X=''/></A>} )
+ end
- def test_ref_choice
- rng = %q{
+ def test_ref_choice
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -454,15 +454,15 @@ class RNGValidation < Test::Unit::TestCase
<element name="C"/>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><D/></A>} )
- error( validator, %q{<A><B/><C/></A>} )
- no_error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A><C/></A>} )
+ error( validator, %q{<A><D/></A>} )
+ error( validator, %q{<A><B/><C/></A>} )
+ no_error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A><C/></A>} )
- rng = %q{
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -478,15 +478,15 @@ class RNGValidation < Test::Unit::TestCase
</choice>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><D/></A>} )
- error( validator, %q{<A><B/><C/></A>} )
- no_error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A><C/></A>} )
+ error( validator, %q{<A><D/></A>} )
+ error( validator, %q{<A><B/><C/></A>} )
+ no_error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A><C/></A>} )
- rng = %q{
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -503,18 +503,18 @@ class RNGValidation < Test::Unit::TestCase
<element name="C"/>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/><C/></A>} )
- no_error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A><C/></A>} )
- no_error( validator, %q{<A><D/></A>} )
- end
+ error( validator, %q{<A><B/><C/></A>} )
+ no_error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A><C/></A>} )
+ no_error( validator, %q{<A><D/></A>} )
+ end
- def test_ref_zero_plus
- rng = %q{
+ def test_ref_zero_plus
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -531,15 +531,15 @@ class RNGValidation < Test::Unit::TestCase
</element>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A/>} )
- no_error( validator, %q{<A><B X=''/></A>} )
- no_error( validator, %q{<A><B X=''/><B X=''/><B X=''/></A>} )
+ error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A/>} )
+ no_error( validator, %q{<A><B X=''/></A>} )
+ no_error( validator, %q{<A><B X=''/><B X=''/><B X=''/></A>} )
- rng = %q{
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -556,18 +556,18 @@ class RNGValidation < Test::Unit::TestCase
</zeroOrMore>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A/>} )
- no_error( validator, %q{<A><B X=''/></A>} )
- no_error( validator, %q{<A><B X=''/><B X=''/><B X=''/></A>} )
- end
+ error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A/>} )
+ no_error( validator, %q{<A><B X=''/></A>} )
+ no_error( validator, %q{<A><B X=''/><B X=''/><B X=''/></A>} )
+ end
- def test_ref_one_plus
- rng = %q{
+ def test_ref_one_plus
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -584,15 +584,15 @@ class RNGValidation < Test::Unit::TestCase
</element>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/></A>} )
- error( validator, %q{<A/>} )
- no_error( validator, %q{<A><B X=''/></A>} )
- no_error( validator, %q{<A><B X=''/><B X=''/><B X=''/></A>} )
+ error( validator, %q{<A><B/></A>} )
+ error( validator, %q{<A/>} )
+ no_error( validator, %q{<A><B X=''/></A>} )
+ no_error( validator, %q{<A><B X=''/><B X=''/><B X=''/></A>} )
- rng = %q{
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -609,17 +609,17 @@ class RNGValidation < Test::Unit::TestCase
</oneOrMore>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/></A>} )
- error( validator, %q{<A/>} )
- no_error( validator, %q{<A><B X=''/></A>} )
- no_error( validator, %q{<A><B X=''/><B X=''/><B X=''/></A>} )
- end
+ error( validator, %q{<A><B/></A>} )
+ error( validator, %q{<A/>} )
+ no_error( validator, %q{<A><B X=''/></A>} )
+ no_error( validator, %q{<A><B X=''/><B X=''/><B X=''/></A>} )
+ end
- def test_ref_interleave
- rng = %q{
+ def test_ref_interleave
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -635,16 +635,16 @@ class RNGValidation < Test::Unit::TestCase
<element name="C"/>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/></A>} )
- error( validator, %q{<A><C/></A>} )
- error( validator, %q{<A><C/><C/></A>} )
- no_error( validator, %q{<A><B/><C/></A>} )
- no_error( validator, %q{<A><C/><B/></A>} )
+ error( validator, %q{<A><B/></A>} )
+ error( validator, %q{<A><C/></A>} )
+ error( validator, %q{<A><C/><C/></A>} )
+ no_error( validator, %q{<A><B/><C/></A>} )
+ no_error( validator, %q{<A><C/><B/></A>} )
- rng = %q{
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -660,16 +660,16 @@ class RNGValidation < Test::Unit::TestCase
</interleave>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A><B/></A>} )
- error( validator, %q{<A><C/></A>} )
- error( validator, %q{<A><C/><C/></A>} )
- no_error( validator, %q{<A><B/><C/></A>} )
- no_error( validator, %q{<A><C/><B/></A>} )
+ error( validator, %q{<A><B/></A>} )
+ error( validator, %q{<A><C/></A>} )
+ error( validator, %q{<A><C/><C/></A>} )
+ no_error( validator, %q{<A><B/><C/></A>} )
+ no_error( validator, %q{<A><C/><B/></A>} )
- rng = %q{
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -688,18 +688,18 @@ class RNGValidation < Test::Unit::TestCase
<element name="C"/>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
-
- error( validator, %q{<A><B/></A>} )
- error( validator, %q{<A><C/></A>} )
- error( validator, %q{<A><C/><C/></A>} )
- no_error( validator, %q{<A><B/><C/></A>} )
- no_error( validator, %q{<A><C/><B/></A>} )
- end
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- def test_ref_recurse
- rng = %q{
+ error( validator, %q{<A><B/></A>} )
+ error( validator, %q{<A><C/></A>} )
+ error( validator, %q{<A><C/><C/></A>} )
+ no_error( validator, %q{<A><B/><C/></A>} )
+ no_error( validator, %q{<A><C/><B/></A>} )
+ end
+
+ def test_ref_recurse
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -716,16 +716,16 @@ class RNGValidation < Test::Unit::TestCase
</element>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- error( validator, %q{<A></A>} )
- no_error( validator, %q{<A><B/></A>} )
- no_error( validator, %q{<A><B><B/></B></A>} )
- end
+ error( validator, %q{<A></A>} )
+ no_error( validator, %q{<A><B/></A>} )
+ no_error( validator, %q{<A><B><B/></B></A>} )
+ end
- def test_ref_optional
- rng = %q{
+ def test_ref_optional
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -741,15 +741,15 @@ class RNGValidation < Test::Unit::TestCase
</element>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- no_error( validator, %q{<A></A>} )
- no_error( validator, %q{<A><B/></A>} )
- error( validator, %q{<A><B/><B/></A>} )
- error( validator, %q{<A><C/></A>} )
+ no_error( validator, %q{<A></A>} )
+ no_error( validator, %q{<A><B/></A>} )
+ error( validator, %q{<A><B/><B/></A>} )
+ error( validator, %q{<A><C/></A>} )
- rng = %q{
+ rng = %q{
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0">
<start>
@@ -765,28 +765,28 @@ class RNGValidation < Test::Unit::TestCase
</optional>
</define>
</grammar>
- }
- validator = REXML::Validation::RelaxNG.new( rng )
+ }
+ validator = REXML::Validation::RelaxNG.new( rng )
- no_error( validator, %q{<A></A>} )
- no_error( validator, %q{<A><B/></A>} )
- error( validator, %q{<A><B/><B/></A>} )
- error( validator, %q{<A><C/></A>} )
- end
+ no_error( validator, %q{<A></A>} )
+ no_error( validator, %q{<A><B/></A>} )
+ error( validator, %q{<A><B/><B/></A>} )
+ error( validator, %q{<A><C/></A>} )
+ end
- def error( validator, source )
- parser = REXML::Parsers::TreeParser.new( source )
- parser.add_listener( validator.reset )
- assert_raise( REXML::Validation::ValidationException,
- "Expected a validation error" ) { parser.parse }
- end
+ def error( validator, source )
+ parser = REXML::Parsers::TreeParser.new( source )
+ parser.add_listener( validator.reset )
+ assert_raise( REXML::Validation::ValidationException,
+ "Expected a validation error" ) { parser.parse }
+ end
- def no_error( validator, source )
- parser = REXML::Parsers::TreeParser.new( source )
- parser.add_listener( validator.reset )
- assert_nothing_raised { parser.parse }
+ def no_error( validator, source )
+ parser = REXML::Parsers::TreeParser.new( source )
+ parser.add_listener( validator.reset )
+ assert_nothing_raised { parser.parse }
+ end
end
end
-end
diff --git a/test/rexml/test_xml_declaration.rb b/test/rexml/test_xml_declaration.rb
index a7b7023..a96d40c 100644
--- a/test/rexml/test_xml_declaration.rb
+++ b/test/rexml/test_xml_declaration.rb
@@ -7,29 +7,29 @@ require "rexml/document"
require "test/unit"
module REXMLTests
-class TestXmlDeclaration < Test::Unit::TestCase
- def setup
- xml = <<-'END_XML'
- <?xml encoding= 'UTF-8' standalone='yes'?>
- <root>
- </root>
- END_XML
- @doc = REXML::Document.new xml
- @root = @doc.root
- @xml_declaration = @doc.children[0]
- end
+ class TestXmlDeclaration < Test::Unit::TestCase
+ def setup
+ xml = <<-'END_XML'
+ <?xml encoding= 'UTF-8' standalone='yes'?>
+ <root>
+ </root>
+ END_XML
+ @doc = REXML::Document.new xml
+ @root = @doc.root
+ @xml_declaration = @doc.children[0]
+ end
- def test_is_first_child
- assert_kind_of(REXML::XMLDecl, @xml_declaration)
- end
+ def test_is_first_child
+ assert_kind_of(REXML::XMLDecl, @xml_declaration)
+ end
- def test_has_document_as_parent
- assert_kind_of(REXML::Document, @xml_declaration.parent)
- end
+ def test_has_document_as_parent
+ assert_kind_of(REXML::Document, @xml_declaration.parent)
+ end
- def test_has_sibling
- assert_kind_of(REXML::XMLDecl, @root.previous_sibling.previous_sibling)
- assert_kind_of(REXML::Element, @xml_declaration.next_sibling.next_sibling)
+ def test_has_sibling
+ assert_kind_of(REXML::XMLDecl, @root.previous_sibling.previous_sibling)
+ assert_kind_of(REXML::Element, @xml_declaration.next_sibling.next_sibling)
+ end
end
end
-end
diff --git a/test/rexml/xpath/test_attribute.rb b/test/rexml/xpath/test_attribute.rb
index 3139104..95af4de 100644
--- a/test/rexml/xpath/test_attribute.rb
+++ b/test/rexml/xpath/test_attribute.rb
@@ -2,28 +2,28 @@ require 'test/unit'
require 'rexml/document'
module REXMLTests
-class TestXPathAttribute < Test::Unit::TestCase
- def setup
- @xml = <<-XML
+ class TestXPathAttribute < Test::Unit::TestCase
+ def setup
+ @xml = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<root>
<child name="one">child1</child>
<child name="two">child2</child>
<child name="three">child3</child>
</root>
- XML
- @document = REXML::Document.new(@xml)
- end
+ XML
+ @document = REXML::Document.new(@xml)
+ end
- def test_elements
- root = @document.elements["root"]
- second_child = root.elements["child[@name='two']"]
- assert_equal("child2", second_child.text)
- end
+ def test_elements
+ root = @document.elements["root"]
+ second_child = root.elements["child[@name='two']"]
+ assert_equal("child2", second_child.text)
+ end
- def test_xpath_each
- children = REXML::XPath.each(@document, "/root/child[@name='two']")
- assert_equal(["child2"], children.collect(&:text))
+ def test_xpath_each
+ children = REXML::XPath.each(@document, "/root/child[@name='two']")
+ assert_equal(["child2"], children.collect(&:text))
+ end
end
end
-end
diff --git a/test/rexml/xpath/test_axis_preceding_sibling.rb b/test/rexml/xpath/test_axis_preceding_sibling.rb
index faba177..2731807 100644
--- a/test/rexml/xpath/test_axis_preceding_sibling.rb
+++ b/test/rexml/xpath/test_axis_preceding_sibling.rb
@@ -2,38 +2,38 @@ require "test/unit/testcase"
require "rexml/document"
module REXMLTests
-class TestXPathAxisPredcedingSibling < Test::Unit::TestCase
- include REXML
- SOURCE = <<-EOF
- <a id='1'>
- <e id='2'>
- <f id='3'/>
- <f id='4'/>
- <f id='5'/>
- <f id='6'/>
- </e>
- </a>
- EOF
+ class TestXPathAxisPredcedingSibling < Test::Unit::TestCase
+ include REXML
+ SOURCE = <<-EOF
+ <a id='1'>
+ <e id='2'>
+ <f id='3'/>
+ <f id='4'/>
+ <f id='5'/>
+ <f id='6'/>
+ </e>
+ </a>
+ EOF
- def setup
- @@doc = Document.new(SOURCE) unless defined? @@doc
- end
+ def setup
+ @@doc = Document.new(SOURCE) unless defined? @@doc
+ end
- def test_preceding_sibling_axis
- context = XPath.first(@@doc,"/a/e/f[last()]")
- assert_equal "6", context.attributes["id"]
+ def test_preceding_sibling_axis
+ context = XPath.first(@@doc,"/a/e/f[last()]")
+ assert_equal "6", context.attributes["id"]
- prev = XPath.first(context, "preceding-sibling::f")
- assert_equal "5", prev.attributes["id"]
+ prev = XPath.first(context, "preceding-sibling::f")
+ assert_equal "5", prev.attributes["id"]
- prev = XPath.first(context, "preceding-sibling::f[1]")
- assert_equal "5", prev.attributes["id"]
+ prev = XPath.first(context, "preceding-sibling::f[1]")
+ assert_equal "5", prev.attributes["id"]
- prev = XPath.first(context, "preceding-sibling::f[2]")
- assert_equal "4", prev.attributes["id"]
+ prev = XPath.first(context, "preceding-sibling::f[2]")
+ assert_equal "4", prev.attributes["id"]
- prev = XPath.first(context, "preceding-sibling::f[3]")
- assert_equal "3", prev.attributes["id"]
+ prev = XPath.first(context, "preceding-sibling::f[3]")
+ assert_equal "3", prev.attributes["id"]
+ end
end
end
-end
diff --git a/test/rexml/xpath/test_base.rb b/test/rexml/xpath/test_base.rb
index 54559c9..8ef5e4a 100644
--- a/test/rexml/xpath/test_base.rb
+++ b/test/rexml/xpath/test_base.rb
@@ -3,755 +3,755 @@ require_relative "../rexml_test_utils"
require "rexml/document"
module REXMLTests
-class TestXPathBase < Test::Unit::TestCase
- include REXMLTestUtils
- include REXML
- SOURCE = <<-EOF
- <a id='1'>
- <b id='2' x='y'>
- <c id='3'/>
- <c id='4'/>
+ class TestXPathBase < Test::Unit::TestCase
+ include REXMLTestUtils
+ include REXML
+ SOURCE = <<-EOF
+ <a id='1'>
+ <b id='2' x='y'>
+ <c id='3'/>
+ <c id='4'/>
+ </b>
+ <d id='5'>
+ <c id='6' x='y'/>
+ <c id='7'/>
+ <c id='8'/>
+ <q id='19'/>
+ </d>
+ <e id='9'>
+ <f id='10' a='b'/>
+ <f id='11' a='c'/>
+ <f id='12' a='d'>
+ <g id='13'/>
+ </f>
+ <f id='14' a='d'/>
+ </e>
+ <m id='15'>
+ <n id='16'>
+ <o id='17'>
+ <p id='18'/>
+ </o>
+ </n>
+ </m>
+ </a>
+ EOF
+ JENI_TENNISON = <<-EOJT
+ <a>
+ <b>
+ <c>
+ <d>
+ <e id='x'>
+ <f/>
+ </e>
+ </d>
+ </c>
+ <c>
+ <d>
+ <e id='y'/>
+ </d>
+ </c>
+ </b>
+ <b>
+ <c>
+ <d>
+ <e id='z'/>
+ </d>
+ </c>
</b>
- <d id='5'>
- <c id='6' x='y'/>
- <c id='7'/>
- <c id='8'/>
- <q id='19'/>
- </d>
- <e id='9'>
- <f id='10' a='b'/>
- <f id='11' a='c'/>
- <f id='12' a='d'>
- <g id='13'/>
- </f>
- <f id='14' a='d'/>
- </e>
- <m id='15'>
- <n id='16'>
- <o id='17'>
- <p id='18'/>
- </o>
- </n>
- </m>
</a>
- EOF
- JENI_TENNISON = <<-EOJT
- <a>
- <b>
- <c>
- <d>
- <e id='x'>
- <f/>
- </e>
- </d>
- </c>
- <c>
- <d>
- <e id='y'/>
- </d>
- </c>
- </b>
- <b>
- <c>
- <d>
- <e id='z'/>
- </d>
- </c>
- </b>
- </a>
- EOJT
-
- def setup
- @@doc = Document.new(SOURCE) unless defined? @@doc
- @@jeni = Document.new( JENI_TENNISON ) unless defined? @@jeni
- end
+ EOJT
- def each_test( element, xpath )
- count = 0
- XPath::each( element, xpath ) { |child|
- count += 1
- yield child if block_given?
- }
- count
- end
+ def setup
+ @@doc = Document.new(SOURCE) unless defined? @@doc
+ @@jeni = Document.new( JENI_TENNISON ) unless defined? @@jeni
+ end
- def test_descendant
- doc = Document.new("<a><b><c id='1'/></b><d><b><c id='2'/></b></d></a>")
- p = XPath.match( doc, "//c" )
- assert_equal( 2, p.size )
- p = XPath.first( @@doc, "//p" )
- assert_equal "p", p.name
- c = each_test( @@doc, "//c" ) { |child| assert_equal "c", child.name }
- assert_equal 5, c
- c = each_test( @@doc.root, "b//c" ) { |child|
- assert_equal "c", child.name
- }
- assert_equal 2, c
-
- doc = Document.new( "<a><z id='1'/><b><z id='11'/><z id='12'/></b><c><z id='21'/><z id='22'/><d><z id='31'/><z id='32'/></d></c></a>" )
- # //para[1] : all descendants which are the first para child of their parent
- assert_equal( 4, XPath.match( doc, "//z[1]" ).size )
- # /descendant::para[1] : the first descendant para element
- assert_equal( 1, XPath.match( doc, "/descendant::z[1]" ).size )
- end
+ def each_test( element, xpath )
+ count = 0
+ XPath::each( element, xpath ) { |child|
+ count += 1
+ yield child if block_given?
+ }
+ count
+ end
- def test_root
- source = "<a><b/></a>"
- doc = Document.new( source )
- assert_equal doc, doc.root_node
- assert_equal "a", XPath::first( doc, "/" ).elements[1].name
- end
+ def test_descendant
+ doc = Document.new("<a><b><c id='1'/></b><d><b><c id='2'/></b></d></a>")
+ p = XPath.match( doc, "//c" )
+ assert_equal( 2, p.size )
+ p = XPath.first( @@doc, "//p" )
+ assert_equal "p", p.name
+ c = each_test( @@doc, "//c" ) { |child| assert_equal "c", child.name }
+ assert_equal 5, c
+ c = each_test( @@doc.root, "b//c" ) { |child|
+ assert_equal "c", child.name
+ }
+ assert_equal 2, c
- def test_abbreviated_simple_child
- assert_equal "a", XPath::first(@@doc, "a").name
- end
+ doc = Document.new( "<a><z id='1'/><b><z id='11'/><z id='12'/></b><c><z id='21'/><z id='22'/><d><z id='31'/><z id='32'/></d></c></a>" )
+ # //para[1] : all descendants which are the first para child of their parent
+ assert_equal( 4, XPath.match( doc, "//z[1]" ).size )
+ # /descendant::para[1] : the first descendant para element
+ assert_equal( 1, XPath.match( doc, "/descendant::z[1]" ).size )
+ end
- def test_child
- c = XPath::first( @@doc, "a/b/c" )
- assert_equal "c", c.name
- assert_equal "3", XPath::first(@@doc, "a/b/c").attributes["id"]
- end
+ def test_root
+ source = "<a><b/></a>"
+ doc = Document.new( source )
+ assert_equal doc, doc.root_node
+ assert_equal "a", XPath::first( doc, "/" ).elements[1].name
+ end
- def test_root_child
- assert_equal "a", XPath::first(@@doc, "/a").name
- c = XPath::first( @@doc, "a/b/c" )
- assert_equal "a", XPath::first(c, "/a").name
- end
+ def test_abbreviated_simple_child
+ assert_equal "a", XPath::first(@@doc, "a").name
+ end
- def test_root_children
- c = XPath::first( @@doc, "a/b/c" )
- assert_equal "2", XPath::first(c, "/a/b").attributes["id"]
- end
+ def test_child
+ c = XPath::first( @@doc, "a/b/c" )
+ assert_equal "c", c.name
+ assert_equal "3", XPath::first(@@doc, "a/b/c").attributes["id"]
+ end
- def test_abbreviated_step
- c = XPath::first( @@doc, "a/b/c" )
- assert_equal("c", c.name)
- assert_equal("a", XPath::first(@@doc.root, ".").name)
- assert_equal("b", XPath::first(c, "..").name)
- assert_equal("a", XPath::first(@@doc, "a/b/..").name)
-
- doc = REXML::Document.new(File.new(fixture_path("project.xml")))
- c = each_test(doc.root, "./Description" ) { |child|
- assert_equal("Description",child.name)
- }
- assert_equal 1, c
- end
+ def test_root_child
+ assert_equal "a", XPath::first(@@doc, "/a").name
+ c = XPath::first( @@doc, "a/b/c" )
+ assert_equal "a", XPath::first(c, "/a").name
+ end
- # Things that aren't tested elsewhere
- def test_predicates
- assert_equal "12", XPath::first(@@doc, "a/e/f[3]").attributes["id"]
- assert_equal "13", XPath::first(@@doc, "a/e/f[3]/g").attributes["id"]
- assert_equal "14", XPath::first(@@doc, "a/e/f[@a='d'][2]").attributes["id"]
- assert_equal "14", XPath::first(@@doc, "a/e/f[@a='d'][@id='14']").attributes["id"]
- assert_equal "a", XPath::first( @@doc, "*[name()='a' and @id='1']" ).name
- c=each_test( @@doc, "//*[name()='f' and @a='d']") { |i|
- assert_equal "f", i.name
- }
- assert_equal 2, c
- c=each_test( @@doc, "//*[name()='m' or @a='d']") { |i|
- assert ["m","f"].include?(i.name)
- }
- assert_equal 3, c
-
- assert_equal "b", XPath::first( @@doc, "//b[@x]" ).name
- end
+ def test_root_children
+ c = XPath::first( @@doc, "a/b/c" )
+ assert_equal "2", XPath::first(c, "/a/b").attributes["id"]
+ end
- def test_node_type
- doc = Document.new "<a><?foo bar?><!--comment-->text</a>"
- #res = XPath::first(doc.root, "text()")
- #assert_equal "text", res.to_s
+ def test_abbreviated_step
+ c = XPath::first( @@doc, "a/b/c" )
+ assert_equal("c", c.name)
+ assert_equal("a", XPath::first(@@doc.root, ".").name)
+ assert_equal("b", XPath::first(c, "..").name)
+ assert_equal("a", XPath::first(@@doc, "a/b/..").name)
- #res = XPath::first(doc, "*")
- #assert_equal "a", res.name
+ doc = REXML::Document.new(File.new(fixture_path("project.xml")))
+ c = each_test(doc.root, "./Description" ) { |child|
+ assert_equal("Description",child.name)
+ }
+ assert_equal 1, c
+ end
- assert_equal( :processing_instruction,
- XPath::first(doc.root, "processing-instruction()").node_type)
- assert_equal( :comment, XPath::first(doc.root, "comment()").node_type)
- end
+ # Things that aren't tested elsewhere
+ def test_predicates
+ assert_equal "12", XPath::first(@@doc, "a/e/f[3]").attributes["id"]
+ assert_equal "13", XPath::first(@@doc, "a/e/f[3]/g").attributes["id"]
+ assert_equal "14", XPath::first(@@doc, "a/e/f[@a='d'][2]").attributes["id"]
+ assert_equal "14", XPath::first(@@doc, "a/e/f[@a='d'][@id='14']").attributes["id"]
+ assert_equal "a", XPath::first( @@doc, "*[name()='a' and @id='1']" ).name
+ c=each_test( @@doc, "//*[name()='f' and @a='d']") { |i|
+ assert_equal "f", i.name
+ }
+ assert_equal 2, c
+ c=each_test( @@doc, "//*[name()='m' or @a='d']") { |i|
+ assert ["m","f"].include?(i.name)
+ }
+ assert_equal 3, c
- def test_functions
- # trivial text() test
- # confuse-a-function
- source = "<a>more <b id='1'/><b id='2'>dumb</b><b id='3'/><c/> text</a>"
- doc = Document.new source
- res = ""
- #XPath::each(doc.root, "text()") {|val| res << val.to_s}
- #assert_equal "more text", res
-
- #res = XPath::first(doc.root, "b[last()]")
- #assert_equal '3', res.attributes['id']
- res = XPath::first(doc.root, "b[position()=2]")
- assert_equal '2', res.attributes['id']
- res = XPath::first(doc.root, "*[name()='c']")
- assert_equal "c", res.name
- end
+ assert_equal "b", XPath::first( @@doc, "//b[@x]" ).name
+ end
- def no_test_ancestor
- doc = REXML::Document.new(File.new(fixture_path("testsrc.xml")))
- doc.elements.each("//item") { |el| print el.name
- if el.attributes['x']
- puts " -- "+el.attributes['x']
- else
- puts
- end
- }
- doc.elements.each("//item/ancestor::") { |el| print el.name
- if el.attributes['x']
- puts " -- "+el.attributes['x']
- else
- puts
- end
- }
- end
+ def test_node_type
+ doc = Document.new "<a><?foo bar?><!--comment-->text</a>"
+ #res = XPath::first(doc.root, "text()")
+ #assert_equal "text", res.to_s
+
+ #res = XPath::first(doc, "*")
+ #assert_equal "a", res.name
+
+ assert_equal( :processing_instruction,
+ XPath::first(doc.root, "processing-instruction()").node_type)
+ assert_equal( :comment, XPath::first(doc.root, "comment()").node_type)
+ end
+
+ def test_functions
+ # trivial text() test
+ # confuse-a-function
+ source = "<a>more <b id='1'/><b id='2'>dumb</b><b id='3'/><c/> text</a>"
+ doc = Document.new source
+ res = ""
+ #XPath::each(doc.root, "text()") {|val| res << val.to_s}
+ #assert_equal "more text", res
+
+ #res = XPath::first(doc.root, "b[last()]")
+ #assert_equal '3', res.attributes['id']
+ res = XPath::first(doc.root, "b[position()=2]")
+ assert_equal '2', res.attributes['id']
+ res = XPath::first(doc.root, "*[name()='c']")
+ assert_equal "c", res.name
+ end
+
+ def no_test_ancestor
+ doc = REXML::Document.new(File.new(fixture_path("testsrc.xml")))
+ doc.elements.each("//item") { |el| print el.name
+ if el.attributes['x']
+ puts " -- "+el.attributes['x']
+ else
+ puts
+ end
+ }
+ doc.elements.each("//item/ancestor::") { |el| print el.name
+ if el.attributes['x']
+ puts " -- "+el.attributes['x']
+ else
+ puts
+ end
+ }
+ end
- # Here are some XPath tests that were originally submitted by ...
- # The code has changed some, but the logic and the source documents are the
- # same.
- # This method reads a document from a file, and then a series of xpaths,
- # also from a file. It then checks each xpath against the source file.
- def test_more
- xmlsource = fixture_path("testsrc.xml")
- xpathtests = fixture_path("xp.tst")
-
- doc = REXML::Document.new(File.new(xmlsource))
- #results = ""
- results = REXML::Document.new
- results.add_element "test-results"
- for line in File.new(xpathtests)
- line.strip!
- begin
- doc.root
- #puts "#"*80
- #print "\nDoing #{line} " ; $stdout.flush
- doc.elements.each(line) do |el|
- #print "." ; $stdout.flush
- results.root << el.clone
- #results << el.to_s
+ # Here are some XPath tests that were originally submitted by ...
+ # The code has changed some, but the logic and the source documents are the
+ # same.
+ # This method reads a document from a file, and then a series of xpaths,
+ # also from a file. It then checks each xpath against the source file.
+ def test_more
+ xmlsource = fixture_path("testsrc.xml")
+ xpathtests = fixture_path("xp.tst")
+
+ doc = REXML::Document.new(File.new(xmlsource))
+ #results = ""
+ results = REXML::Document.new
+ results.add_element "test-results"
+ for line in File.new(xpathtests)
+ line.strip!
+ begin
+ doc.root
+ #puts "#"*80
+ #print "\nDoing #{line} " ; $stdout.flush
+ doc.elements.each(line) do |el|
+ #print "." ; $stdout.flush
+ results.root << el.clone
+ #results << el.to_s
+ end
+ #ObjectSpace.garbage_collect
+ GC::start
+ rescue Exception => z
+ #puts "\n'#{line}' failed"
+ fail("Error on line #{line}:\n#{z.message}\n"+z.backtrace[0,10].join("\n"))
+ #results.root.add_element( "error", {"path"=>line}).text = z.message+"\n"+z.backtrace[0,10].join("\n")
+ #results << "<error path='"+line+"'>"+z.message+"</error>"
end
- #ObjectSpace.garbage_collect
- GC::start
- rescue Exception => z
- #puts "\n'#{line}' failed"
- fail("Error on line #{line}:\n#{z.message}\n"+z.backtrace[0,10].join("\n"))
- #results.root.add_element( "error", {"path"=>line}).text = z.message+"\n"+z.backtrace[0,10].join("\n")
- #results << "<error path='"+line+"'>"+z.message+"</error>"
end
end
- end
- def test_axe_descendant
- assert_equal "f", XPath::first( @@doc, "descendant::f").name
- end
+ def test_axe_descendant
+ assert_equal "f", XPath::first( @@doc, "descendant::f").name
+ end
- def test_axe_parent
- q = XPath.first( @@doc, "a/d/c/parent::*/q" )
- assert_equal 19, q.attributes["id"].to_i
- end
+ def test_axe_parent
+ q = XPath.first( @@doc, "a/d/c/parent::*/q" )
+ assert_equal 19, q.attributes["id"].to_i
+ end
- def test_abbreviated_attribute
- assert_equal 'a', XPath::first( @@doc, "a[@id='1']" ).name
- c = XPath::first( @@doc, "a/b/c[@id='4']" )
- assert_equal 'c', c.name
- assert_equal '4', c.attributes['id']
+ def test_abbreviated_attribute
+ assert_equal 'a', XPath::first( @@doc, "a[@id='1']" ).name
+ c = XPath::first( @@doc, "a/b/c[@id='4']" )
+ assert_equal 'c', c.name
+ assert_equal '4', c.attributes['id']
- result = XPath::first( @@doc, "descendant::f[@a='c']")
- assert_equal "11", result.attributes['id']
+ result = XPath::first( @@doc, "descendant::f[@a='c']")
+ assert_equal "11", result.attributes['id']
- assert_equal "11", XPath::first(@@doc, "a/e/f[@a='c']").attributes["id"]
- assert_equal "11", XPath::first(@@doc, "a/e/*[@a='c']").attributes["id"]
- end
+ assert_equal "11", XPath::first(@@doc, "a/e/f[@a='c']").attributes["id"]
+ assert_equal "11", XPath::first(@@doc, "a/e/*[@a='c']").attributes["id"]
+ end
- def test_axe_self
- c = XPath::first( @@doc, "a/b/c" )
- assert c
- assert_equal "c", c.name
- assert_equal "c", XPath::first( c, "self::node()" ).name
- end
+ def test_axe_self
+ c = XPath::first( @@doc, "a/b/c" )
+ assert c
+ assert_equal "c", c.name
+ assert_equal "c", XPath::first( c, "self::node()" ).name
+ end
- def test_axe_ancestor
- doc = REXML::Document.new "
- <a>
- <b id='1'>
- <c>
- <b id='2'>
- <d/>
- </b>
- </c>
- </b>
- </a>"
+ def test_axe_ancestor
+ doc = REXML::Document.new "
+ <a>
+ <b id='1'>
+ <c>
+ <b id='2'>
+ <d/>
+ </b>
+ </c>
+ </b>
+ </a>"
+
+ d = XPath.first( doc, "//d" )
+ assert_equal "d", d.name
+ b = each_test( d, "ancestor::b" ) { |el|
+ assert((1..2) === el.attributes['id'].to_i,
+ "Expected #{el.attributes['id']} to be either 1 or 2"
+ )
+ }
+ assert_equal 2, b
+ end
- d = XPath.first( doc, "//d" )
- assert_equal "d", d.name
- b = each_test( d, "ancestor::b" ) { |el|
- assert((1..2) === el.attributes['id'].to_i,
- "Expected #{el.attributes['id']} to be either 1 or 2"
- )
- }
- assert_equal 2, b
- end
+ def test_axe_child
+ m = XPath.first( @@doc, "a/child::m" )
+ assert_equal 15, m.attributes['id'].to_i
+ end
- def test_axe_child
- m = XPath.first( @@doc, "a/child::m" )
- assert_equal 15, m.attributes['id'].to_i
- end
+ def test_axe_attribute
+ a = XPath.first( @@doc, "a/attribute::id" )
+ assert_equal "1", a.value
+ a = XPath.first( @@doc, "a/e/f[@id='14']/attribute::a" )
+ assert_equal "d", a.value
+ end
- def test_axe_attribute
- a = XPath.first( @@doc, "a/attribute::id" )
- assert_equal "1", a.value
- a = XPath.first( @@doc, "a/e/f[@id='14']/attribute::a" )
- assert_equal "d", a.value
- end
+ def test_axe_sibling
+ doc = Document.new "<a><b><c/></b><e><f id='10'/><f id='11'/><f id='12'/></e></a>"
+ first_f = XPath.first( doc, "a/e/f" )
+ assert first_f
+ assert_equal '10', first_f.attributes['id']
+ next_f = XPath.first( doc, "a/e/f/following-sibling::node()" )
+ assert_equal '11', next_f.attributes['id']
- def test_axe_sibling
- doc = Document.new "<a><b><c/></b><e><f id='10'/><f id='11'/><f id='12'/></e></a>"
- first_f = XPath.first( doc, "a/e/f" )
- assert first_f
- assert_equal '10', first_f.attributes['id']
- next_f = XPath.first( doc, "a/e/f/following-sibling::node()" )
- assert_equal '11', next_f.attributes['id']
+ b = XPath.first( doc, "a/e/preceding-sibling::node()" )
+ assert_equal 'b', b.name
+ end
- b = XPath.first( doc, "a/e/preceding-sibling::node()" )
- assert_equal 'b', b.name
- end
+ def test_lang
+ doc = Document.new(File.new(fixture_path("lang0.xml")))
+ #puts IO.read( "test/lang.xml" )
- def test_lang
- doc = Document.new(File.new(fixture_path("lang0.xml")))
- #puts IO.read( "test/lang.xml" )
+ #puts XPath.match( doc, "//language/*" ).size
+ c = each_test( doc, "//language/*" ) { |element|
+ #puts "#{element.name}: #{element.text}"
+ }
+ assert_equal 4, c
+ end
- #puts XPath.match( doc, "//language/*" ).size
- c = each_test( doc, "//language/*" ) { |element|
- #puts "#{element.name}: #{element.text}"
- }
- assert_equal 4, c
- end
+ def test_namespaces_1
+ source = <<-EOF
+ <foo xmlns:ts="this" xmlns:tt="that">
+ <ts:bar>this bar</ts:bar>
+ <tt:bar>that bar</tt:bar>
+ </foo>
+ EOF
+ doc = Document.new source
+ XPath.each( doc, "//bar" ) {
+ fail "'bar' should match nothing in this case"
+ }
- def test_namespaces_1
- source = <<-EOF
- <foo xmlns:ts="this" xmlns:tt="that">
- <ts:bar>this bar</ts:bar>
- <tt:bar>that bar</tt:bar>
- </foo>
- EOF
- doc = Document.new source
- XPath.each( doc, "//bar" ) {
- fail "'bar' should match nothing in this case"
- }
-
- namespace = {"t"=>"this"}
- results = XPath.first( doc, "//t:bar", namespace )
- assert_equal "this bar", results.text
- end
+ namespace = {"t"=>"this"}
+ results = XPath.first( doc, "//t:bar", namespace )
+ assert_equal "this bar", results.text
+ end
- def test_namespaces_2
- source = <<-EOF
- <foo xmlns:ts="this" xmlns:tt="that">
- <ts:bar>this bar</ts:bar>
- <tt:bar>that bar</tt:bar>
- </foo>
- EOF
- doc = Document.new source
- res = XPath::first(doc, "//*[local_name()='bar']")
- assert res, "looking for //*[name()='bar']"
- assert_equal 'this', res.namespace
- res = XPath::first(doc.root, "*[namespace_uri()='that']")
- assert_equal 'that bar', res.text
- end
+ def test_namespaces_2
+ source = <<-EOF
+ <foo xmlns:ts="this" xmlns:tt="that">
+ <ts:bar>this bar</ts:bar>
+ <tt:bar>that bar</tt:bar>
+ </foo>
+ EOF
+ doc = Document.new source
+ res = XPath::first(doc, "//*[local_name()='bar']")
+ assert res, "looking for //*[name()='bar']"
+ assert_equal 'this', res.namespace
+ res = XPath::first(doc.root, "*[namespace_uri()='that']")
+ assert_equal 'that bar', res.text
+ end
- def test_complex
- next_f = XPath.first( @@doc, "a/e/f[@id='11']/following-sibling::*" )
- assert_equal 12, next_f.attributes['id'].to_i
- prev_f = XPath.first( @@doc, "a/e/f[@id='11']/preceding-sibling::*" )
- assert_equal 10, prev_f.attributes['id'].to_i
- c = each_test( @@doc, "descendant-or-self::*[@x='y']" )
- assert_equal 2, c
- end
+ def test_complex
+ next_f = XPath.first( @@doc, "a/e/f[@id='11']/following-sibling::*" )
+ assert_equal 12, next_f.attributes['id'].to_i
+ prev_f = XPath.first( @@doc, "a/e/f[@id='11']/preceding-sibling::*" )
+ assert_equal 10, prev_f.attributes['id'].to_i
+ c = each_test( @@doc, "descendant-or-self::*[@x='y']" )
+ assert_equal 2, c
+ end
- def test_grouping
- t = XPath.first( @@doc, "a/d/*[name()='d' and (name()='f' or name()='q')]" )
- assert_nil t
- t = XPath.first( @@doc, "a/d/*[(name()='d' and name()='f') or name()='q']" )
- assert_equal 'q', t.name
- end
+ def test_grouping
+ t = XPath.first( @@doc, "a/d/*[name()='d' and (name()='f' or name()='q')]" )
+ assert_nil t
+ t = XPath.first( @@doc, "a/d/*[(name()='d' and name()='f') or name()='q']" )
+ assert_equal 'q', t.name
+ end
- def test_preceding
- d = Document.new "<a><b id='0'/><b id='2'/><b><c id='0'/><c id='1'/><c id='2'/></b><b id='1'/></a>"
- start = XPath.first( d, "/a/b[@id='1']" )
- assert_equal 'b', start.name
- c = XPath.first( start, "preceding::c" )
- assert_equal '2', c.attributes['id']
-
- c1, c0 = XPath.match( d, "/a/b/c[@id='2']/preceding::node()" )
- assert_equal '1', c1.attributes['id']
- assert_equal '0', c0.attributes['id']
-
- c2, c1, c0, b, b2, b0 = XPath.match( start, "preceding::node()" )
-
- assert_equal 'c', c2.name
- assert_equal 'c', c1.name
- assert_equal 'c', c0.name
- assert_equal 'b', b.name
- assert_equal 'b', b2.name
- assert_equal 'b', b0.name
-
- assert_equal '2', c2.attributes['id']
- assert_equal '1', c1.attributes['id']
- assert_equal '0', c0.attributes['id']
- assert b.attributes.empty?
- assert_equal '2', b2.attributes['id']
- assert_equal '0', b0.attributes['id']
-
- d = REXML::Document.new("<a><b/><c/><d/></a>")
- matches = REXML::XPath.match(d, "/a/d/preceding::node()")
- assert_equal("c", matches[0].name)
- assert_equal("b", matches[1].name)
-
- s = "<a><b><c id='1'/></b><b><b><c id='2'/><c id='3'/></b><c id='4'/></b><c id='NOMATCH'><c id='5'/></c></a>"
- d = REXML::Document.new(s)
- c = REXML::XPath.match( d, "//c[@id = '5']")
- cs = REXML::XPath.match( c, "preceding::c" )
- assert_equal( 4, cs.length )
- end
+ def test_preceding
+ d = Document.new "<a><b id='0'/><b id='2'/><b><c id='0'/><c id='1'/><c id='2'/></b><b id='1'/></a>"
+ start = XPath.first( d, "/a/b[@id='1']" )
+ assert_equal 'b', start.name
+ c = XPath.first( start, "preceding::c" )
+ assert_equal '2', c.attributes['id']
+
+ c1, c0 = XPath.match( d, "/a/b/c[@id='2']/preceding::node()" )
+ assert_equal '1', c1.attributes['id']
+ assert_equal '0', c0.attributes['id']
+
+ c2, c1, c0, b, b2, b0 = XPath.match( start, "preceding::node()" )
+
+ assert_equal 'c', c2.name
+ assert_equal 'c', c1.name
+ assert_equal 'c', c0.name
+ assert_equal 'b', b.name
+ assert_equal 'b', b2.name
+ assert_equal 'b', b0.name
+
+ assert_equal '2', c2.attributes['id']
+ assert_equal '1', c1.attributes['id']
+ assert_equal '0', c0.attributes['id']
+ assert b.attributes.empty?
+ assert_equal '2', b2.attributes['id']
+ assert_equal '0', b0.attributes['id']
+
+ d = REXML::Document.new("<a><b/><c/><d/></a>")
+ matches = REXML::XPath.match(d, "/a/d/preceding::node()")
+ assert_equal("c", matches[0].name)
+ assert_equal("b", matches[1].name)
+
+ s = "<a><b><c id='1'/></b><b><b><c id='2'/><c id='3'/></b><c id='4'/></b><c id='NOMATCH'><c id='5'/></c></a>"
+ d = REXML::Document.new(s)
+ c = REXML::XPath.match( d, "//c[@id = '5']")
+ cs = REXML::XPath.match( c, "preceding::c" )
+ assert_equal( 4, cs.length )
+ end
- def test_following
- d = Document.new "<a><b id='0'/><b/><b><c id='1'/><c id='2'/></b><b id='1'/></a>"
- start = XPath.first( d, "/a/b[@id='0']" )
- assert_equal 'b', start.name
- c = XPath.first( start, "following::c" )
- assert_equal '1', c.attributes['id']
-
- s = "<a><b><c><d/></c><e/></b><f><g><h/><i/></g></f><i/></a>"
- d = Document.new(s)
- c = XPath.first(d, '/a/b/c')
- assert_equal 'c', c.name
- res = XPath.match( c, 'following::*' )
- assert_equal 6, res.size
- res = XPath.match( c, 'following::i' )
- assert_equal 2, res.size
- end
+ def test_following
+ d = Document.new "<a><b id='0'/><b/><b><c id='1'/><c id='2'/></b><b id='1'/></a>"
+ start = XPath.first( d, "/a/b[@id='0']" )
+ assert_equal 'b', start.name
+ c = XPath.first( start, "following::c" )
+ assert_equal '1', c.attributes['id']
+
+ s = "<a><b><c><d/></c><e/></b><f><g><h/><i/></g></f><i/></a>"
+ d = Document.new(s)
+ c = XPath.first(d, '/a/b/c')
+ assert_equal 'c', c.name
+ res = XPath.match( c, 'following::*' )
+ assert_equal 6, res.size
+ res = XPath.match( c, 'following::i' )
+ assert_equal 2, res.size
+ end
- # The following three paths were provided by
- # Jeni Tennison <jeni@jenitennison.com>
- # a consultant who is also an XSL and XPath expert
- #def test_child_cubed
- # els = @@jeni.elements.to_a("*****")
- # assert_equal 3, els.size
- #end
-
- #def test_div_2
- # results = doc.elements.to_a("/ div 2")
- #end
-
- #def test_nested_predicates
- # puts @@jeni.root.elements[1].elements[1].name
- # results = @@jeni.root.elements[1].elements[1].elements.to_a("../following-sibling::*[*[name() = name(current())]]")
- # puts results
- #end
-
- # Contributed by Mike Stok
- def test_starts_with
- source = <<-EOF
- <foo>
- <a href="mailto:a@b.c">a@b.c</a>
- <a href="http://www.foo.com">http://www.foo.com</a>
- </foo>
- EOF
- doc = Document.new source
- mailtos = doc.elements.to_a("//a[starts-with(@href, 'mailto:')]")
- assert_equal 1, mailtos.size
- assert_equal "mailto:a@b.c", mailtos[0].attributes['href']
-
- ailtos = doc.elements.to_a("//a[starts-with(@href, 'ailto:')]")
- assert_equal 0, ailtos.size
- end
+ # The following three paths were provided by
+ # Jeni Tennison <jeni@jenitennison.com>
+ # a consultant who is also an XSL and XPath expert
+ #def test_child_cubed
+ # els = @@jeni.elements.to_a("*****")
+ # assert_equal 3, els.size
+ #end
+
+ #def test_div_2
+ # results = doc.elements.to_a("/ div 2")
+ #end
+
+ #def test_nested_predicates
+ # puts @@jeni.root.elements[1].elements[1].name
+ # results = @@jeni.root.elements[1].elements[1].elements.to_a("../following-sibling::*[*[name() = name(current())]]")
+ # puts results
+ #end
+
+ # Contributed by Mike Stok
+ def test_starts_with
+ source = <<-EOF
+ <foo>
+ <a href="mailto:a@b.c">a@b.c</a>
+ <a href="http://www.foo.com">http://www.foo.com</a>
+ </foo>
+ EOF
+ doc = Document.new source
+ mailtos = doc.elements.to_a("//a[starts-with(@href, 'mailto:')]")
+ assert_equal 1, mailtos.size
+ assert_equal "mailto:a@b.c", mailtos[0].attributes['href']
+
+ ailtos = doc.elements.to_a("//a[starts-with(@href, 'ailto:')]")
+ assert_equal 0, ailtos.size
+ end
- def test_toms_text_node
- file = "<a>A<b>B</b><c>C<d>D</d>E</c>F</a>"
- doc = Document.new(file)
- assert_equal 'A', XPath.first(doc[0], 'text()').to_s
- assert_equal 'AF', XPath.match(doc[0], 'text()').collect { |n|
- n.to_s
- }.join('')
- assert_equal 'B', XPath.first(doc[0], 'b/text()').to_s
- assert_equal 'D', XPath.first(doc[0], '//d/text()').to_s
- assert_equal 'ABCDEF', XPath.match(doc[0], '//text()').collect {|n|
- n.to_s
- }.join('')
- end
+ def test_toms_text_node
+ file = "<a>A<b>B</b><c>C<d>D</d>E</c>F</a>"
+ doc = Document.new(file)
+ assert_equal 'A', XPath.first(doc[0], 'text()').to_s
+ assert_equal 'AF', XPath.match(doc[0], 'text()').collect { |n|
+ n.to_s
+ }.join('')
+ assert_equal 'B', XPath.first(doc[0], 'b/text()').to_s
+ assert_equal 'D', XPath.first(doc[0], '//d/text()').to_s
+ assert_equal 'ABCDEF', XPath.match(doc[0], '//text()').collect {|n|
+ n.to_s
+ }.join('')
+ end
- def test_string_length
- doc = Document.new <<-EOF
- <AAA>
- <Q/>
- <SSSS/>
- <BB/>
- <CCC/>
- <DDDDDDDD/>
- <EEEE/>
- </AAA>
- EOF
- assert doc, "create doc"
-
- set = doc.elements.to_a("//*[string-length(name()) = 3]")
- assert_equal 2, set.size, "nodes with names length = 3"
-
- set = doc.elements.to_a("//*[string-length(name()) < 3]")
- assert_equal 2, set.size, "nodes with names length < 3"
-
- set = doc.elements.to_a("//*[string-length(name()) > 3]")
- assert_equal 3, set.size, "nodes with names length > 3"
- end
+ def test_string_length
+ doc = Document.new <<-EOF
+ <AAA>
+ <Q/>
+ <SSSS/>
+ <BB/>
+ <CCC/>
+ <DDDDDDDD/>
+ <EEEE/>
+ </AAA>
+ EOF
+ assert doc, "create doc"
+
+ set = doc.elements.to_a("//*[string-length(name()) = 3]")
+ assert_equal 2, set.size, "nodes with names length = 3"
+
+ set = doc.elements.to_a("//*[string-length(name()) < 3]")
+ assert_equal 2, set.size, "nodes with names length < 3"
+
+ set = doc.elements.to_a("//*[string-length(name()) > 3]")
+ assert_equal 3, set.size, "nodes with names length > 3"
+ end
- # Test provided by Mike Stok
- def test_contains
- source = <<-EOF
- <foo>
- <a href="mailto:a@b.c">a@b.c</a>
- <a href="http://www.foo.com">http://www.foo.com</a>
- </foo>
- EOF
- doc = Document.new source
-
- [
- #['o', 2],
- ['foo', 1], ['bar', 0]].each { |search, expected|
- set = doc.elements.to_a("//a[contains(@href, '#{search}')]")
- assert_equal expected, set.size
- }
- end
+ # Test provided by Mike Stok
+ def test_contains
+ source = <<-EOF
+ <foo>
+ <a href="mailto:a@b.c">a@b.c</a>
+ <a href="http://www.foo.com">http://www.foo.com</a>
+ </foo>
+ EOF
+ doc = Document.new source
+
+ [
+ #['o', 2],
+ ['foo', 1], ['bar', 0]].each { |search, expected|
+ set = doc.elements.to_a("//a[contains(@href, '#{search}')]")
+ assert_equal expected, set.size
+ }
+ end
- # Mike Stok and Sean Russell
- def test_substring
- # examples from http://www.w3.org/TR/xpath#function-substring
- doc = Document.new('<test string="12345" />')
-
- Document.new("<a b='1'/>")
- #puts XPath.first(d, 'node()[0 + 1]')
- #d = Document.new("<a b='1'/>")
- #puts XPath.first(d, 'a[0 mod 0]')
- [ [1.5, 2.6, '234'],
- [0, 3, '12'],
- [0, '0 div 0', ''],
- [1, '0 div 0', ''],
- ['-42', '1 div 0', '12345'],
- ['-1 div 0', '1 div 0', '']
- ].each { |start, length, expected|
- set = doc.elements.to_a("//test[substring(@string, #{start}, #{length}) = '#{expected}']")
- assert_equal 1, set.size, "#{start}, #{length}, '#{expected}'"
- }
- end
+ # Mike Stok and Sean Russell
+ def test_substring
+ # examples from http://www.w3.org/TR/xpath#function-substring
+ doc = Document.new('<test string="12345" />')
+
+ Document.new("<a b='1'/>")
+ #puts XPath.first(d, 'node()[0 + 1]')
+ #d = Document.new("<a b='1'/>")
+ #puts XPath.first(d, 'a[0 mod 0]')
+ [ [1.5, 2.6, '234'],
+ [0, 3, '12'],
+ [0, '0 div 0', ''],
+ [1, '0 div 0', ''],
+ ['-42', '1 div 0', '12345'],
+ ['-1 div 0', '1 div 0', '']
+ ].each { |start, length, expected|
+ set = doc.elements.to_a("//test[substring(@string, #{start}, #{length}) = '#{expected}']")
+ assert_equal 1, set.size, "#{start}, #{length}, '#{expected}'"
+ }
+ end
- def test_translate
- source = <<-EOF
- <doc>
- <case name='w3c one' result='BAr' /> <!-- w3c -->
- <case name='w3c two' result='AAA' /> <!-- w3c -->
- <case name='alchemy' result="gold" /> <!-- mike -->
- <case name='vbxml one' result='A Space Odyssey' />
- <case name='vbxml two' result='AbCdEf' />
- </doc>
- EOF
-
- doc = Document.new(source)
-
- [ ['bar', 'abc', 'ABC', 'w3c one'],
- ['--aaa--','abc-','ABC', 'w3c two'],
- ['lead', 'dear language', 'doll groover', 'alchemy'],
- ['A Space Odissei', 'i', 'y', 'vbxml one'],
- ['abcdefg', 'aceg', 'ACE', 'vbxml two'],
- ].each { |arg1, arg2, arg3, name|
- translate = "translate('#{arg1}', '#{arg2}', '#{arg3}')"
- set = doc.elements.to_a("//case[@result = #{translate}]")
- assert_equal 1, set.size, translate
- assert_equal name, set[0].attributes['name']
- }
- end
+ def test_translate
+ source = <<-EOF
+ <doc>
+ <case name='w3c one' result='BAr' /> <!-- w3c -->
+ <case name='w3c two' result='AAA' /> <!-- w3c -->
+ <case name='alchemy' result="gold" /> <!-- mike -->
+ <case name='vbxml one' result='A Space Odyssey' />
+ <case name='vbxml two' result='AbCdEf' />
+ </doc>
+ EOF
+
+ doc = Document.new(source)
+
+ [ ['bar', 'abc', 'ABC', 'w3c one'],
+ ['--aaa--','abc-','ABC', 'w3c two'],
+ ['lead', 'dear language', 'doll groover', 'alchemy'],
+ ['A Space Odissei', 'i', 'y', 'vbxml one'],
+ ['abcdefg', 'aceg', 'ACE', 'vbxml two'],
+ ].each { |arg1, arg2, arg3, name|
+ translate = "translate('#{arg1}', '#{arg2}', '#{arg3}')"
+ set = doc.elements.to_a("//case[@result = #{translate}]")
+ assert_equal 1, set.size, translate
+ assert_equal name, set[0].attributes['name']
+ }
+ end
- def test_math
- d = Document.new( '<a><b/><c/></a>' )
- assert XPath.first( d.root, 'node()[1]' )
- assert_equal 'b', XPath.first( d.root, 'node()[1]' ).name
- assert XPath.first( d.root, 'node()[0 + 1]' )
- assert_equal 'b', XPath.first( d.root, './node()[0 + 1]' ).name
- assert XPath.first( d.root, 'node()[1 + 1]' )
- assert_equal 'c', XPath.first( d.root, './node()[1 + 1]' ).name
- assert XPath.first( d.root, 'node()[4 div 2]' )
- assert_equal 'c', XPath.first( d.root, './node()[4 div 2]' ).name
- assert XPath.first( d.root, 'node()[2 - 1]' )
- assert_equal 'b', XPath.first( d.root, './node()[2 - 1]' ).name
- assert XPath.first( d.root, 'node()[5 mod 2]' )
- assert_equal 'b', XPath.first( d.root, './node()[5 mod 2]' ).name
- assert XPath.first( d.root, 'node()[8 mod 3]' )
- assert_equal 'c', XPath.first( d.root, './node()[8 mod 3]' ).name
- assert XPath.first( d.root, 'node()[1 * 2]' )
- assert_equal 'c', XPath.first( d.root, './node()[1 * 2]' ).name
- assert XPath.first( d.root, 'node()[2 + -1]' )
- assert_equal 'b', XPath.first( d.root, './node()[2 + -1]' ).name
- end
+ def test_math
+ d = Document.new( '<a><b/><c/></a>' )
+ assert XPath.first( d.root, 'node()[1]' )
+ assert_equal 'b', XPath.first( d.root, 'node()[1]' ).name
+ assert XPath.first( d.root, 'node()[0 + 1]' )
+ assert_equal 'b', XPath.first( d.root, './node()[0 + 1]' ).name
+ assert XPath.first( d.root, 'node()[1 + 1]' )
+ assert_equal 'c', XPath.first( d.root, './node()[1 + 1]' ).name
+ assert XPath.first( d.root, 'node()[4 div 2]' )
+ assert_equal 'c', XPath.first( d.root, './node()[4 div 2]' ).name
+ assert XPath.first( d.root, 'node()[2 - 1]' )
+ assert_equal 'b', XPath.first( d.root, './node()[2 - 1]' ).name
+ assert XPath.first( d.root, 'node()[5 mod 2]' )
+ assert_equal 'b', XPath.first( d.root, './node()[5 mod 2]' ).name
+ assert XPath.first( d.root, 'node()[8 mod 3]' )
+ assert_equal 'c', XPath.first( d.root, './node()[8 mod 3]' ).name
+ assert XPath.first( d.root, 'node()[1 * 2]' )
+ assert_equal 'c', XPath.first( d.root, './node()[1 * 2]' ).name
+ assert XPath.first( d.root, 'node()[2 + -1]' )
+ assert_equal 'b', XPath.first( d.root, './node()[2 + -1]' ).name
+ end
- def test_name
- assert_raise( UndefinedNamespaceException, "x should be undefined" ) {
- REXML::Document.new("<a x='foo'><b/><x:b/></a>")
- }
- d = REXML::Document.new("<a xmlns:x='foo'><b/><x:b/></a>")
- assert_equal 1, d.root.elements.to_a('*[name() = "b"]').size
- assert_equal 1, d.elements.to_a('//*[name() = "x:b"]').size
- end
+ def test_name
+ assert_raise( UndefinedNamespaceException, "x should be undefined" ) {
+ REXML::Document.new("<a x='foo'><b/><x:b/></a>")
+ }
+ d = REXML::Document.new("<a xmlns:x='foo'><b/><x:b/></a>")
+ assert_equal 1, d.root.elements.to_a('*[name() = "b"]').size
+ assert_equal 1, d.elements.to_a('//*[name() = "x:b"]').size
+ end
- def test_local_name
- d = REXML::Document.new("<a xmlns:x='foo'><b/><x:b/></a>")
- assert_equal 2, d.root.elements.to_a('*[local_name() = "b"]').size
- assert_equal 2, d.elements.to_a('//*[local_name() = "b"]').size
- end
+ def test_local_name
+ d = REXML::Document.new("<a xmlns:x='foo'><b/><x:b/></a>")
+ assert_equal 2, d.root.elements.to_a('*[local_name() = "b"]').size
+ assert_equal 2, d.elements.to_a('//*[local_name() = "b"]').size
+ end
- def test_comparisons
- source = "<a><b id='1'/><b id='2'/><b id='3'/></a>"
- doc = REXML::Document.new(source)
-
- # NOTE TO SER: check that number() is required
- assert_equal 2, REXML::XPath.match(doc, "//b[number(@id) > 1]").size
- assert_equal 3, REXML::XPath.match(doc, "//b[number(@id) >= 1]").size
- assert_equal 1, REXML::XPath.match(doc, "//b[number(@id) <= 1]").size
- assert_equal 1, REXML::XPath.match(doc, "//b[number(@id) = (1 * 1)]").size
- assert_equal 1, REXML::XPath.match(doc, "//b[number(@id) = (1 mod 2)]").size
- assert_equal 1, REXML::XPath.match(doc, "//b[number(@id) = (4 div 2)]").size
- end
+ def test_comparisons
+ source = "<a><b id='1'/><b id='2'/><b id='3'/></a>"
+ doc = REXML::Document.new(source)
+
+ # NOTE TO SER: check that number() is required
+ assert_equal 2, REXML::XPath.match(doc, "//b[number(@id) > 1]").size
+ assert_equal 3, REXML::XPath.match(doc, "//b[number(@id) >= 1]").size
+ assert_equal 1, REXML::XPath.match(doc, "//b[number(@id) <= 1]").size
+ assert_equal 1, REXML::XPath.match(doc, "//b[number(@id) = (1 * 1)]").size
+ assert_equal 1, REXML::XPath.match(doc, "//b[number(@id) = (1 mod 2)]").size
+ assert_equal 1, REXML::XPath.match(doc, "//b[number(@id) = (4 div 2)]").size
+ end
- # Contributed by Kouhei
- def test_substring_before
- doc = Document.new("<r><a/><b/><c/></r>")
- assert_equal("a", doc.root.elements.to_a("*[name()=substring-before('abc', 'b')]")[0].name)
- assert_equal("c", doc.root.elements.to_a("*[name()=substring-after('abc', 'b')]")[0].name)
- end
+ # Contributed by Kouhei
+ def test_substring_before
+ doc = Document.new("<r><a/><b/><c/></r>")
+ assert_equal("a", doc.root.elements.to_a("*[name()=substring-before('abc', 'b')]")[0].name)
+ assert_equal("c", doc.root.elements.to_a("*[name()=substring-after('abc', 'b')]")[0].name)
+ end
- def test_spaces
- doc = Document.new("<a>
- <b>
- <c id='a'/>
- </b>
- <c id='b'/>
- </a>")
- assert_equal( 1, REXML::XPath.match(doc,
- "//*[local-name()='c' and @id='b']").size )
- assert_equal( 1, REXML::XPath.match(doc,
- "//*[ local-name()='c' and @id='b' ]").size )
- assert_equal( 1, REXML::XPath.match(doc,
- "//*[ local-name() = 'c' and @id = 'b' ]").size )
- assert_equal( 1,
- REXML::XPath.match(doc, '/a/c[@id]').size )
- assert_equal( 1,
- REXML::XPath.match(doc, '/a/c[(@id)]').size )
- assert_equal( 1,
- REXML::XPath.match(doc, '/a/c[ @id ]').size )
- assert_equal( 1,
- REXML::XPath.match(doc, '/a/c[ (@id) ]').size )
- assert_equal( 1,
- REXML::XPath.match(doc, '/a/c[( @id )]').size )
- assert_equal( 1, REXML::XPath.match(doc.root,
- '/a/c[ ( @id ) ]').size )
- assert_equal( 1, REXML::XPath.match(doc,
- '/a/c [ ( @id ) ] ').size )
- assert_equal( 1, REXML::XPath.match(doc,
- ' / a / c [ ( @id ) ] ').size )
- end
+ def test_spaces
+ doc = Document.new("<a>
+ <b>
+ <c id='a'/>
+ </b>
+ <c id='b'/>
+ </a>")
+ assert_equal( 1, REXML::XPath.match(doc,
+ "//*[local-name()='c' and @id='b']").size )
+ assert_equal( 1, REXML::XPath.match(doc,
+ "//*[ local-name()='c' and @id='b' ]").size )
+ assert_equal( 1, REXML::XPath.match(doc,
+ "//*[ local-name() = 'c' and @id = 'b' ]").size )
+ assert_equal( 1,
+ REXML::XPath.match(doc, '/a/c[@id]').size )
+ assert_equal( 1,
+ REXML::XPath.match(doc, '/a/c[(@id)]').size )
+ assert_equal( 1,
+ REXML::XPath.match(doc, '/a/c[ @id ]').size )
+ assert_equal( 1,
+ REXML::XPath.match(doc, '/a/c[ (@id) ]').size )
+ assert_equal( 1,
+ REXML::XPath.match(doc, '/a/c[( @id )]').size )
+ assert_equal( 1, REXML::XPath.match(doc.root,
+ '/a/c[ ( @id ) ]').size )
+ assert_equal( 1, REXML::XPath.match(doc,
+ '/a/c [ ( @id ) ] ').size )
+ assert_equal( 1, REXML::XPath.match(doc,
+ ' / a / c [ ( @id ) ] ').size )
+ end
- def test_text_nodes
- # source = "<root>
- #<child/>
- #<child>test</child>
- #</root>"
- source = "<root><child>test</child></root>"
- d = REXML::Document.new( source )
- r = REXML::XPath.match( d, %q{/root/child[text()="test"]} )
- assert_equal( 1, r.size )
- assert_equal( "child", r[0].name )
- assert_equal( "test", r[0].text )
- end
+ def test_text_nodes
+ # source = "<root>
+ #<child/>
+ #<child>test</child>
+ #</root>"
+ source = "<root><child>test</child></root>"
+ d = REXML::Document.new( source )
+ r = REXML::XPath.match( d, %q{/root/child[text()="test"]} )
+ assert_equal( 1, r.size )
+ assert_equal( "child", r[0].name )
+ assert_equal( "test", r[0].text )
+ end
- def test_auto_string_value
- source = "<root><foo/><title>Introduction</title></root>"
- d = REXML::Document.new( source )
- #r = REXML::XPath.match( d, %q{/root[title="Introduction"]} )
- #assert_equal( 1, r.size )
- source = "<a><b/><c/><c>test</c></a>"
- d = REXML::Document.new( source )
- r = REXML::XPath.match( d, %q{/a[c='test']} )
- assert_equal( 1, r.size )
- r = REXML::XPath.match( d, %q{a[c='test']} )
- assert_equal( 1, r.size )
- r = d.elements["/a[c='test']"]
- assert_not_nil( r )
- r = d.elements["a[c='test']"]
- assert_not_nil( r )
- r = d.elements["a[c='xtest']"]
- assert_nil( r )
- r = REXML::XPath.match( d, %q{a[c='xtest']} )
- assert_equal( 0, r.size )
- end
+ def test_auto_string_value
+ source = "<root><foo/><title>Introduction</title></root>"
+ d = REXML::Document.new( source )
+ #r = REXML::XPath.match( d, %q{/root[title="Introduction"]} )
+ #assert_equal( 1, r.size )
+ source = "<a><b/><c/><c>test</c></a>"
+ d = REXML::Document.new( source )
+ r = REXML::XPath.match( d, %q{/a[c='test']} )
+ assert_equal( 1, r.size )
+ r = REXML::XPath.match( d, %q{a[c='test']} )
+ assert_equal( 1, r.size )
+ r = d.elements["/a[c='test']"]
+ assert_not_nil( r )
+ r = d.elements["a[c='test']"]
+ assert_not_nil( r )
+ r = d.elements["a[c='xtest']"]
+ assert_nil( r )
+ r = REXML::XPath.match( d, %q{a[c='xtest']} )
+ assert_equal( 0, r.size )
+ end
- def test_ordering
- source = "<a><b><c id='1'/><c id='2'/></b><b><d id='1'/><d id='2'/></b></a>"
- d = REXML::Document.new( source )
- r = REXML::XPath.match( d, %q{/a/*/*[1]} )
- assert_equal( 1, r.size )
- r.each { |el| assert_equal( '1', el.attribute('id').value ) }
- end
+ def test_ordering
+ source = "<a><b><c id='1'/><c id='2'/></b><b><d id='1'/><d id='2'/></b></a>"
+ d = REXML::Document.new( source )
+ r = REXML::XPath.match( d, %q{/a/*/*[1]} )
+ assert_equal( 1, r.size )
+ r.each { |el| assert_equal( '1', el.attribute('id').value ) }
+ end
- def test_descendant_or_self_ordering
- source = "<a>
- <b>
- <c id='1'/>
- <c id='2'/>
- </b>
- <b>
- <d id='1'>
- <c id='3'/>
- </d>
- <d id='2'>
- <e>
- <c id='4'/>
- </e>
- </d>
- </b>
- </a>"
- d = REXML::Document.new( source )
- cs = XPath.match( d, "/descendant-or-self::c" )
- assert_equal( 4, cs.length )
- 1.upto(4) {|x| assert_equal( x.to_s, cs[x-1].attributes['id'] ) }
- end
+ def test_descendant_or_self_ordering
+ source = "<a>
+ <b>
+ <c id='1'/>
+ <c id='2'/>
+ </b>
+ <b>
+ <d id='1'>
+ <c id='3'/>
+ </d>
+ <d id='2'>
+ <e>
+ <c id='4'/>
+ </e>
+ </d>
+ </b>
+ </a>"
+ d = REXML::Document.new( source )
+ cs = XPath.match( d, "/descendant-or-self::c" )
+ assert_equal( 4, cs.length )
+ 1.upto(4) {|x| assert_equal( x.to_s, cs[x-1].attributes['id'] ) }
+ end
- def test_and
- d = Document.new %q{<doc><route run='*' title='HNO'
- destination='debian_production1' date='*' edition='*'
- source='debian_satellite1'/></doc>}
- assert_equal( nil, d.root.elements["route[@run='0']"] )
- assert_equal( nil, d.root.elements["route[@run='0' and @title='HNO']"] )
- end
+ def test_and
+ d = Document.new %q{<doc><route run='*' title='HNO'
+ destination='debian_production1' date='*' edition='*'
+ source='debian_satellite1'/></doc>}
+ assert_equal( nil, d.root.elements["route[@run='0']"] )
+ assert_equal( nil, d.root.elements["route[@run='0' and @title='HNO']"] )
+ end
- def test_numbers
- d = Document.new %q{<a x="0" y="*" z="4e" w="e4" v="a"/>}
-
- xp1 = "/a[ @x = 0 ]"
- xp2 = "/a[ @x = '0' ]"
- xp3 = "/a[ (@x + 1) = 1 ]"
- xp4 = "/a[ @y = 0 ]"
- xp5 = "/a[ (@z + 1) = 5 ]"
- xp6 = "/a[ (@w + 1) = 5 ]"
- xp7 = "/a[ (@v + 1) = 1 ]"
- xp8 = "/a[ @n = 0 ]"
-
- assert_equal( 1, XPath.match( d, xp1 ).length )
- assert_equal( 1, XPath.match( d, xp2 ).length )
- assert_equal( 1, XPath.match( d, xp3 ).length )
- assert_equal( 0, XPath.match( d, xp4 ).length )
- assert_equal( 0, XPath.match( d, xp5 ).length )
- assert_equal( 0, XPath.match( d, xp6 ).length )
- assert_equal( 0, XPath.match( d, xp7 ).length )
- assert_equal( 0, XPath.match( d, xp8 ).length )
- end
+ def test_numbers
+ d = Document.new %q{<a x="0" y="*" z="4e" w="e4" v="a"/>}
+
+ xp1 = "/a[ @x = 0 ]"
+ xp2 = "/a[ @x = '0' ]"
+ xp3 = "/a[ (@x + 1) = 1 ]"
+ xp4 = "/a[ @y = 0 ]"
+ xp5 = "/a[ (@z + 1) = 5 ]"
+ xp6 = "/a[ (@w + 1) = 5 ]"
+ xp7 = "/a[ (@v + 1) = 1 ]"
+ xp8 = "/a[ @n = 0 ]"
+
+ assert_equal( 1, XPath.match( d, xp1 ).length )
+ assert_equal( 1, XPath.match( d, xp2 ).length )
+ assert_equal( 1, XPath.match( d, xp3 ).length )
+ assert_equal( 0, XPath.match( d, xp4 ).length )
+ assert_equal( 0, XPath.match( d, xp5 ).length )
+ assert_equal( 0, XPath.match( d, xp6 ).length )
+ assert_equal( 0, XPath.match( d, xp7 ).length )
+ assert_equal( 0, XPath.match( d, xp8 ).length )
+ end
- def test_tobis_preceding
- doc_string = '<a>
+ def test_tobis_preceding
+ doc_string = '<a>
<b/>
<c>
<d/>
@@ -759,58 +759,58 @@ class TestXPathBase < Test::Unit::TestCase
</c>
</a>'
- doc = Document.new(doc_string)
+ doc = Document.new(doc_string)
- # e = REXML::XPath.first(doc,'/a/c/e')
- e = doc.root.get_elements('/a/c/e')[0]
- assert_equal( 1, e.get_elements('preceding-sibling::*').length )
- assert_equal( 2, XPath.match(e, 'preceding::*').length )
- end
+ # e = REXML::XPath.first(doc,'/a/c/e')
+ e = doc.root.get_elements('/a/c/e')[0]
+ assert_equal( 1, e.get_elements('preceding-sibling::*').length )
+ assert_equal( 2, XPath.match(e, 'preceding::*').length )
+ end
- def test_filtering
- #doc=Document.new("<a><b><c1/><c2/></b><b><c3/><c4/></b><b><c5/><c6/></b></a>")
- #assert_equal( 3, XPath.match( doc, '/a/b/*[1]' ).length )
- #assert_equal( 2, XPath.match( doc, '/a/b/following-sibling::*[1]' ).length )
- end
+ def test_filtering
+ #doc=Document.new("<a><b><c1/><c2/></b><b><c3/><c4/></b><b><c5/><c6/></b></a>")
+ #assert_equal( 3, XPath.match( doc, '/a/b/*[1]' ).length )
+ #assert_equal( 2, XPath.match( doc, '/a/b/following-sibling::*[1]' ).length )
+ end
- # Submitted by Alex
- def test_union
- data = %Q{<div id="the_div">
+ # Submitted by Alex
+ def test_union
+ data = %Q{<div id="the_div">
<span id="the_span">
<strong id="the_strong">a</strong>
</span>
<em id="the_em2">b</em>
</div>}
- rd = REXML::Document.new( data )
- #union = rd.get_elements("/div/span | /div/em")
- #assert_equal(2, union.length, "/div/span | /div/em" )
- union = rd.get_elements('//*[name()="em" or name()="strong"]')
- assert_equal(2, union.length, 'name() and "or" failed')
- union = rd.get_elements('//em|//strong')
- assert_equal(2, union.length,
- 'Both tag types are returned by XPath union operator')
- end
+ rd = REXML::Document.new( data )
+ #union = rd.get_elements("/div/span | /div/em")
+ #assert_equal(2, union.length, "/div/span | /div/em" )
+ union = rd.get_elements('//*[name()="em" or name()="strong"]')
+ assert_equal(2, union.length, 'name() and "or" failed')
+ union = rd.get_elements('//em|//strong')
+ assert_equal(2, union.length,
+ 'Both tag types are returned by XPath union operator')
+ end
- def test_union2
- src = <<-EOL
+ def test_union2
+ src = <<-EOL
<div id="the_div">
<span id="the_span">
<strong id="the_strong">a</strong>
</span>
<em id="the_em2">b</em>
</div>
- EOL
- rd = REXML::Document.new( src )
- union = rd.get_elements('//em|//strong')
- assert_equal(2, union.length,
- 'Both tag types are returned by XPath union operator')
- end
+ EOL
+ rd = REXML::Document.new( src )
+ union = rd.get_elements('//em|//strong')
+ assert_equal(2, union.length,
+ 'Both tag types are returned by XPath union operator')
+ end
- def test_a_star_star_one
- string = <<-EOL
+ def test_a_star_star_one
+ string = <<-EOL
<a>
<b>
<c1/>
@@ -825,97 +825,97 @@ class TestXPathBase < Test::Unit::TestCase
<f/>
</b>
</a>
- EOL
- d = REXML::Document.new( string )
- c1 = XPath.match( d, '/a/*/*[1]' )
- assert_equal( 1, c1.length )
- assert_equal( 'c1', c1[0].name )
- end
-
- def test_sum
- d = Document.new("<a>"+
- "<b>1</b><b>2</b><b>3</b>"+
- "<c><d>1</d><d>2</d></c>"+
- "<e att='1'/><e att='2'/>"+
- "</a>")
+ EOL
+ d = REXML::Document.new( string )
+ c1 = XPath.match( d, '/a/*/*[1]' )
+ assert_equal( 1, c1.length )
+ assert_equal( 'c1', c1[0].name )
+ end
- for v,p in [[6, "sum(/a/b)"],
- [9, "sum(//b | //d)"],
- [3, "sum(/a/e/@*)"] ]
- assert_equal( v, XPath::match( d, p ).first )
+ def test_sum
+ d = Document.new("<a>"+
+ "<b>1</b><b>2</b><b>3</b>"+
+ "<c><d>1</d><d>2</d></c>"+
+ "<e att='1'/><e att='2'/>"+
+ "</a>")
+
+ for v,p in [[6, "sum(/a/b)"],
+ [9, "sum(//b | //d)"],
+ [3, "sum(/a/e/@*)"] ]
+ assert_equal( v, XPath::match( d, p ).first )
+ end
end
- end
- def test_xpath_namespace
- d = REXML::Document.new("<tag1 xmlns='ns1'><tag2 xmlns='ns2'/><tada>xa</tada></tag1>")
- x = d.root
- num = 0
- x.each_element('tada') { num += 1 }
- assert_equal(1, num)
- end
+ def test_xpath_namespace
+ d = REXML::Document.new("<tag1 xmlns='ns1'><tag2 xmlns='ns2'/><tada>xa</tada></tag1>")
+ x = d.root
+ num = 0
+ x.each_element('tada') { num += 1 }
+ assert_equal(1, num)
+ end
- def test_ticket_39
- doc = REXML::Document.new( <<-EOL )
- <rss>
- <channel>
- <!-- removing the namespace declaration makes the test pass -->
- <convertLineBreaks xmlns="http://www.blogger.com/atom/ns#">true</convertLineBreaks>
- <item>
- <title>Item 1</title>
- </item>
- <item>
- <title>Item 2</title>
- <pubDate>Thu, 13 Oct 2005 19:59:00 +0000</pubDate>
- </item>
- <item>
- <title>Item 3</title>
- </item>
- </channel>
- </rss>
- EOL
- root_node = XPath.first(doc, "rss")
- assert_not_nil root_node
- channel_node = XPath.first(root_node, "channel")
- assert_not_nil channel_node
- items = XPath.match(channel_node, "*")
- assert_equal 4, items.size
- items = XPath.match(channel_node, "item")
- assert_equal 3, items.size # fails
- end
+ def test_ticket_39
+ doc = REXML::Document.new( <<-EOL )
+ <rss>
+ <channel>
+ <!-- removing the namespace declaration makes the test pass -->
+ <convertLineBreaks xmlns="http://www.blogger.com/atom/ns#">true</convertLineBreaks>
+ <item>
+ <title>Item 1</title>
+ </item>
+ <item>
+ <title>Item 2</title>
+ <pubDate>Thu, 13 Oct 2005 19:59:00 +0000</pubDate>
+ </item>
+ <item>
+ <title>Item 3</title>
+ </item>
+ </channel>
+ </rss>
+ EOL
+ root_node = XPath.first(doc, "rss")
+ assert_not_nil root_node
+ channel_node = XPath.first(root_node, "channel")
+ assert_not_nil channel_node
+ items = XPath.match(channel_node, "*")
+ assert_equal 4, items.size
+ items = XPath.match(channel_node, "item")
+ assert_equal 3, items.size # fails
+ end
- def test_ticket_42
- source = "<a></a>"
- doc = Document.new(source)
- bElem = Element.new('b')
- doc.root.add_element(bElem)
- doc.elements.each('//b[name(..) = "a"]') { |x|
- assert_equal x,bElem
- }
- end
+ def test_ticket_42
+ source = "<a></a>"
+ doc = Document.new(source)
+ bElem = Element.new('b')
+ doc.root.add_element(bElem)
+ doc.elements.each('//b[name(..) = "a"]') { |x|
+ assert_equal x,bElem
+ }
+ end
- def test_ticket_56
- namespaces = {'h' => 'http://www.w3.org/1999/xhtml'}
+ def test_ticket_56
+ namespaces = {'h' => 'http://www.w3.org/1999/xhtml'}
- finaldoc = REXML::Document.new(File.read(fixture_path('google.2.xml')))
+ finaldoc = REXML::Document.new(File.read(fixture_path('google.2.xml')))
- column_headers = []
+ column_headers = []
- REXML::XPath.each(finaldoc, '//h:form[@action="ModifyCampaign"]//h:th',
- namespaces) do |el|
- node = REXML::XPath.first(el, 'h:a/text()', namespaces)
- column_headers << (node ? node.value : nil)
+ REXML::XPath.each(finaldoc, '//h:form[@action="ModifyCampaign"]//h:th',
+ namespaces) do |el|
+ node = REXML::XPath.first(el, 'h:a/text()', namespaces)
+ column_headers << (node ? node.value : nil)
+ end
+ column_headers.map! { |h| h.to_s.strip.chomp }
+ expected = ["", "", "Current Status", "Current Budget",
+ "Clicks", "Impr.", "CTR", "Avg. CPC", "Cost", "Conv. Rate",
+ "Cost/Conv."]
+ assert_equal( expected, column_headers )
end
- column_headers.map! { |h| h.to_s.strip.chomp }
- expected = ["", "", "Current Status", "Current Budget",
- "Clicks", "Impr.", "CTR", "Avg. CPC", "Cost", "Conv. Rate",
- "Cost/Conv."]
- assert_equal( expected, column_headers )
- end
- def test_ticket_70
- string = <<EOF
+ def test_ticket_70
+ string = <<EOF
<mydoc>
@@ -929,134 +929,134 @@ text</someelement>
</mydoc>
EOF
- doc = Document.new string
- assert_equal( 1, XPath.match( doc, "//someelement[contains(@attribute,'1.10')]" ).length )
- end
+ doc = Document.new string
+ assert_equal( 1, XPath.match( doc, "//someelement[contains(@attribute,'1.10')]" ).length )
+ end
- def test_ticket_43
- #url = http://news.search.yahoo.com/news/rss?p=market&ei=UTF-8&fl=0&x=wrt
+ def test_ticket_43
+ #url = http://news.search.yahoo.com/news/rss?p=market&ei=UTF-8&fl=0&x=wrt
- sum = Document.new(File.new(fixture_path("yahoo.xml"))).elements.to_a("//item").size
- assert_equal( 10, sum )
+ sum = Document.new(File.new(fixture_path("yahoo.xml"))).elements.to_a("//item").size
+ assert_equal( 10, sum )
- text = Document.new(File.new(fixture_path("yahoo.xml"))).elements.to_a(%Q{//title[contains(text(), "'")]}).collect{|e| e.text}.join
- assert_equal( "Broward labor market's a solid performer (Miami Herald)", text )
- end
+ text = Document.new(File.new(fixture_path("yahoo.xml"))).elements.to_a(%Q{//title[contains(text(), "'")]}).collect{|e| e.text}.join
+ assert_equal( "Broward labor market's a solid performer (Miami Herald)", text )
+ end
- def test_ticket_57
- data = "<?xml version='1.0'?><a:x xmlns:a='1'><a:y p='p' q='q'><a:z>zzz</a:z></a:y></a:x>"
+ def test_ticket_57
+ data = "<?xml version='1.0'?><a:x xmlns:a='1'><a:y p='p' q='q'><a:z>zzz</a:z></a:y></a:x>"
- r = Document.new(data)
+ r = Document.new(data)
- assert_equal(Text, REXML::XPath.first(r,"a:x/a:y[@p='p' and @q='q']/a:z/text()").class)
- assert_equal("zzz", REXML::XPath.first(r,"a:x/a:y[@p='p' and @q='q']/a:z/text()").to_s)
- end
+ assert_equal(Text, REXML::XPath.first(r,"a:x/a:y[@p='p' and @q='q']/a:z/text()").class)
+ assert_equal("zzz", REXML::XPath.first(r,"a:x/a:y[@p='p' and @q='q']/a:z/text()").to_s)
+ end
- def test_ticket_59
- data = "<a>
- <c id='1'/>
- <c id='2'/>
- <b>
- <c id='3'/>
- </b>
- <c id='4'/>
- <b>
+ def test_ticket_59
+ data = "<a>
+ <c id='1'/>
+ <c id='2'/>
<b>
- <c id='5'/>
+ <c id='3'/>
</b>
- <c id='6'/>
- </b>
- <c id='7'/>
- <b>
+ <c id='4'/>
<b>
- <c id='8'/>
<b>
- <c id='9'/>
+ <c id='5'/>
+ </b>
+ <c id='6'/>
+ </b>
+ <c id='7'/>
+ <b>
+ <b>
+ <c id='8'/>
<b>
- <c id='10'/>
+ <c id='9'/>
+ <b>
+ <c id='10'/>
+ </b>
+ <c id='11'/>
</b>
- <c id='11'/>
</b>
</b>
- </b>
- <c id='12'/>
- </a>"
- d = Document.new(data)
- res = d.elements.to_a( "//c" ).collect {|e| e.attributes['id'].to_i}
- assert_equal( res, res.sort )
- end
+ <c id='12'/>
+ </a>"
+ d = Document.new(data)
+ res = d.elements.to_a( "//c" ).collect {|e| e.attributes['id'].to_i}
+ assert_equal( res, res.sort )
+ end
- def ticket_61_fixture(doc, xpath)
- matches = []
- doc.elements.each(xpath) do |element|
- matches << element
- assert_equal('Add', element.text)
- assert_equal('ButtonText', element.attributes['class'])
+ def ticket_61_fixture(doc, xpath)
+ matches = []
+ doc.elements.each(xpath) do |element|
+ matches << element
+ assert_equal('Add', element.text)
+ assert_equal('ButtonText', element.attributes['class'])
+ end
+ assert_equal(1, matches.length)
end
- assert_equal(1, matches.length)
- end
- def test_ticket_61_text
- file = File.open(fixture_path("ticket_61.xml"))
- doc = REXML::Document.new file
- ticket_61_fixture( doc, "//div[text()='Add' and @class='ButtonText']" )
- end
+ def test_ticket_61_text
+ file = File.open(fixture_path("ticket_61.xml"))
+ doc = REXML::Document.new file
+ ticket_61_fixture( doc, "//div[text()='Add' and @class='ButtonText']" )
+ end
- def test_ticket_61_contains
- file = File.open(fixture_path("ticket_61.xml"))
- doc = REXML::Document.new file
- ticket_61_fixture( doc, "//div[contains(.,'Add') and @class='ButtonText']" )
- end
+ def test_ticket_61_contains
+ file = File.open(fixture_path("ticket_61.xml"))
+ doc = REXML::Document.new file
+ ticket_61_fixture( doc, "//div[contains(.,'Add') and @class='ButtonText']" )
+ end
- def test_namespaces_0
- d = Document.new(%q{<x:a xmlns:x="y"/>})
- assert_equal( 1, XPath.match( d, "//x:a" ).size )
- assert_equal( 1, XPath.match( d, "//x:*" ).size )
- end
+ def test_namespaces_0
+ d = Document.new(%q{<x:a xmlns:x="y"/>})
+ assert_equal( 1, XPath.match( d, "//x:a" ).size )
+ assert_equal( 1, XPath.match( d, "//x:*" ).size )
+ end
- def test_ticket_71
- doc = Document.new(%Q{<root xmlns:ns1="xyz" xmlns:ns2="123"><element ns1:attrname="foo" ns2:attrname="bar"/></root>})
- el = doc.root.elements[1]
- assert_equal( "element", el.name )
- el2 = XPath.first( doc.root, "element[@ns:attrname='foo']", { 'ns' => "xyz" } )
- assert_equal( el, el2 )
- end
+ def test_ticket_71
+ doc = Document.new(%Q{<root xmlns:ns1="xyz" xmlns:ns2="123"><element ns1:attrname="foo" ns2:attrname="bar"/></root>})
+ el = doc.root.elements[1]
+ assert_equal( "element", el.name )
+ el2 = XPath.first( doc.root, "element[@ns:attrname='foo']", { 'ns' => "xyz" } )
+ assert_equal( el, el2 )
+ end
- def test_ticket_78
- doc = <<-EOT
- <root>
- <element>
- <tag x='1'>123</tag>
- </element>
- <element>
- <tag x='2'>123a</tag>
- </element>
- </root>
- EOT
- seq = %w{BEGIN 123 END BEGIN 123a END}
-
- xmlDoc = Document.new(doc)
-
- ["//element[tag='123']/tag", "//element[tag='123a']/tag"].each do |query|
- assert_equal( "BEGIN", seq.shift )
- XPath.each(xmlDoc, query) { |element|
- assert_equal( seq.shift, element.text )
- }
- assert_equal( "END", seq.shift )
+ def test_ticket_78
+ doc = <<-EOT
+ <root>
+ <element>
+ <tag x='1'>123</tag>
+ </element>
+ <element>
+ <tag x='2'>123a</tag>
+ </element>
+ </root>
+ EOT
+ seq = %w{BEGIN 123 END BEGIN 123a END}
+
+ xmlDoc = Document.new(doc)
+
+ ["//element[tag='123']/tag", "//element[tag='123a']/tag"].each do |query|
+ assert_equal( "BEGIN", seq.shift )
+ XPath.each(xmlDoc, query) { |element|
+ assert_equal( seq.shift, element.text )
+ }
+ assert_equal( "END", seq.shift )
+ end
end
- end
- def test_ticket_79
- source = "<a><b><c>test</c></b><b><c>3</c></b></a>"
- d = REXML::Document.new( source )
- r = REXML::XPath.match( d, %q{/a/b[c='test']} )
- assert_equal(1, r.size())
- r = REXML::XPath.match( d, %q{/a/b[c='3']} )
- assert_equal(1, r.size())
- end
+ def test_ticket_79
+ source = "<a><b><c>test</c></b><b><c>3</c></b></a>"
+ d = REXML::Document.new( source )
+ r = REXML::XPath.match( d, %q{/a/b[c='test']} )
+ assert_equal(1, r.size())
+ r = REXML::XPath.match( d, %q{/a/b[c='3']} )
+ assert_equal(1, r.size())
+ end
- def test_or_and
- doc = "
+ def test_or_and
+ doc = "
<html>
<head>
<title>test</title>
@@ -1069,13 +1069,13 @@ EOF
</html>
"
- xmldoc = REXML::Document.new(doc)
- xpath = "descendant::node()[(local-name()='link' or local-name()='a') and @rel='sub']"
- hrefs = []
- xmldoc.elements.each(xpath) do |element|
- hrefs << element.attributes["href"]
+ xmldoc = REXML::Document.new(doc)
+ xpath = "descendant::node()[(local-name()='link' or local-name()='a') and @rel='sub']"
+ hrefs = []
+ xmldoc.elements.each(xpath) do |element|
+ hrefs << element.attributes["href"]
+ end
+ assert_equal(["/"], hrefs, "Bug #3842 [ruby-core:32447]")
end
- assert_equal(["/"], hrefs, "Bug #3842 [ruby-core:32447]")
end
end
-end
diff --git a/test/rexml/xpath/test_node.rb b/test/rexml/xpath/test_node.rb
index f0109be..aec2de1 100644
--- a/test/rexml/xpath/test_node.rb
+++ b/test/rexml/xpath/test_node.rb
@@ -5,38 +5,38 @@ require_relative "../rexml_test_utils"
require "rexml/document"
module REXMLTests
-class TestXPathNode < Test::Unit::TestCase
- def matches(xml, xpath)
- document = REXML::Document.new(xml)
- REXML::XPath.each(document, xpath).collect(&:to_s)
- end
+ class TestXPathNode < Test::Unit::TestCase
+ def matches(xml, xpath)
+ document = REXML::Document.new(xml)
+ REXML::XPath.each(document, xpath).collect(&:to_s)
+ end
- class TestQName < self
- def test_ascii
- xml = <<-XML
+ class TestQName < self
+ def test_ascii
+ xml = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<root>
<ascii>
<child>child</child>
</ascii>
</root>
- XML
- assert_equal(["<child>child</child>"],
- matches(xml, "/root/ascii/child"))
- end
+ XML
+ assert_equal(["<child>child</child>"],
+ matches(xml, "/root/ascii/child"))
+ end
- def test_non_ascii
- xml = <<-XML
+ def test_non_ascii
+ xml = <<-XML
<?xml version="1.0" encoding="UTF-8"?>
<root>
<non-àscii>
<child>child</child>
</non-àscii>
</root>
- XML
- assert_equal(["<child>child</child>"],
- matches(xml, "/root/non-àscii/child"))
+ XML
+ assert_equal(["<child>child</child>"],
+ matches(xml, "/root/non-àscii/child"))
+ end
end
end
end
-end
diff --git a/test/rexml/xpath/test_predicate.rb b/test/rexml/xpath/test_predicate.rb
index 4cbf244..287e131 100644
--- a/test/rexml/xpath/test_predicate.rb
+++ b/test/rexml/xpath/test_predicate.rb
@@ -4,60 +4,60 @@ require "rexml/xpath"
require "rexml/parsers/xpathparser"
module REXMLTests
-class TestXPathPredicate < Test::Unit::TestCase
- include REXML
- SRC=<<-EOL
- <article>
- <section role="subdivision" id="1">
- <para>free flowing text.</para>
- </section>
- <section role="division">
- <section role="subdivision" id="2">
- <para>free flowing text.</para>
- </section>
- <section role="division">
- <para>free flowing text.</para>
- </section>
- </section>
- </article>
- EOL
+ class TestXPathPredicate < Test::Unit::TestCase
+ include REXML
+ SRC=<<-EOL
+ <article>
+ <section role="subdivision" id="1">
+ <para>free flowing text.</para>
+ </section>
+ <section role="division">
+ <section role="subdivision" id="2">
+ <para>free flowing text.</para>
+ </section>
+ <section role="division">
+ <para>free flowing text.</para>
+ </section>
+ </section>
+ </article>
+ EOL
- def setup
- @doc = REXML::Document.new( SRC )
- @parser = REXML::Parsers::XPathParser.new
+ def setup
+ @doc = REXML::Document.new( SRC )
+ @parser = REXML::Parsers::XPathParser.new
- end
+ end
- def test_predicates_parent
- path = '//section[../self::section[@role="division"]]'
- m = do_path( path )
- assert_equal( 2, m.size )
- assert_equal( "2", m[0].attributes["id"] )
- assert_nil( m[1].attributes["id"] )
- end
+ def test_predicates_parent
+ path = '//section[../self::section[@role="division"]]'
+ m = do_path( path )
+ assert_equal( 2, m.size )
+ assert_equal( "2", m[0].attributes["id"] )
+ assert_nil( m[1].attributes["id"] )
+ end
- def test_predicates_single
- path = '//section[@role="subdivision" and not(../self::section[@role="division"])]'
- m = do_path( path )
- assert_equal( 1, m.size )
- assert_equal( "1", m[0].attributes["id"] )
- end
+ def test_predicates_single
+ path = '//section[@role="subdivision" and not(../self::section[@role="division"])]'
+ m = do_path( path )
+ assert_equal( 1, m.size )
+ assert_equal( "1", m[0].attributes["id"] )
+ end
- def test_predicates_multi
- path = '//section[@role="subdivision"][not(../self::section[@role="division"])]'
- m = do_path( path )
- assert_equal( 1, m.size )
- assert_equal( "1", m[0].attributes["id"] )
- end
+ def test_predicates_multi
+ path = '//section[@role="subdivision"][not(../self::section[@role="division"])]'
+ m = do_path( path )
+ assert_equal( 1, m.size )
+ assert_equal( "1", m[0].attributes["id"] )
+ end
- def do_path( path )
- m = REXML::XPath.match( @doc, path )
- #puts path, @parser.parse( path ).inspect
- return m
- end
+ def do_path( path )
+ m = REXML::XPath.match( @doc, path )
+ #puts path, @parser.parse( path ).inspect
+ return m
+ end
- def test_get_no_siblings_terminal_nodes
- source = <<-XML
+ def test_get_no_siblings_terminal_nodes
+ source = <<-XML
<a>
<b number='1' str='abc'>TEXT1</b>
<c number='1'/>
@@ -68,15 +68,15 @@ class TestXPathPredicate < Test::Unit::TestCase
</c>
</a>
XML
- doc = REXML::Document.new(source)
- predicate = "count(child::node()|" +
- "following-sibling::node()|" +
- "preceding-sibling::node())=0"
- m = REXML::XPath.match(doc, "/descendant-or-self::node()[#{predicate}]")
- assert_equal( [REXML::Text.new("TEXT1"),
- REXML::Text.new("TEXT2"),
- REXML::Comment.new("COMMENT")],
- m )
+ doc = REXML::Document.new(source)
+ predicate = "count(child::node()|" +
+ "following-sibling::node()|" +
+ "preceding-sibling::node())=0"
+ m = REXML::XPath.match(doc, "/descendant-or-self::node()[#{predicate}]")
+ assert_equal( [REXML::Text.new("TEXT1"),
+ REXML::Text.new("TEXT2"),
+ REXML::Comment.new("COMMENT")],
+ m )
+ end
end
end
-end
diff --git a/test/rexml/xpath/test_text.rb b/test/rexml/xpath/test_text.rb
index cf65130..46aba3c 100644
--- a/test/rexml/xpath/test_text.rb
+++ b/test/rexml/xpath/test_text.rb
@@ -4,71 +4,71 @@ require 'rexml/element'
require 'rexml/xpath'
module REXMLTests
-class TestXPathText < Test::Unit::TestCase
- def setup
- @doc = REXML::Document.new
- end
+ class TestXPathText < Test::Unit::TestCase
+ def setup
+ @doc = REXML::Document.new
+ end
- def tear_down
- end
+ def tear_down
+ end
- def test_text_as_element
- node1 = REXML::Element.new('a', @doc)
- node2 = REXML::Element.new('b', node1)
- REXML::Text.new('test', false, node2)
- assert_equal(1, @doc.elements.size, "doc owns 1 element node1")
- assert_same(node1, @doc.elements[1], "doc owns 1 element node1")
- assert_equal(1, node1.elements.size, "node1 owns 1 element node2")
- assert_same(node2, node1.elements[1], "node1 owns 1 element node2")
- assert_equal(1, node2.size, "node2 owns 1 text element")
- end
+ def test_text_as_element
+ node1 = REXML::Element.new('a', @doc)
+ node2 = REXML::Element.new('b', node1)
+ REXML::Text.new('test', false, node2)
+ assert_equal(1, @doc.elements.size, "doc owns 1 element node1")
+ assert_same(node1, @doc.elements[1], "doc owns 1 element node1")
+ assert_equal(1, node1.elements.size, "node1 owns 1 element node2")
+ assert_same(node2, node1.elements[1], "node1 owns 1 element node2")
+ assert_equal(1, node2.size, "node2 owns 1 text element")
+ end
- def test_text_in_xpath_query
- node1 = REXML::Element.new('a', @doc)
- node2 = REXML::Element.new('b', node1)
- textnode = REXML::Text.new('test', false, node2)
- textnode.parent = node2 # should be unnecessary
- nodes = @doc.get_elements('//b')
- assert_equal(1, nodes.size, "document has one element")
- # why doesn't this query work right?
- nodes = REXML::XPath.match(@doc, '//text()')
- assert_equal(1, nodes.size, "//text() should yield one Text element")
- assert_equal(REXML::Text, nodes[0].class)
- end
+ def test_text_in_xpath_query
+ node1 = REXML::Element.new('a', @doc)
+ node2 = REXML::Element.new('b', node1)
+ textnode = REXML::Text.new('test', false, node2)
+ textnode.parent = node2 # should be unnecessary
+ nodes = @doc.get_elements('//b')
+ assert_equal(1, nodes.size, "document has one element")
+ # why doesn't this query work right?
+ nodes = REXML::XPath.match(@doc, '//text()')
+ assert_equal(1, nodes.size, "//text() should yield one Text element")
+ assert_equal(REXML::Text, nodes[0].class)
+ end
- def test_comment_in_xpath_query
- node1 = REXML::Element.new('a', @doc)
- node2 = REXML::Element.new('b', node1)
- commentnode = REXML::Comment.new('test', node2)
- nodes = REXML::XPath.match(@doc, '//comment()')
- assert_equal(1, nodes.size, "//comment() should yield one Comment element")
- assert_same commentnode, nodes[0]
- end
+ def test_comment_in_xpath_query
+ node1 = REXML::Element.new('a', @doc)
+ node2 = REXML::Element.new('b', node1)
+ commentnode = REXML::Comment.new('test', node2)
+ nodes = REXML::XPath.match(@doc, '//comment()')
+ assert_equal(1, nodes.size, "//comment() should yield one Comment element")
+ assert_same commentnode, nodes[0]
+ end
- def test_parentage
- node1 = REXML::Element.new('a', @doc)
- assert_same(@doc, node1.parent, "node1 parent is document")
- node2 = REXML::Element.new('b', node1)
- assert_same(node1, node2.parent, "node2 parent is node1")
- textnode = REXML::Text.new('test', false, node2)
- # why isn't the text's parent node2?
- # Also look at Comment, etc.
- assert_same(node2, textnode.parent)
- comment = REXML::Comment.new('Test comment', node2)
- assert_same(node2, comment.parent)
- end
+ def test_parentage
+ node1 = REXML::Element.new('a', @doc)
+ assert_same(@doc, node1.parent, "node1 parent is document")
+ node2 = REXML::Element.new('b', node1)
+ assert_same(node1, node2.parent, "node2 parent is node1")
+ textnode = REXML::Text.new('test', false, node2)
+ # why isn't the text's parent node2?
+ # Also look at Comment, etc.
+ assert_same(node2, textnode.parent)
+ comment = REXML::Comment.new('Test comment', node2)
+ assert_same(node2, comment.parent)
+ end
- def test_ancestors
- node1 = REXML::Element.new('a', @doc)
- node2 = REXML::Element.new('b', node1)
- textnode = REXML::Text.new('test', false, node2)
- #textnode.parent = node2 # should be unnecessary
- assert_same node2, textnode.parent
- nodes = @doc.get_elements('//b/ancestor::*')
- assert_equal(1, nodes.size, "<b> has one element ancestor")
- nodes = @doc.get_elements('//b/ancestor::node()')
- assert_equal(2, nodes.size, "<b> has two node ancestors")
- assert nodes[1].kind_of?(REXML::Document)
+ def test_ancestors
+ node1 = REXML::Element.new('a', @doc)
+ node2 = REXML::Element.new('b', node1)
+ textnode = REXML::Text.new('test', false, node2)
+ #textnode.parent = node2 # should be unnecessary
+ assert_same node2, textnode.parent
+ nodes = @doc.get_elements('//b/ancestor::*')
+ assert_equal(1, nodes.size, "<b> has one element ancestor")
+ nodes = @doc.get_elements('//b/ancestor::node()')
+ assert_equal(2, nodes.size, "<b> has two node ancestors")
+ assert nodes[1].kind_of?(REXML::Document)
+ end
end
end
-end