libxml-ruby-3.2.1/ 0000755 0000041 0000041 00000000000 13760147770 014027 5 ustar www-data www-data libxml-ruby-3.2.1/test/ 0000755 0000041 0000041 00000000000 13760147770 015006 5 ustar www-data www-data libxml-ruby-3.2.1/test/test_node_edit.rb 0000644 0000041 0000041 00000011170 13760147770 020324 0 ustar www-data www-data # encoding: UTF-8
require_relative './test_helper'
class TestNodeEdit < Minitest::Test
def setup
xp = LibXML::XML::Parser.string('onetwothree')
@doc = xp.parse
end
def teardown
@doc = nil
end
def first_node
@doc.root.child
end
def second_node
first_node.next
end
def third_node
second_node.next
end
def test_add_next_01
first_node.next = LibXML::XML::Node.new('num', 'one-and-a-half')
assert_equal('oneone-and-a-halftwothree',
@doc.root.to_s.gsub(/\n\s*/,''))
end
def test_add_next_02
second_node.next = LibXML::XML::Node.new('num', 'two-and-a-half')
assert_equal('onetwotwo-and-a-halfthree',
@doc.root.to_s.gsub(/\n\s*/,''))
end
def test_add_next_03
third_node.next = LibXML::XML::Node.new('num', 'four')
assert_equal 'onetwothreefour',
@doc.root.to_s.gsub(/\n\s*/,'')
end
def test_add_prev_01
first_node.prev = LibXML::XML::Node.new('num', 'half')
assert_equal 'halfonetwothree',
@doc.root.to_s.gsub(/\n\s*/,'')
end
def test_add_prev_02
second_node.prev = LibXML::XML::Node.new('num', 'one-and-a-half')
assert_equal 'oneone-and-a-halftwothree',
@doc.root.to_s.gsub(/\n\s*/,'')
end
def test_add_prev_03
third_node.prev = LibXML::XML::Node.new('num', 'two-and-a-half')
assert_equal 'onetwotwo-and-a-halfthree',
@doc.root.to_s.gsub(/\n\s*/,'')
end
def test_remove_node
first_node.remove!
assert_equal('twothree',
@doc.root.to_s.gsub(/\n\s*/,''))
end
def test_remove_node_gc
xp = LibXML::XML::Parser.string('onetwothree')
doc = xp.parse
doc.root.child.remove!
GC.start
refute_nil(doc)
end
def test_remove_node_iteration
nodes = Array.new
@doc.root.each_element do |node|
if node.name == 'num'
nodes << node
node.remove!
end
end
assert_equal(3, nodes.length)
end
def test_reuse_removed_node
# Remove the node
node = @doc.root.first.remove!
refute_nil(node)
# Add it to the end of the document
@doc.root.last.next = node
assert_equal('twothreeone',
@doc.root.to_s.gsub(/\n\s*/,''))
end
def test_append_existing_node
doc = LibXML::XML::Parser.string('abfirstsecondcd').parse
node1 = doc.find_first('//two')
doc.root << node1
assert_equal('abfirstcdsecond',
doc.root.to_s)
end
def test_wrong_doc
doc1 = LibXML::XML::Parser.string('').parse
doc2 = LibXML::XML::Parser.string('').parse
node = doc1.root.child
error = assert_raises(LibXML::XML::Error) do
doc2.root << node
end
GC.start
assert_equal(' Nodes belong to different documents. You must first import the node by calling LibXML::XML::Document.import.',
error.to_s)
end
# This test is to verify that an earlier reported bug has been fixed
def test_merge
documents = []
# Read in 500 documents
500.times do
documents << LibXML::XML::Parser.string(File.read(File.join(File.dirname(__FILE__), 'model', 'merge_bug_data.xml'))).parse
end
master_doc = documents.shift
documents.each do |child_doc|
master_body = master_doc.find("//body").first
child_body = child_doc.find("//body").first
child_element = child_body.detect do |node|
node.element?
end
master_body << child_element.copy(true)
end
end
def test_append_chain
node = LibXML::XML::Node.new('foo') << LibXML::XML::Node.new('bar') << "bars contents"
assert_equal('bars contents',
node.to_s)
end
def test_set_base
@doc.root.base_uri = 'http://www.rubynet.org/'
assert_equal("\n one\n two\n three\n",
@doc.root.to_s)
end
end
libxml-ruby-3.2.1/test/test_node_xlink.rb 0000644 0000041 0000041 00000001435 13760147770 020527 0 ustar www-data www-data # encoding: UTF-8
# $Id$
require_relative './test_helper'
class TC_XML_Node_XLink < Minitest::Test
def setup()
xp = LibXML::XML::Parser.string('one')
doc = xp.parse
assert_instance_of(LibXML::XML::Document, doc)
@root = doc.root
assert_instance_of(LibXML::XML::Node, @root)
end
def teardown()
@root = nil
end
def test_xml_node_xlink()
for elem in @root.find('fixnum')
assert_instance_of(LibXML::XML::Node, elem)
assert_instance_of(TrueClass, elem.xlink?)
assert_equal("simple", elem.xlink_type_name)
assert_equal(LibXML::XML::Node::XLINK_TYPE_SIMPLE, elem.xlink_type)
end
end
end
libxml-ruby-3.2.1/test/test_namespaces.rb 0000644 0000041 0000041 00000016663 13760147770 020525 0 ustar www-data www-data # encoding: UTF-8
require_relative './test_helper'
class TestNamespaces < Minitest::Test
def setup
file = File.join(File.dirname(__FILE__), 'model/soap.xml')
@doc = LibXML::XML::Document.file(file)
end
def teardown
@doc = nil
end
def test_namespace_node
node = @doc.root
ns = node.namespaces.namespace
assert_equal('soap', ns.prefix)
assert_equal('http://schemas.xmlsoap.org/soap/envelope/', ns.href)
end
def test_namespace_attr
node = @doc.root
attr = node.attributes.get_attribute('encodingStyle')
assert_equal('soap', attr.ns.prefix)
assert_equal('soap', attr.namespaces.namespace.prefix)
end
def test_set_namespace_node
node = LibXML::XML::Node.new('Envelope')
assert_equal('', node.to_s)
ns = LibXML::XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
assert_equal("", node.to_s)
assert_nil(node.namespaces.namespace)
# Now put the node in the soap namespace
node.namespaces.namespace = ns
refute_nil(node.namespaces.namespace)
assert_equal("", node.to_s)
end
def test_set_namespace_attribute
# Create node
node = LibXML::XML::Node.new('Envelope')
assert_equal('', node.to_s)
# Create attribute
attr = LibXML::XML::Attr.new(node, "encodingStyle", "http://www.w3.org/2001/12/soap-encoding")
assert_equal('',
node.to_s)
# Create namespace attribute
ns = LibXML::XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
assert_equal('',
node.to_s)
assert_nil(node.namespaces.namespace)
# Now put the node in the soap namespace
node.namespaces.namespace = ns
refute_nil(node.namespaces.namespace)
assert_equal('',
node.to_s)
# Now put the attribute in the soap namespace
attr.namespaces.namespace = ns
refute_nil(node.namespaces.namespace)
assert_equal('',
node.to_s)
end
def test_define_namespace
node = LibXML::XML::Node.new('Envelope')
assert_equal('', node.to_s)
LibXML::XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
assert_equal("", node.to_s)
assert_nil(node.namespaces.namespace)
end
def test_define_default_namespace
node = LibXML::XML::Node.new('Envelope')
assert_equal('', node.to_s)
LibXML::XML::Namespace.new(node, nil, 'http://schemas.xmlsoap.org/soap/envelope/')
assert_equal("", node.to_s)
# This seems wrong, but appears to be the way libxml works
assert_nil(node.namespaces.namespace)
end
def test_namespaces
node = @doc.find_first('//ns1:IdAndName',
:ns1 => 'http://domain.somewhere.com')
namespaces = node.namespaces.sort
assert_equal(5, namespaces.length)
namespace = namespaces[0]
assert_instance_of(LibXML::XML::Namespace, namespace)
assert_nil(namespace.prefix)
assert_equal('http://services.somewhere.com', namespace.href)
namespace = namespaces[1]
assert_instance_of(LibXML::XML::Namespace, namespace)
assert_equal('ns1', namespace.prefix)
assert_equal('http://domain.somewhere.com', namespace.href)
namespace = namespaces[2]
assert_instance_of(LibXML::XML::Namespace, namespace)
assert_equal('soap', namespace.prefix)
assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
namespace = namespaces[3]
assert_instance_of(LibXML::XML::Namespace, namespace)
assert_equal('xsd', namespace.prefix)
assert_equal('http://www.w3.org/2001/XMLSchema', namespace.href)
namespace = namespaces[4]
assert_instance_of(LibXML::XML::Namespace, namespace)
assert_equal('xsi', namespace.prefix)
assert_equal('http://www.w3.org/2001/XMLSchema-instance', namespace.href)
end
def test_namespace_definitions
ns_defs = @doc.root.namespaces.definitions
assert_equal(3, ns_defs.size)
namespace = ns_defs[0]
assert_instance_of(LibXML::XML::Namespace, namespace)
assert_equal('soap', namespace.prefix)
assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
namespace = ns_defs[1]
assert_instance_of(LibXML::XML::Namespace, namespace)
assert_equal('xsd', namespace.prefix)
assert_equal('http://www.w3.org/2001/XMLSchema', namespace.href)
namespace = ns_defs[2]
assert_instance_of(LibXML::XML::Namespace, namespace)
assert_equal('xsi', namespace.prefix)
assert_equal('http://www.w3.org/2001/XMLSchema-instance', namespace.href)
node = @doc.root.find_first('//ns:getManufacturerNamesResponse',
:ns => 'http://services.somewhere.com')
ns_defs = node.namespaces.definitions
assert_equal(1, ns_defs.size)
namespace = ns_defs[0]
assert_instance_of(LibXML::XML::Namespace, namespace)
assert_nil(namespace.prefix)
assert_equal('http://services.somewhere.com', namespace.href)
end
def test_find_by_prefix
namespace = @doc.root.namespaces.find_by_prefix('soap')
assert_instance_of(LibXML::XML::Namespace, namespace)
assert_equal('soap', namespace.prefix)
assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
end
def test_find_default_ns
namespace = @doc.root.namespaces.find_by_prefix(nil)
assert_nil(namespace)
node = @doc.find_first('//ns1:getManufacturerNamesResponse',
:ns1 => 'http://services.somewhere.com')
namespace = node.namespaces.find_by_prefix(nil)
assert_instance_of(LibXML::XML::Namespace, namespace)
assert_nil(namespace.prefix)
assert_equal('http://services.somewhere.com', namespace.href)
end
def test_find_ns_by_href
node = @doc.find_first('//ns1:getManufacturerNamesResponse',
:ns1 => 'http://services.somewhere.com')
namespace = node.namespaces.find_by_href('http://schemas.xmlsoap.org/soap/envelope/')
assert_instance_of(LibXML::XML::Namespace, namespace)
assert_equal('soap', namespace.prefix)
assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
end
def test_default_namespace
doc = LibXML::XML::Document.string('')
ns = doc.root.namespaces.default
assert_equal(ns.href, 'http://schemas.xmlsoap.org/soap/envelope/')
end
def test_default_prefix
doc = LibXML::XML::Document.string('')
doc.root.namespaces.default_prefix = 'soap'
node = doc.root.find_first('/soap:Envelope')
refute_nil(node)
end
end
libxml-ruby-3.2.1/test/test_sax_parser.rb 0000644 0000041 0000041 00000025604 13760147770 020550 0 ustar www-data www-data # encoding: UTF-8
require_relative './test_helper'
require 'stringio'
class DocTypeCallback
include LibXML::XML::SaxParser::Callbacks
def on_start_element(element, attributes)
end
end
class TestCaseCallbacks
include LibXML::XML::SaxParser::Callbacks
attr_accessor :result
def initialize
@result = Array.new
end
def on_cdata_block(cdata)
@result << "cdata: #{cdata}"
end
def on_characters(chars)
@result << "characters: #{chars}"
end
def on_comment(text)
@result << "comment: #{text}"
end
def on_end_document
@result << "end_document"
end
def on_end_element(name)
@result << "end_element: #{name}"
end
def on_end_element_ns(name, prefix, uri)
@result << "end_element_ns #{name}, prefix: #{prefix}, uri: #{uri}"
end
# Called for parser errors.
def on_error(error)
@result << "error: #{error}"
end
def on_processing_instruction(target, data)
@result << "pi: #{target} #{data}"
end
def on_start_document
@result << "startdoc"
end
def on_start_element(name, attributes)
attributes ||= Hash.new
@result << "start_element: #{name}, attr: #{attributes.inspect}"
end
def on_start_element_ns(name, attributes, prefix, uri, namespaces)
attributes ||= Hash.new
namespaces ||= Hash.new
@result << "start_element_ns: #{name}, attr: #{attributes.inspect}, prefix: #{prefix}, uri: #{uri}, ns: #{namespaces.inspect}"
end
end
class TestSaxParser < Minitest::Test
def saxtest_file
File.join(File.dirname(__FILE__), 'model/atom.xml')
end
def verify(parser)
result = parser.callbacks.result
i = -1
assert_equal("startdoc", result[i+=1])
assert_equal("pi: xml-stylesheet type=\"text/xsl\" href=\"my_stylesheet.xsl\"", result[i+=1])
assert_equal("start_element: feed, attr: {}", result[i+=1])
assert_equal("start_element_ns: feed, attr: {}, prefix: , uri: http://www.w3.org/2005/Atom, ns: {nil=>\"http://www.w3.org/2005/Atom\"}", result[i+=1])
assert_equal("characters: \n ", result[i+=1])
assert_equal("comment: Not a valid atom entry ", result[i+=1])
assert_equal("characters: \n ", result[i+=1])
assert_equal("start_element: entry, attr: {}", result[i+=1])
assert_equal("start_element_ns: entry, attr: {}, prefix: , uri: http://www.w3.org/2005/Atom, ns: {}", result[i+=1])
assert_equal("characters: \n ", result[i+=1])
assert_equal("start_element: title, attr: {\"type\"=>\"html\"}", result[i+=1])
assert_equal("start_element_ns: title, attr: {\"type\"=>\"html\"}, prefix: , uri: http://www.w3.org/2005/Atom, ns: {}", result[i+=1])
assert_equal("cdata: <>", result[i+=1])
assert_equal("end_element: title", result[i+=1])
assert_equal("end_element_ns title, prefix: , uri: http://www.w3.org/2005/Atom", result[i+=1])
assert_equal("characters: \n ", result[i+=1])
assert_equal("start_element: content, attr: {\"type\"=>\"xhtml\"}", result[i+=1])
assert_equal("start_element_ns: content, attr: {\"type\"=>\"xhtml\"}, prefix: , uri: http://www.w3.org/2005/Atom, ns: {}", result[i+=1])
assert_equal("characters: \n ", result[i+=1])
assert_equal("start_element: xhtml:div, attr: {}", result[i+=1])
assert_equal("start_element_ns: div, attr: {}, prefix: xhtml, uri: http://www.w3.org/1999/xhtml, ns: {\"xhtml\"=>\"http://www.w3.org/1999/xhtml\"}", result[i+=1])
assert_equal("characters: \n ", result[i+=1])
assert_equal("start_element: xhtml:p, attr: {}", result[i+=1])
assert_equal("start_element_ns: p, attr: {}, prefix: xhtml, uri: http://www.w3.org/1999/xhtml, ns: {}", result[i+=1])
assert_equal("characters: hi there", result[i+=1])
assert_equal("end_element: xhtml:p", result[i+=1])
assert_equal("end_element_ns p, prefix: xhtml, uri: http://www.w3.org/1999/xhtml", result[i+=1])
assert_equal("characters: \n ", result[i+=1])
assert_equal("end_element: xhtml:div", result[i+=1])
assert_equal("end_element_ns div, prefix: xhtml, uri: http://www.w3.org/1999/xhtml", result[i+=1])
assert_equal("characters: \n ", result[i+=1])
assert_equal("end_element: content", result[i+=1])
assert_equal("end_element_ns content, prefix: , uri: http://www.w3.org/2005/Atom", result[i+=1])
assert_equal("characters: \n ", result[i+=1])
assert_equal("end_element: entry", result[i+=1])
assert_equal("end_element_ns entry, prefix: , uri: http://www.w3.org/2005/Atom", result[i+=1])
assert_equal("characters: \n", result[i+=1])
assert_equal("end_element: feed", result[i+=1])
assert_equal("end_element_ns feed, prefix: , uri: http://www.w3.org/2005/Atom", result[i+=1])
assert_equal("end_document", result[i+=1])
end
def test_file
parser = LibXML::XML::SaxParser.file(saxtest_file)
parser.callbacks = TestCaseCallbacks.new
parser.parse
verify(parser)
end
def test_file_no_callbacks
parser = LibXML::XML::SaxParser.file(saxtest_file)
assert_equal true, parser.parse
end
def test_noexistent_file
error = assert_raises(LibXML::XML::Error) do
LibXML::XML::SaxParser.file('i_dont_exist.xml')
end
assert_equal('Warning: failed to load external entity "i_dont_exist.xml".', error.to_s)
end
def test_nil_file
error = assert_raises(TypeError) do
LibXML::XML::SaxParser.file(nil)
end
assert_match(/nil into String/, error.to_s)
end
def test_io
File.open(saxtest_file) do |file|
parser = LibXML::XML::SaxParser.io(file)
parser.callbacks = TestCaseCallbacks.new
parser.parse
verify(parser)
end
end
def test_nil_io
error = assert_raises(TypeError) do
LibXML::XML::HTMLParser.io(nil)
end
assert_equal("Must pass in an IO object", error.to_s)
end
def test_string_no_callbacks
xml = File.read(saxtest_file)
parser = LibXML::XML::SaxParser.string(xml)
assert_equal true, parser.parse
end
def test_string
xml = File.read(saxtest_file)
parser = LibXML::XML::SaxParser.string(xml)
parser.callbacks = TestCaseCallbacks.new
parser.parse
verify(parser)
end
def test_string_io
xml = File.read(saxtest_file)
io = StringIO.new(xml)
parser = LibXML::XML::SaxParser.io(io)
parser.callbacks = TestCaseCallbacks.new
parser.parse
verify(parser)
end
def test_nil_string
error = assert_raises(TypeError) do
LibXML::XML::SaxParser.string(nil)
end
assert_equal("wrong argument type nil (expected String)", error.to_s)
end
def test_doctype
xml = <<-EOS
a1
EOS
parser = LibXML::XML::SaxParser.string(xml)
parser.callbacks = DocTypeCallback.new
doc = parser.parse
refute_nil(doc)
end
def test_parse_warning
# Two xml PIs is a warning
xml = <<-EOS
EOS
parser = LibXML::XML::SaxParser.string(xml)
parser.callbacks = TestCaseCallbacks.new
parser.parse
# Check callbacks
result = parser.callbacks.result
i = -1
assert_equal("startdoc", result[i+=1])
assert_equal("error: Warning: xmlParsePITarget: invalid name prefix 'xml' at :2.", result[i+=1])
assert_equal("pi: xml-invalid ", result[i+=1])
assert_equal("start_element: Test, attr: {}", result[i+=1])
assert_equal("start_element_ns: Test, attr: {}, prefix: , uri: , ns: {}", result[i+=1])
assert_equal("end_element: Test", result[i+=1])
assert_equal("end_element_ns Test, prefix: , uri: ", result[i+=1])
assert_equal("end_document", result[i+=1])
end
def test_parse_error
xml = <<-EOS
EOS
parser = LibXML::XML::SaxParser.string(xml)
parser.callbacks = TestCaseCallbacks.new
error = assert_raises(LibXML::XML::Error) do
parser.parse
end
# Check callbacks
result = parser.callbacks.result
i = -1
assert_equal("startdoc", result[i+=1])
assert_equal("start_element: Results, attr: {}", result[i+=1])
assert_equal("start_element_ns: Results, attr: {}, prefix: , uri: , ns: {}", result[i+=1])
assert_equal("characters: \n", result[i+=1])
assert_equal("error: Fatal error: EndTag: '
AQUALIA THERMAL Lichte cr├иme - Versterkende & kalmerende 24 u hydraterende verzorging
Huid wordt continu gehydrateerd, intens versterkt en gekalmeerd.
Hypoallergeen. Geschikt voor de gevoelige huid.
01.EFFECTIVITEIT
Intensief gehydrateerd, de huid voelt gekalmeerd. Ze voelt de hele dag soepel en fluweelzacht aan, zonder een trekkerig gevoel. De huid is elastischer, soepeler en stralender. Doeltreffendheid getest onder dermatologisch toezicht.
02.GEBRUIK
's Morgens en/ of 's avonds aanbrengen.
03.ACTIEVE INGREDIENTEN
Technologische innovatie: 24 u continue cellulaire vochtnevel. Voor de 1ste keer worden Thermaal Bronwater van Vichy, rijk aan zeldzame mineralen en Actief HyaluronineтДв verwerkt in microcapsules, die deze vervolgens verspreiden in de cellen.
04.TEXTUUR
De lichte cr├иme is verfrissend en trekt makkelijk in. Niet vet en niet kleverig. Zonder 'maskereffect'.
'
xp = LibXML::XML::HTMLParser.string(str)
assert_instance_of(LibXML::XML::HTMLParser, xp)
assert_instance_of(LibXML::XML::HTMLParser, xp)
doc = xp.parse
assert_instance_of(LibXML::XML::Document, doc)
end
def test_nil_string
error = assert_raises(TypeError) do
LibXML::XML::HTMLParser.string(nil)
end
assert_equal("wrong argument type nil (expected String)", error.to_s)
end
def test_parse
html = <<-EOS
Hello World
EOS
parser = LibXML::XML::HTMLParser.string(html, :options => LibXML::XML::HTMLParser::Options::NOBLANKS)
doc = parser.parse
assert_instance_of LibXML::XML::Document, doc
root = doc.root
assert_instance_of LibXML::XML::Node, root
assert_equal 'html', root.name
head = root.child
assert_instance_of LibXML::XML::Node, head
assert_equal 'head', head.name
meta = head.child
assert_instance_of LibXML::XML::Node, meta
assert_equal 'meta', meta.name
assert_equal 'keywords', meta[:name]
assert_equal 'nasty', meta[:content]
body = head.next
assert_instance_of LibXML::XML::Node, body
assert_equal 'body', body.name
hello = body.child
# It appears that some versions of libxml2 add a layer of
# cant figure our why or how, so this skips it if there
hello = hello.child if hello.name == "p"
assert_instance_of LibXML::XML::Node, hello
assert_equal 'Hello', hello.content
br = hello.next
assert_instance_of LibXML::XML::Node, br
assert_equal 'br', br.name
world = br.next
assert_instance_of LibXML::XML::Node, world
assert_equal 'World', world.content
end
def test_no_implied
html = "hello world"
parser = LibXML::XML::HTMLParser.string(html, :options => LibXML::XML::HTMLParser::Options::NOIMPLIED)
doc = parser.parse
assert_equal("
#{html}
", doc.root.to_s)
end
def test_comment
doc = LibXML::XML::HTMLParser.string('', :options => LibXML::XML::HTMLParser::Options::NOIMPLIED |
LibXML::XML::HTMLParser::Options::NOERROR |
LibXML::XML::HTMLParser::Options::NOWARNING |
LibXML::XML::HTMLParser::Options::RECOVER |
LibXML::XML::HTMLParser::Options::NONET)
assert(doc)
end
def test_open_many_files
file = File.expand_path(File.join(File.dirname(__FILE__), 'model/ruby-lang.html'))
1000.times do
LibXML::XML::HTMLParser.file(file).parse
end
end
end
libxml-ruby-3.2.1/test/test_node.rb 0000644 0000041 0000041 00000014464 13760147770 017330 0 ustar www-data www-data # encoding: UTF-8
require_relative './test_helper'
class TestNode < Minitest::Test
def setup
@file_name = "model/bands.utf-8.xml"
# Strip spaces to make testing easier
LibXML::XML.default_keep_blanks = false
file = File.join(File.dirname(__FILE__), @file_name)
@doc = LibXML::XML::Document.file(file)
end
def teardown
LibXML::XML.default_keep_blanks = true
@doc = nil
end
def nodes
# Find all nodes with a country attributes
@doc.find('*[@country]')
end
def test_doc_class
assert_instance_of(LibXML::XML::Document, @doc)
end
def test_doc_node_type
assert_equal LibXML::XML::Node::DOCUMENT_NODE, @doc.node_type
end
def test_root_class
assert_instance_of(LibXML::XML::Node, @doc.root)
end
def test_root_node_type
assert_equal LibXML::XML::Node::ELEMENT_NODE, @doc.root.node_type
end
def test_node_class
for n in nodes
assert_instance_of(LibXML::XML::Node, n)
end
end
def test_context
node = @doc.root
context = node.context
assert_instance_of(LibXML::XML::XPath::Context, context)
end
def test_find
assert_instance_of(LibXML::XML::XPath::Object, self.nodes)
end
def test_node_child_get
assert_instance_of(TrueClass, @doc.root.child?)
assert_instance_of(LibXML::XML::Node, @doc.root.child)
assert_equal(Encoding::UTF_8, @doc.root.child.name.encoding)
assert_equal("m\u00F6tley_cr\u00FCe", @doc.root.child.name)
end
def test_node_doc
for n in nodes
assert_instance_of(LibXML::XML::Document, n.doc) if n.document?
end
end
def test_name
node = @doc.root.children.last
assert_equal("iron_maiden", node.name)
end
def test_node_find
nodes = @doc.root.find('./fixnum')
for node in nodes
assert_instance_of(LibXML::XML::Node, node)
end
end
def test_equality
node_a = @doc.find_first('*[@country]')
node_b = @doc.root.child
# On the ruby side these are different objects
refute(node_a.equal?(node_b))
# But they are the same underlying libxml node so specify they are equal
assert(node_a == node_b)
assert(node_a.eql?(node_b))
file = File.join(File.dirname(__FILE__), @file_name)
doc2 = LibXML::XML::Document.file(file)
node_a2 = doc2.find_first('*[@country]')
refute(node_a == node_a2)
refute(node_a.eql?(node_a2))
assert_equal(node_a.to_s, node_a2.to_s)
refute(node_a.equal?(node_a2))
end
def test_equality_2
parent = LibXML::XML::Node.new('parent')
child = LibXML::XML::Node.new('child')
parent << child
node_a = child.parent
node_b = child.parent
# In this case the nodes are equal - the parent being the root
assert(node_a.equal?(node_b))
assert(node_a == node_b)
assert(node_a.eql?(node_b))
end
def test_equality_nil
node = @doc.root
assert(node != nil)
end
def test_equality_wrong_type
node = @doc.root
assert_raises(TypeError) do
assert(node != 'abc')
end
end
def test_content
node = @doc.root.last
assert_equal("Iron Maiden is a British heavy metal band formed in 1975.",
node.content)
end
def test_base
doc = LibXML::XML::Parser.string('').parse
assert_nil(doc.root.base_uri)
end
# We use the same facility that libXSLT does here to disable output escaping.
# This lets you specify that the node's content should be rendered unaltered
# whenever it is being output. This is useful for things like