libxml-ruby 4.1.2-x64-mingw-ucrt → 5.0.1-x64-mingw-ucrt

data/lib/libxml/html_parser.rb

@@ -5,31 +5,31 @@ module LibXML
     class HTMLParser
       # call-seq:
       #    XML::HTMLParser.file(path) -> XML::HTMLParser
-      #    XML::HTMLParser.file(path, :encoding => XML::Encoding::UTF_8,
-      #                           :options => XML::HTMLParser::Options::NOENT) -> XML::HTMLParser
+      #    XML::HTMLParser.file(path, encoding: XML::Encoding::UTF_8,
+      #                               options: XML::HTMLParser::Options::NOENT) -> XML::HTMLParser
       #
       # Creates a new parser by parsing the specified file or uri.
       #
-      # You may provide an optional hash table to control how the
-      # parsing is performed.  Valid options are:
+      # Parameters:
       #
+      #  path - Path to file to parse
       #  encoding - The document encoding, defaults to nil. Valid values
       #             are the encoding constants defined on XML::Encoding.
       #  options - Parser options.  Valid values are the constants defined on
       #            XML::HTMLParser::Options.  Mutliple options can be combined
       #            by using Bitwise OR (|).
-      def self.file(path, options = {})
+      def self.file(path, encoding: nil, options: nil)
         context = XML::HTMLParser::Context.file(path)
-        context.encoding = options[:encoding] if options[:encoding]
-        context.options = options[:options] if options[:options]
+        context.encoding = encoding if encoding
+        context.options = options if options
         self.new(context)
       end
 
       # call-seq:
       #    XML::HTMLParser.io(io) -> XML::HTMLParser
-      #    XML::HTMLParser.io(io, :encoding => XML::Encoding::UTF_8,
-      #                       :options => XML::HTMLParser::Options::NOENT
-      #                       :base_uri="http://libxml.org") -> XML::HTMLParser
+      #    XML::HTMLParser.io(io, encoding: XML::Encoding::UTF_8,
+      #                           options: XML::HTMLParser::Options::NOENT
+      #                           base_uri: "http://libxml.org") -> XML::HTMLParser
       #
       # Creates a new reader by parsing the specified io object.
       #
@@ -42,36 +42,36 @@ module LibXML
       #  options - Parser options.  Valid values are the constants defined on
       #            XML::HTMLParser::Options.  Mutliple options can be combined
       #            by using Bitwise OR (|).
-      def self.io(io, options = {})
+      def self.io(io, base_uri: nil, encoding: nil, options: nil)
         context = XML::HTMLParser::Context.io(io)
-        context.base_uri = options[:base_uri] if options[:base_uri]
-        context.encoding = options[:encoding] if options[:encoding]
-        context.options = options[:options] if options[:options]
+        context.base_uri = base_uri if base_uri
+        context.encoding = encoding if encoding
+        context.options = options if options
         self.new(context)
       end
 
       # call-seq:
       #    XML::HTMLParser.string(string)
-      #    XML::HTMLParser.string(string, :encoding => XML::Encoding::UTF_8,
-      #                               :options => XML::HTMLParser::Options::NOENT
-      #                               :base_uri="http://libxml.org") -> XML::HTMLParser
+      #    XML::HTMLParser.string(string, encoding: XML::Encoding::UTF_8,
+      #                                   options: XML::HTMLParser::Options::NOENT
+      #                                   base_uri: "http://libxml.org") -> XML::HTMLParser
       #
       # Creates a new parser by parsing the specified string.
       #
-      # You may provide an optional hash table to control how the
-      # parsing is performed.  Valid options are:
+      # Parameters:
       #
+      #  string - String to parse
       #  base_uri - The base url for the parsed document.
       #  encoding - The document encoding, defaults to nil. Valid values
       #             are the encoding constants defined on XML::Encoding.
       #  options - Parser options.  Valid values are the constants defined on
       #            XML::HTMLParser::Options.  Mutliple options can be combined
       #            by using Bitwise OR (|).
-      def self.string(string, options = {})
+      def self.string(string, base_uri: nil, encoding: nil, options: nil)
         context = XML::HTMLParser::Context.string(string)
-        context.base_uri = options[:base_uri] if options[:base_uri]
-        context.encoding = options[:encoding] if options[:encoding]
-        context.options = options[:options] if options[:options]
+        context.base_uri = base_uri if base_uri
+        context.encoding = encoding if encoding
+        context.options = options if options
         self.new(context)
       end
 

data/lib/libxml/parser.rb

@@ -18,31 +18,33 @@ module LibXML
 
       # call-seq:
       #    XML::Parser.file(path) -> XML::Parser
-      #    XML::Parser.file(path, :encoding => XML::Encoding::UTF_8,
-      #                           :options => XML::Parser::Options::NOENT) -> XML::Parser
+      #    XML::Parser.file(path, encoding: XML::Encoding::UTF_8,
+      #                           options: XML::Parser::Options::NOENT) -> XML::Parser
       #
       # Creates a new parser for the specified file or uri.
       #
-      # You may provide an optional hash table to control how the
-      # parsing is performed.  Valid options are:
+      # Parameters:
       #
+      #  path - Path to file
+      #  base_uri - The base url for the parsed document.
       #  encoding - The document encoding, defaults to nil. Valid values
       #             are the encoding constants defined on XML::Encoding.
       #  options - Parser options.  Valid values are the constants defined on
       #            XML::Parser::Options.  Mutliple options can be combined
       #            by using Bitwise OR (|).
-      def self.file(path, options = {})
+      def self.file(path, base_uri: nil, encoding: nil, options: nil)
         context = XML::Parser::Context.file(path)
-        context.encoding = options[:encoding] if options[:encoding]
-        context.options = options[:options] if options[:options]
+        context.base_uri = base_uri if base_uri
+        context.encoding = encoding if encoding
+        context.options = options if options
         self.new(context)
       end
 
       # call-seq:
       #    XML::Parser.io(io) -> XML::Parser
-      #    XML::Parser.io(io, :encoding => XML::Encoding::UTF_8,
-      #                       :options => XML::Parser::Options::NOENT
-      #                       :base_uri="http://libxml.org") -> XML::Parser
+      #    XML::Parser.io(io, encoding: XML::Encoding::UTF_8,
+      #                       options: XML::Parser::Options::NOENT
+      #                       base_uri: "http://libxml.org") -> XML::Parser
       #
       # Creates a new parser for the specified io object.
       #
@@ -55,36 +57,36 @@ module LibXML
       #  options - Parser options.  Valid values are the constants defined on
       #            XML::Parser::Options.  Mutliple options can be combined
       #            by using Bitwise OR (|).
-      def self.io(io, options = {})
+      def self.io(io, base_uri: nil, encoding: nil, options: nil)
         context = XML::Parser::Context.io(io)
-        context.base_uri = options[:base_uri] if options[:base_uri]
-        context.encoding = options[:encoding] if options[:encoding]
-        context.options = options[:options] if options[:options]
+        context.base_uri = base_uri if base_uri
+        context.encoding = encoding if encoding
+        context.options = options if options
         self.new(context)
       end
 
       # call-seq:
       #    XML::Parser.string(string)
-      #    XML::Parser.string(string, :encoding => XML::Encoding::UTF_8,
-      #                               :options => XML::Parser::Options::NOENT
-      #                               :base_uri="http://libxml.org") -> XML::Parser
+      #    XML::Parser.string(string, encoding: XML::Encoding::UTF_8,
+      #                               options: XML::Parser::Options::NOENT
+      #                               base_uri: "http://libxml.org") -> XML::Parser
       #
       # Creates a new parser by parsing the specified string.
       #
-      # You may provide an optional hash table to control how the
-      # parsing is performed.  Valid options are:
+      # Parameters:
       #
+      #  string - The string to parse
       #  base_uri - The base url for the parsed document.
       #  encoding - The document encoding, defaults to nil. Valid values
       #             are the encoding constants defined on XML::Encoding.
       #  options - Parser options.  Valid values are the constants defined on
-      #            XML::Parser::Options.  Mutliple options can be combined
+      #            XML::Parser::Options.  Multiple options can be combined
       #            by using Bitwise OR (|).
-      def self.string(string, options = {})
+      def self.string(string, base_uri: nil, encoding: nil, options: nil)
         context = XML::Parser::Context.string(string)
-        context.base_uri = options[:base_uri] if options[:base_uri]
-        context.encoding = options[:encoding] if options[:encoding]
-        context.options = options[:options] if options[:options]
+        context.base_uri = base_uri if base_uri
+        context.encoding = encoding if encoding
+        context.options = options if options
         self.new(context)
       end
 

data/test/test.rb

@@ -0,0 +1,5 @@
+begin
+  File.open("/does/not/exist")
+rescue => e
+  puts e
+end

data/test/test_document.rb

@@ -129,4 +129,12 @@ class TestDocument < Minitest::Test
     file = File.join(File.dirname(__FILE__), 'model/atom.xml')
     schema_document = LibXML::XML::Document.file(file, options: LibXML::XML::Parser::Options::NONET)
   end
+
+  def test_io
+    File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
+      doc = LibXML::XML::Document.io(io)
+      assert_instance_of(LibXML::XML::Document, doc)
+    end
+  end
+
 end

data/test/test_document_write.rb

@@ -7,14 +7,11 @@ class TestDocumentWrite < 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)
+    @doc = LibXML::XML::Document.file(file, options: LibXML::XML::Parser::Options::NOBLANKS)
   end
 
   def teardown
-    LibXML::XML.default_keep_blanks = true
     @doc = nil
   end
 

data/test/test_dtd.rb

@@ -31,13 +31,13 @@ class TestDtd < Minitest::Test
   end
   
   def test_internal_subset
-    xhtml_dtd = LibXML::XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", nil, nil, true
+    xhtml_dtd = LibXML::XML::Dtd.new("-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", nil, nil, true)
 		assert xhtml_dtd.name.nil?
 		assert_equal "-//W3C//DTD XHTML 1.0 Transitional//EN", xhtml_dtd.external_id
 		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.uri
 		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.system_id
 
-    xhtml_dtd = LibXML::XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", "xhtml1", nil, true
+    xhtml_dtd = LibXML::XML::Dtd.new("-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", "xhtml1", nil, true)
 		assert_equal "xhtml1", xhtml_dtd.name
 		assert_equal "-//W3C//DTD XHTML 1.0 Transitional//EN", xhtml_dtd.external_id
 		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.uri
@@ -45,13 +45,13 @@ class TestDtd < Minitest::Test
   end
 
   def test_external_subset
-    xhtml_dtd = LibXML::XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", nil
+    xhtml_dtd = LibXML::XML::Dtd.new("-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", nil)
 		assert xhtml_dtd.name.nil?
 		assert_equal "-//W3C//DTD XHTML 1.0 Transitional//EN", xhtml_dtd.external_id
 		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.uri
 		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.system_id
 
-    xhtml_dtd = LibXML::XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", "xhtml1"
+    xhtml_dtd = LibXML::XML::Dtd.new("-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", "xhtml1")
 		assert_equal "xhtml1", xhtml_dtd.name
 		assert_equal "-//W3C//DTD XHTML 1.0 Transitional//EN", xhtml_dtd.external_id
 		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.uri
@@ -106,13 +106,11 @@ class TestDtd < Minitest::Test
       errors << error
     end
 
-    LibXML::XML.default_load_external_dtd = false
     LibXML::XML::Parser.string(xml).parse
     assert_equal(0, errors.length)
 
     errors.clear
-    LibXML::XML.default_load_external_dtd = true
-    LibXML::XML::Parser.string(xml).parse
+    LibXML::XML::Parser.string(xml, options: LibXML::XML::Parser::Options::DTDLOAD).parse
     assert_equal(1, errors.length)
     assert_equal("Warning: failed to load external entity \"test.dtd\" at :1.",
                  errors[0].to_s)
@@ -123,7 +121,6 @@ class TestDtd < Minitest::Test
     assert_equal("Warning: failed to load external entity \"test.dtd\" at :1.",
                  errors[0].to_s)
   ensure
-    LibXML::XML.default_load_external_dtd = false
     LibXML::XML::Error.reset_handler
   end
 end

data/test/test_encoding.rb

@@ -38,10 +38,7 @@ class TestEncoding < Minitest::Test
     @encoding = encoding
     file = file_for_encoding(encoding)
 
-    # Strip spaces to make testing easier
-    LibXML::XML.default_keep_blanks = false
-    @doc = LibXML::XML::Document.file(file)
-    LibXML::XML.default_keep_blanks = true
+    @doc = LibXML::XML::Document.file(file, options: LibXML::XML::Parser::Options::NOBLANKS)
   end
 
   def test_encoding

data/test/test_helper.rb

@@ -1,9 +1,13 @@
 # encoding: UTF-8
 
 # To make testing/debugging easier, test within this source tree versus an installed gem
-
 require 'bundler/setup'
-require 'minitest/autorun'
+
+# Add ext directory to load path to make it easier to test locally built extensions
+ext_path = File.expand_path(File.join(__dir__, '..', 'ext', 'libxml'))
+$LOAD_PATH.unshift(File.expand_path(ext_path))
+
+# Now load code
 require 'libxml-ruby'
 
 def windows?
@@ -11,3 +15,6 @@ def windows?
 end
 
 STDOUT.write "\nlibxml2: #{LibXML::XML::LIBXML_VERSION}\n#{RUBY_DESCRIPTION}\n\n"
+
+require 'minitest/autorun'
+

data/test/test_html_parser.rb

@@ -1,162 +1,162 @@
-# encoding: UTF-8
-
-require_relative './test_helper'
-require 'stringio'
-
-class HTMLParserTest < Minitest::Test
-  def html_file
-    File.expand_path(File.join(File.dirname(__FILE__), 'model/ruby-lang.html'))
-  end
-
-  # -----  Sources  ------
-  def test_file
-    xp = LibXML::XML::HTMLParser.file(html_file)
-    assert_instance_of(LibXML::XML::HTMLParser, xp)
-    doc = xp.parse
-    refute_nil(doc)
-  end
-
-  def test_noexistent_file
-    error = assert_raises(LibXML::XML::Error) do
-      LibXML::XML::HTMLParser.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::HTMLParser.file(nil)
-    end
-
-    assert_match(/nil into String/, error.to_s)
-  end
-
-  def test_io
-    File.open(html_file) do |io|
-      xp = LibXML::XML::HTMLParser.io(io)
-      assert_instance_of(LibXML::XML::HTMLParser, xp)
-
-      doc = xp.parse
-      assert_instance_of(LibXML::XML::Document, doc)
-    end
-  end
-
-  def test_io_gc
-    # Test that the reader keeps a reference
-    # to the io object
-    file = File.open(html_file)
-    parser = LibXML::XML::HTMLParser.io(file)
-    file = nil
-    GC.start
-    assert(parser.parse)
-  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_io
-    data = File.read(html_file)
-    io = StringIO.new(data)
-    xp = LibXML::XML::HTMLParser.io(io)
-    assert_instance_of(LibXML::XML::HTMLParser, xp)
-
-    doc = xp.parse
-    assert_instance_of(LibXML::XML::Document, doc)
-  end
-
-  def test_string
-    str = '<html><body><p>hi</p></body></html>'
-    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
-      <html>
-        <head>
-          <meta name=keywords content=nasty>
-        </head>
-        <body>Hello<br>World</html>
-   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 <p>
-    # 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("<p>#{html}</p>", doc.root.to_s)
-  end
-
-  def test_comment
-    doc = LibXML::XML::HTMLParser.string('<!-- stuff -->', :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
+# encoding: UTF-8
+
+require_relative './test_helper'
+require 'stringio'
+
+class HTMLParserTest < Minitest::Test
+  def html_file
+    File.expand_path(File.join(File.dirname(__FILE__), 'model/ruby-lang.html'))
+  end
+
+  # -----  Sources  ------
+  def test_file
+    xp = LibXML::XML::HTMLParser.file(html_file)
+    assert_instance_of(LibXML::XML::HTMLParser, xp)
+    doc = xp.parse
+    refute_nil(doc)
+  end
+
+  def test_noexistent_file
+    error = assert_raises(LibXML::XML::Error) do
+      LibXML::XML::HTMLParser.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::HTMLParser.file(nil)
+    end
+
+    assert_match(/nil into String/, error.to_s)
+  end
+
+  def test_io
+    File.open(html_file) do |io|
+      xp = LibXML::XML::HTMLParser.io(io)
+      assert_instance_of(LibXML::XML::HTMLParser, xp)
+
+      doc = xp.parse
+      assert_instance_of(LibXML::XML::Document, doc)
+    end
+  end
+
+  def test_io_gc
+    # Test that the reader keeps a reference
+    # to the io object
+    file = File.open(html_file)
+    parser = LibXML::XML::HTMLParser.io(file)
+    file = nil
+    GC.start
+    assert(parser.parse)
+  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_io
+    data = File.read(html_file)
+    io = StringIO.new(data)
+    xp = LibXML::XML::HTMLParser.io(io)
+    assert_instance_of(LibXML::XML::HTMLParser, xp)
+
+    doc = xp.parse
+    assert_instance_of(LibXML::XML::Document, doc)
+  end
+
+  def test_string
+    str = '<html><body><p>hi</p></body></html>'
+    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
+      <html>
+        <head>
+          <meta name=keywords content=nasty>
+        </head>
+        <body>Hello<br>World</html>
+   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 <p>
+    # 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("<p>#{html}</p>", doc.root.to_s)
+  end
+
+  def test_comment
+    doc = LibXML::XML::HTMLParser.string('<!-- stuff -->', :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

data/test/test_namespace.rb

@@ -37,9 +37,7 @@ class TestNS < Minitest::Test
   def test_duplicate_ns
     node = LibXML::XML::Node.new('foo')
     LibXML::XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
-    assert_raises(LibXML::XML::Error) do
-      LibXML::XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
-    end
+    LibXML::XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
   end
 
   def test_eql