libxml-ruby 3.2.2-x64-mingw-ucrt

data/test/test_xml.rb

@@ -0,0 +1,263 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+require 'stringio'
+
+class TestXml < Minitest::Test
+  # -----  Constants  ------
+  def test_lib_versions
+    assert(LibXML::XML.check_lib_versions)
+  end
+
+  def test_debug_entities
+    original = LibXML::XML.debug_entities
+
+    LibXML::XML.debug_entities = false
+    refute(LibXML::XML.debug_entities)
+
+    LibXML::XML.debug_entities = true
+    assert(LibXML::XML.debug_entities)
+
+    LibXML::XML.debug_entities = false
+    refute(LibXML::XML.debug_entities)
+
+    LibXML::XML.debug_entities = original
+  end
+
+  def test_default_compression
+    return unless LibXML::XML.default_compression
+
+    original = LibXML::XML.default_compression
+
+    0.upto(9) do |i|
+      LibXML::XML.default_compression = i
+      assert_equal(i, LibXML::XML.default_compression)
+    end
+
+    9.downto(0) do |i|
+      assert_equal(i, LibXML::XML.default_compression = i)
+      assert_equal(i, LibXML::XML.default_compression)
+    end
+
+    0.downto(-10) do |i|
+      assert_equal(i, LibXML::XML.default_compression = i)
+      assert_equal(0, LibXML::XML.default_compression)
+    end
+
+    10.upto(20) do |i|
+      assert_equal(i, LibXML::XML.default_compression = i)
+      assert_equal(9, LibXML::XML.default_compression)
+    end
+
+    LibXML::XML.default_compression = original
+  end
+
+  def test_default_keep_blanks
+    original = LibXML::XML.default_keep_blanks
+
+    LibXML::XML.default_keep_blanks = false
+    refute(LibXML::XML.default_keep_blanks)
+    assert_equal(LibXML::XML::Parser::Options::NOBLANKS, LibXML::XML.default_options)
+
+    LibXML::XML.default_keep_blanks = true
+    assert(LibXML::XML.default_keep_blanks)
+    assert_equal(0, LibXML::XML.default_options)
+
+    LibXML::XML.default_keep_blanks = original
+  end
+
+  def test_default_line_numbers
+    original = LibXML::XML.default_line_numbers
+
+    LibXML::XML.default_line_numbers = false
+    refute(LibXML::XML.default_line_numbers)
+
+    LibXML::XML.default_line_numbers = true
+    assert(LibXML::XML.default_line_numbers)
+
+    LibXML::XML.default_line_numbers = false
+    refute(LibXML::XML.default_line_numbers)
+
+    LibXML::XML.default_line_numbers = original
+  end
+
+  def test_default_substitute_entities
+    original = LibXML::XML.default_substitute_entities
+
+    LibXML::XML.default_substitute_entities = false
+    refute(LibXML::XML.default_substitute_entities)
+    assert_equal(0, LibXML::XML.default_options)
+
+    LibXML::XML.default_substitute_entities = true
+    assert(LibXML::XML.default_substitute_entities)
+    assert_equal(LibXML::XML::Parser::Options::NOENT, LibXML::XML.default_options)
+
+    LibXML::XML.default_substitute_entities = false
+    refute(LibXML::XML.default_substitute_entities)
+
+    LibXML::XML.default_substitute_entities = original
+  end
+
+  def test_default_tree_indent_string
+    original = LibXML::XML.default_tree_indent_string
+
+    s = LibXML::XML.default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('  ', s)
+    LibXML::XML.default_tree_indent_string = 'uga'
+    s = LibXML::XML.default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('uga', s)
+    LibXML::XML.default_tree_indent_string = '  '
+    s = LibXML::XML.default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('  ', s)
+
+    LibXML::XML.default_tree_indent_string = original
+  end
+
+  def test_default_validity_checking
+    original = LibXML::XML.default_validity_checking
+
+    LibXML::XML.default_validity_checking = false
+    refute(LibXML::XML.default_validity_checking)
+    assert_equal(0, LibXML::XML.default_options)
+
+    LibXML::XML.default_validity_checking = true
+    assert(LibXML::XML.default_validity_checking)
+    assert_equal(LibXML::XML::Parser::Options::DTDVALID, LibXML::XML.default_options)
+
+    LibXML::XML.default_validity_checking = false
+    refute(LibXML::XML.default_validity_checking)
+
+    LibXML::XML.default_validity_checking = original
+  end
+
+  def test_default_warnings
+    original = LibXML::XML.default_warnings
+
+    LibXML::XML.default_warnings = false
+    refute(LibXML::XML.default_warnings)
+    assert_equal(LibXML::XML::Parser::Options::NOWARNING, LibXML::XML.default_options)
+
+    LibXML::XML.default_warnings = true
+    assert(LibXML::XML.default_warnings)
+    assert_equal(0, LibXML::XML.default_options)
+
+    LibXML::XML.default_warnings = false
+    refute(LibXML::XML.default_warnings)
+
+    LibXML::XML.default_warnings = original
+  end
+
+  def test_enabled_automata
+    assert(LibXML::XML.enabled_automata?)
+  end
+
+  def test_enabled_c14n
+    assert(LibXML::XML.enabled_c14n?)
+  end
+
+  def test_enabled_catalog
+    assert(LibXML::XML.enabled_catalog?)
+  end
+
+  def test_enabled_debug
+    assert(LibXML::XML.enabled_debug?)
+  end
+
+  def test_enabled_docbook
+    assert(LibXML::XML.enabled_docbook?)
+  end
+
+  def test_enabled_ftp
+    assert(LibXML::XML.enabled_ftp?)
+  end
+
+  def test_enabled_http
+    assert(LibXML::XML.enabled_http?)
+  end
+
+  def test_enabled_html
+    assert(LibXML::XML.enabled_html?)
+  end
+
+  def test_enabled_iconv
+    iconv_enabled = RUBY_PLATFORM !~ /darwin/
+    assert_equal(iconv_enabled, LibXML::XML.enabled_iconv?)
+  end
+
+  def test_enabled_memory_debug
+    assert_equal(false, LibXML::XML.enabled_memory_debug?)
+  end
+
+  def test_enabled_regexp
+    assert(LibXML::XML.enabled_regexp?)
+  end
+
+  def test_enabled_schemas
+    assert(LibXML::XML.enabled_schemas?)
+  end
+
+  def test_enabled_thread
+    assert(LibXML::XML.enabled_thread?)
+  end
+
+  def test_enabled_unicode
+    assert(LibXML::XML.enabled_unicode?)
+  end
+
+  def test_enabled_xinclude
+    assert(LibXML::XML.enabled_xinclude?)
+  end
+
+  def test_enabled_xpath
+    assert(LibXML::XML.enabled_xpath?)
+  end
+
+  def test_enabled_xpointer
+    assert(LibXML::XML.enabled_xpointer?)
+  end
+
+  def test_enabled_zlib
+    assert(LibXML::XML.enabled_zlib?.is_a?(TrueClass) || LibXML::XML.enabled_zlib?.is_a?(FalseClass))
+  end
+
+  def test_intent_tree_output
+    assert(TrueClass, LibXML::XML.indent_tree_output)
+
+    LibXML::XML.indent_tree_output = false
+    assert(FalseClass, LibXML::XML.indent_tree_output)
+
+    LibXML::XML.indent_tree_output = true
+    assert(TrueClass, LibXML::XML.indent_tree_output)
+  end
+
+  def test_version
+    assert_instance_of(String, LibXML::XML::VERSION)
+  end
+
+  def test_vernum
+    assert_instance_of(Integer, LibXML::XML::VERNUM)
+  end
+
+  def test_libxml_parser_features
+    assert_instance_of(Array, LibXML::XML.features)
+  end
+
+  def test_default_options
+    assert_equal(0, LibXML::XML.default_options)
+  end
+
+  def test_default_save_no_empty_tags
+    original = LibXML::XML.default_save_no_empty_tags
+
+    LibXML::XML.default_save_no_empty_tags = false
+    refute(LibXML::XML.default_save_no_empty_tags)
+
+    LibXML::XML.default_save_no_empty_tags = true
+    assert(LibXML::XML.default_save_no_empty_tags)
+
+    LibXML::XML.default_save_no_empty_tags = original
+  end
+end

data/test/test_xpath.rb

@@ -0,0 +1,244 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+require 'tempfile'
+
+class TestXPath < Minitest::Test
+  def setup
+    @doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def test_doc_find
+    nodes = @doc.find('/soap:Envelope')
+    assert_instance_of(LibXML::XML::XPath::Object, nodes)
+    assert_equal(1, nodes.length)
+    assert_equal(nodes.xpath_type, LibXML::XML::XPath::NODESET)
+  end
+
+  def test_doc_find_first
+    node = @doc.find_first('/soap:Envelope/soap:Body')
+    assert_instance_of(LibXML::XML::Node, node)
+  end
+
+  def test_ns
+    nodes = @doc.find('//ns1:IdAndName', 'ns1:http://domain.somewhere.com')
+    assert_equal(3, nodes.length)
+  end
+
+  def test_ns_gc
+    _stress = GC.stress
+    GC.stress = true
+
+    doc = LibXML::XML::Document.string('<foo xmlns="http://bar.com" />')
+    node = doc.root
+    # This line segfaults on prior versions of libxml-ruby
+    node.find("namespace::*")
+
+    GC.stress = _stress
+  end
+
+  def test_ns_array
+    nodes = @doc.find('//ns1:IdAndName', ['ns1:http://domain.somewhere.com'])
+    assert_equal(3, nodes.length)
+  end
+
+  def test_default_ns1
+    # Find all nodes with http://services.somewhere.com namespace
+    nodes = @doc.find('//*[namespace-uri()="http://services.somewhere.com"]')
+    assert_equal(2, nodes.length)
+    assert_equal('getManufacturerNamesResponse', nodes[0].name)
+    assert_equal('IDAndNameList', nodes[1].name)
+  end
+
+  def test_default_ns2
+    # Find all nodes with http://services.somewhere.com namespace
+    nodes = @doc.find('//ns:*', 'ns:http://services.somewhere.com')
+    assert_equal(2, nodes.length)
+    assert_equal('getManufacturerNamesResponse', nodes[0].name)
+    assert_equal('IDAndNameList', nodes[1].name)
+
+    # Get getManufacturerNamesResponse node
+    nodes = @doc.find('//ns:getManufacturerNamesResponse', 'ns:http://services.somewhere.com')
+    assert_equal(1, nodes.length)
+
+    # Get IdAndName node
+    nodes = @doc.find('/soap:Envelope/soap:Body/ns0:getManufacturerNamesResponse/ns0:IDAndNameList/ns1:IdAndName',
+                      ['ns0:http://services.somewhere.com', 'ns1:http://domain.somewhere.com'])
+    assert_equal(3, nodes.length)
+  end
+
+  def test_default_ns3
+    # Find all nodes with http://services.somewhere.com namespace
+    nodes = @doc.find('//ns:*', 'ns' => 'http://services.somewhere.com')
+    assert_equal(2, nodes.length)
+    assert_equal('getManufacturerNamesResponse', nodes[0].name)
+    assert_equal('IDAndNameList', nodes[1].name)
+  end
+
+  def test_default_ns4
+    # Find all nodes with http://services.somewhere.com namespace
+    nodes = @doc.find('//ns:*', :ns => 'http://services.somewhere.com')
+    assert_equal(2, nodes.length)
+    assert_equal('getManufacturerNamesResponse', nodes[0].name)
+    assert_equal('IDAndNameList', nodes[1].name)
+  end
+
+  def test_default_ns5
+    # Find all nodes with http://services.somewhere.com namespace
+    LibXML::XML::Namespace.new(@doc.root, 'ns', 'http://services.somewhere.com')
+    nodes = @doc.find('//ns:*')
+    assert_equal(2, nodes.length)
+    assert_equal('getManufacturerNamesResponse', nodes[0].name)
+    assert_equal('IDAndNameList', nodes[1].name)
+  end
+
+  def test_attribute_ns
+    # Pull all nodes with http://services.somewhere.com namespace
+    nodes = @doc.find('@soap:encodingStyle')
+    assert_equal(1, nodes.length)
+    assert_equal('encodingStyle', nodes.first.name)
+    assert_equal('http://www.w3.org/2001/12/soap-encoding', nodes.first.value)
+  end
+
+  def test_register_default_ns
+    doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/atom.xml'))
+
+    # No namespace has been yet defined
+    assert_raises(LibXML::XML::Error) do
+      doc.find("atom:title")
+    end
+
+    node = doc.find('atom:title', 'atom:http://www.w3.org/2005/Atom')
+    refute_nil(node)
+
+    # Register namespace
+    doc.root.namespaces.default_prefix = 'atom'
+    node = doc.find("atom:title")
+    refute_nil(node)
+  end
+
+  def test_node_find
+    nodes = @doc.find('//ns1:IdAndName', 'ns1:http://domain.somewhere.com')
+    node = nodes.first
+
+    # Since we are searching on the node, don't have to register namespace
+    nodes = node.find('ns1:name')
+    assert_equal(1, nodes.length)
+		refute_equal(nodes.first.object_id, nodes.last.object_id)
+    assert_equal('name', nodes.first.name)
+    assert_equal('man1', nodes.first.content)
+  end
+
+  def test_node_find_first
+    node = @doc.find_first('//ns1:IdAndName', 'ns1:http://domain.somewhere.com')
+
+    # Since we are searching on the node, don't have to register namespace
+    node = node.find_first('ns1:name')
+    assert_equal('name', node.name)
+    assert_equal('man1', node.content)
+  end
+
+  def test_node_no_doc
+    node = LibXML::XML::Node.new('header', 'some content')
+    assert_raises(TypeError) do
+      node = node.find_first('/header')
+    end
+  end
+
+  def test_memory
+    # This sometimes causes a segmentation fault because
+    # an xml document is sometimes freed before the
+    # xpath_object used to query it.  When the xpath_object
+    # is free, it iterates over its results which are pointers
+    # to the document's nodes. A segmentation fault then happens.
+
+    1000.times do
+      doc = LibXML::XML::Document.new('1.0')
+      doc.root = LibXML::XML::Node.new("header")
+
+      1000.times do
+        doc.root << LibXML::XML::Node.new("footer")
+      end
+
+      doc.find('/header/footer')
+    end
+  end
+
+  # Test that document doesn't get freed before nodes
+  def test_xpath_free
+    doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+    nodes = doc.find('//*')
+    GC.start
+    assert_equal('Envelope', nodes.first.name)
+  end
+
+  def test_xpath_namespace_nodes
+    doc = LibXML::XML::Document.string('<feed xmlns="http://www.w3.org/2005/Atom" xmlns:xhtml="http://www.w3.org/1999/xhtml"><entry/></feed>')
+    nodes = doc.find('//atom:entry|namespace::*', :atom => "http://www.w3.org/2005/Atom")
+    assert_equal(4, nodes.length)
+
+    node = nodes[0]
+    assert_equal(LibXML::XML::Node::ELEMENT_NODE, node.node_type)
+
+    node = nodes[1]
+    assert_equal(LibXML::XML::Node::NAMESPACE_DECL, node.node_type)
+
+    node = nodes[2]
+    assert_equal(LibXML::XML::Node::NAMESPACE_DECL, node.node_type)
+
+    node = nodes[3]
+    assert_equal(LibXML::XML::Node::NAMESPACE_DECL, node.node_type)
+  end
+
+	# Test to make sure we don't get nil on empty results.
+	# This is also to test that we don't segfault due to our C code getting a NULL pointer
+	# and not handling it properly.
+	def test_xpath_empty_result
+    doc = LibXML::XML::Document.string('<html><body><p>Welcome to XHTML land!</p></body></html>')
+		nodes = doc.find("//object/param[translate(@name, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz') = 'wmode']")
+		refute_nil nodes
+	end
+
+  def test_invalid_expression
+    xml = LibXML::XML::Document.string('<a></a>')
+
+    # Using the expression twice used to cause a Segmentation Fault
+    error = assert_raises(LibXML::XML::Error) do
+      xml.find('//a/')
+    end
+    assert_equal("Error: Invalid expression.", error.to_s)
+
+    # Try again - this used to cause a Segmentation Fault
+    error = assert_raises(LibXML::XML::Error) do
+      xml.find('//a/')
+    end
+    assert_equal("Error: Invalid expression.", error.to_s)
+  end
+
+  def test_find_cdata
+    doc = LibXML::XML::Document.string('<root>hi there <![CDATA[ mycdata ]]> bye!</root>')
+
+    nodes = doc.find('/root/text()')
+    assert_equal(3, nodes.length)
+    assert_equal(nodes[0].node_type, LibXML::XML::Node::TEXT_NODE)
+    assert_equal(nodes[0].content, 'hi there ')
+
+    assert_equal(nodes[1].node_type, LibXML::XML::Node::CDATA_SECTION_NODE)
+    assert_equal(nodes[1].content, ' mycdata ')
+
+    assert_equal(nodes[2].node_type, LibXML::XML::Node::TEXT_NODE)
+    assert_equal(nodes[2].content, ' bye!')
+  end
+
+  def test_find_comment
+    doc = LibXML::XML::Document.string('<root>hi there <!-- my comment --> bye!</root>')
+
+    nodes = doc.find('//comment()')
+    assert_equal(1, nodes.length)
+    assert_equal(nodes[0].content, ' my comment ')
+  end
+end

data/test/test_xpath_context.rb

@@ -0,0 +1,88 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+require "tempfile"
+
+class TestXPathContext < Minitest::Test
+  SOAP_PREFIX = 'soap'
+  SOAP_URI = 'http://schemas.xmlsoap.org/soap/envelope/'
+  
+  NS0_PREFIX = 'ns0'
+  NS0_URI = 'http://services.somewhere.com'
+  
+  def setup
+    doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+    @context = LibXML::XML::XPath::Context.new(doc)
+  end
+  
+  def teardown()
+    @context = nil
+  end
+  
+  def test_no_ns
+    error = assert_raises(LibXML::XML::Error) do
+      @context.find('/soap:Envelope')
+    end
+    assert_equal("Error: Undefined namespace prefix.", error.to_s)
+  end    
+
+  def test_ns_register
+    @context.register_namespace(SOAP_PREFIX, SOAP_URI)
+    @context.register_namespace(NS0_PREFIX, NS0_URI)
+    nodes = @context.find('/soap:Envelope/soap:Body/ns0:getManufacturerNamesResponse')
+    assert_equal(1, nodes.length)
+  end
+      
+  def test_ns_register_string
+    @context.register_namespaces("#{SOAP_PREFIX}:#{SOAP_URI}")
+    @context.register_namespaces("#{NS0_PREFIX}:#{NS0_URI}")
+    nodes = @context.find('/soap:Envelope/soap:Body/ns0:getManufacturerNamesResponse')
+    assert_equal(1, nodes.length)
+  end
+      
+  def test_ns_register_array
+    @context.register_namespaces(["#{SOAP_PREFIX}:#{SOAP_URI}", "#{NS0_PREFIX}:#{NS0_URI}"])
+    nodes = @context.find('/soap:Envelope/soap:Body/ns0:getManufacturerNamesResponse')
+    assert_equal(1, nodes.length)
+  end
+  
+  def test_ns_register_hash
+    @context.register_namespaces(SOAP_PREFIX => SOAP_URI,
+                                 NS0_PREFIX => NS0_URI)
+
+    nodes = @context.find('/soap:Envelope/soap:Body/ns0:getManufacturerNamesResponse')
+    assert_equal(1, nodes.length)
+  end
+
+  def test_ns_register_node
+    @context.register_namespaces_from_node(@context.doc.root)
+    nodes = @context.find('/soap:Envelope')
+    assert_equal(1, nodes.length)
+  end
+  
+  def test_node
+    @context.register_namespaces_from_node(@context.doc.root)
+    
+    nodes = @context.find('soap:Body')
+    assert_equal(0, nodes.length)
+    
+    
+    @context.node = @context.doc.root.child.next
+    nodes = @context.find('soap:Body')
+    assert_equal(0, nodes.length)
+  end
+
+  def test_cache
+    @context.enable_cache
+    @context.enable_cache(10)
+    @context.disable_cache
+  end
+
+  def test_require_doc
+    doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+    error = assert_raises(TypeError) do
+      @context = LibXML::XML::XPath::Context.new(doc.root)
+    end
+    assert_equal("Supplied argument must be a document or node.", error.to_s)
+  end
+end

data/test/test_xpath_expression.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+
+class TestXPathExpression < Minitest::Test
+  def setup
+    xp = LibXML::XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    @doc = xp.parse
+  end
+  
+  def teardown
+    @doc = nil
+  end
+
+  def test_nodes
+    expr = LibXML::XML::XPath::Expression.compile('/ruby_array/fixnum')
+    set = @doc.find(expr)
+    assert_instance_of(LibXML::XML::XPath::Object, set)
+    assert_equal(2, set.size)
+  end
+
+  def test_find_class
+    expr = LibXML::XML::XPath::Expression.new('/ruby_array/fixnum')
+    set = @doc.find(expr)
+    assert_instance_of(LibXML::XML::XPath::Object, set)
+    assert_equal(2, set.size)
+  end
+
+  def test_find_invalid
+    error = assert_raises(TypeError) do
+      @doc.find(999)
+    end
+    assert_equal('Argument should be an instance of a String or XPath::Expression',
+                 error.to_s)
+  end
+end

data/test/test_xpointer.rb

@@ -0,0 +1,72 @@
+# encoding: UTF-8
+require_relative './test_helper'
+
+class TC_XML_XPointer < Minitest::Test
+  def setup()
+    xp = LibXML::XML::Parser.string('<!DOCTYPE ra [<!ELEMENT ra (foo+)><!ATTLIST ra id ID #IMPLIED><!ELEMENT foo (#PCDATA)><!ATTLIST foo id ID #IMPLIED>]><ra id="start"><foo id="one">one</foo><foo id="two">two</foo><foo id="three">three</foo></ra>')
+    @doc = xp.parse
+    assert_instance_of(LibXML::XML::Document, @doc)
+    @root = @doc.root
+    assert_instance_of(LibXML::XML::Node, @root)
+  end
+
+  def teardown()
+    @doc = nil
+    @root = nil
+    @xptr = nil
+  end
+
+  def test_libxml_xpointer_id
+    xptr = @root.pointer('xpointer(id("two"))')
+    assert_instance_of(LibXML::XML::XPath::Object, xptr)
+    xptr.each do |node|
+      # It seems from the spec that the pointer should
+      # be the whole node, rather than just the ID attr.
+      assert_equal('two', node.content)
+      assert_instance_of(LibXML::XML::Node, node)
+      assert_equal('two', node['id'])
+    end
+
+    # FIXME: Not sure at all about this kind of range
+    if ENV['NOTWORKING']
+      @xptr = @root.pointer('xpointer(id("two")) xpointer(id("three"))')
+      assert_instance_of(LibXML::XML::XPath, @xptr)
+      assert_instance_of(LibXML::XML::Node::Set, @xptr.set)
+      assert_equal(2, @xptr.set.length)
+      for n in @xptr.set
+        assert_match(/two|three/, n.to_s)
+      end
+    end
+  end
+
+  # FIXME: There is a bug in these ranges...
+  if ENV['NOTWORKING']
+    def test_libxml_xpointer_range()
+      nstart = nend = nil
+      @xptr = @root.pointer('xpointer(id("one"))').set
+      @xptr.each{|n| nstart = n}
+      assert_instance_of(LibXML::XML::Node, nstart)
+      @xptr = @root.pointer('xpointer(id("three"))').set
+      @xptr.each{|n| nend = n}
+      assert_instance_of(LibXML::XML::Node, nend)
+      range = LibXML::XML::XPointer.range(nstart, nend)
+      assert_instance_of(LibXML::XML::XPath, range)
+      assert_instance_of(LibXML::XML::Node::Set, range.set)
+
+      for n in range.set
+        assert_match(/one|two|three/, n.to_s)
+      end
+      assert_equal(3, range.set.length)
+    end
+  end
+
+#  def test_libxml_xpointer_start_point()
+#    @xptr = @root.pointer('xpointer(start-point("one"))')
+#    assert_instance_of(LibXML::XML::XPath, @xptr)
+#    set = @xptr.set
+#    assert_instance_of(LibXML::XML::Node::Set, set)
+#    for n in set
+#      assert_match(/one|two|three/, n.to_s)
+#    end
+#  end
+end