libxml-ruby 2.8.0 → 3.2.3

data/test/{tc_encoding.rb → test_encoding.rb}

@@ -1,126 +1,129 @@
-# encoding: UTF-8
-
-require './test_helper'
-require 'test/unit'
-
-# Code  UTF8        Latin1      Hex
-# m      109          109        6D
-# ö      195 182      246        C3 B6 / F6
-# t      116          116        74
-# l      108          108        6C
-# e      101          101        65
-# y      121          121        79
-# _       95           95        5F
-# c       99           99        63
-# r      114          114        72
-# ü      195 188      252        C3 BC / FC
-# e      101          101        65
-
-# See:
-#  http://en.wikipedia.org/wiki/ISO/IEC_8859-1
-#  http://en.wikipedia.org/wiki/List_of_Unicode_characters
-
-class TestEncoding < Test::Unit::TestCase
-  def setup
-    Encoding.default_internal = nil
-  end
-
-  def file_for_encoding(encoding)
-    file_name = "model/bands.#{encoding.name.downcase}.xml"
-    File.join(File.dirname(__FILE__), file_name)
-  end
-
-  def load_encoding(encoding)
-    @encoding = encoding
-    file = file_for_encoding(encoding)
-
-    # Strip spaces to make testing easier
-    XML.default_keep_blanks = false
-    @doc = XML::Document.file(file)
-  end
-
-  def test_encoding
-    doc = XML::Document.new
-    assert_equal(XML::Encoding::NONE, doc.encoding)
-    assert_equal(Encoding::ASCII_8BIT, doc.rb_encoding) if defined?(Encoding)
-
-    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.xml'))
-    doc = XML::Document.file(file)
-    assert_equal(XML::Encoding::UTF_8, doc.encoding)
-    assert_equal(Encoding::UTF_8, doc.rb_encoding) if defined?(Encoding)
-
-    doc.encoding = XML::Encoding::ISO_8859_1
-    assert_equal(XML::Encoding::ISO_8859_1, doc.encoding)
-    assert_equal(Encoding::ISO8859_1, doc.rb_encoding) if defined?(Encoding)
-  end
-
-  def test_no_internal_encoding_iso_8859_1
-    Encoding.default_internal = nil
-    load_encoding(Encoding::ISO_8859_1)
-    node = @doc.root.children.first
-
-    name = node.name
-    assert_equal(Encoding::UTF_8, name.encoding)
-    assert_equal("m\u00F6tley_cr\u00FCe", name)
-    assert_equal("109 195 182 116 108 101 121 95 99 114 195 188 101",
-                 name.bytes.to_a.join(" "))
-    assert_equal("M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.",
-                 node.content)
-
-    name = name.encode(Encoding::ISO_8859_1)
-    assert_equal(Encoding::ISO_8859_1, name.encoding)
-    assert_equal("m\xF6tley_cr\xFCe".force_encoding(Encoding::ISO_8859_1), name)
-    assert_equal("109 246 116 108 101 121 95 99 114 252 101",
-                 name.bytes.to_a.join(" "))
-    assert_equal("M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.".force_encoding(Encoding::ISO_8859_1),
-                node.content.encode(Encoding::ISO_8859_1))
-  end
-
-  def test_internal_encoding_iso_8859_1
-    Encoding.default_internal = Encoding::ISO_8859_1
-    load_encoding(Encoding::ISO_8859_1)
-    node = @doc.root.children.first
-
-    name = node.name
-    assert_equal(Encoding::ISO_8859_1, name.encoding)
-    assert_equal("109 246 116 108 101 121 95 99 114 252 101",
-                 name.bytes.to_a.join(" "))
-    assert_equal("m\xF6tley_cr\xFCe".force_encoding(Encoding::ISO_8859_1), name)
-    assert_equal("109 246 116 108 101 121 95 99 114 252 101",
-                 name.bytes.to_a.join(" "))
-    assert_equal("M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.".force_encoding(Encoding::ISO_8859_1),
-                node.content.encode(Encoding::ISO_8859_1))
-  end
-
-  def test_no_internal_encoding_utf_8
-    Encoding.default_internal = nil
-    load_encoding(Encoding::UTF_8)
-    node = @doc.root.children.first
-
-    name = node.name
-    assert_equal(@encoding, name.encoding)
-    assert_equal("109 195 182 116 108 101 121 95 99 114 195 188 101",
-                 name.bytes.to_a.join(" "))
-
-    name = name.encode(Encoding::ISO_8859_1)
-    assert_equal(Encoding::ISO_8859_1, name.encoding)
-    assert_equal("109 246 116 108 101 121 95 99 114 252 101",
-                 name.bytes.to_a.join(" "))
-  end
-
-  def test_internal_encoding_utf_8
-    Encoding.default_internal = Encoding::ISO_8859_1
-    load_encoding(Encoding::UTF_8)
-    node = @doc.root.children.first
-
-    name = node.name
-    assert_equal(Encoding::ISO_8859_1, name.encoding)
-    assert_equal("109 246 116 108 101 121 95 99 114 252 101",
-                 name.bytes.to_a.join(" "))
-  end
-
-  def test_encoding_conversions
-    assert_equal("UTF-8", XML::Encoding.to_s(XML::Encoding::UTF_8))
-    assert_equal(XML::Encoding::UTF_8, XML::Encoding.from_s("UTF-8"))
-  end
-end
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+# Code  UTF8        Latin1      Hex
+# m      109          109        6D
+# ö      195 182      246        C3 B6 / F6
+# t      116          116        74
+# l      108          108        6C
+# e      101          101        65
+# y      121          121        79
+# _       95           95        5F
+# c       99           99        63
+# r      114          114        72
+# ü      195 188      252        C3 BC / FC
+# e      101          101        65
+
+# See:
+#  http://en.wikipedia.org/wiki/ISO/IEC_8859-1
+#  http://en.wikipedia.org/wiki/List_of_Unicode_characters
+
+class TestEncoding < Minitest::Test
+  def setup
+    @original_encoding = Encoding.default_internal
+    Encoding.default_internal = nil
+  end
+
+  def teardown
+    Encoding.default_internal = @original_encoding
+  end
+
+  def file_for_encoding(encoding)
+    file_name = "model/bands.#{encoding.name.downcase}.xml"
+    File.join(File.dirname(__FILE__), file_name)
+  end
+
+  def load_encoding(encoding)
+    @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
+  end
+
+  def test_encoding
+    doc = LibXML::XML::Document.new
+    assert_equal(LibXML::XML::Encoding::NONE, doc.encoding)
+    assert_equal(Encoding::ASCII_8BIT, doc.rb_encoding)
+
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.xml'))
+    doc = LibXML::XML::Document.file(file)
+    assert_equal(LibXML::XML::Encoding::UTF_8, doc.encoding)
+    assert_equal(Encoding::UTF_8, doc.rb_encoding)
+
+    doc.encoding = LibXML::XML::Encoding::ISO_8859_1
+    assert_equal(LibXML::XML::Encoding::ISO_8859_1, doc.encoding)
+    assert_equal(Encoding::ISO8859_1, doc.rb_encoding)
+  end
+
+  def test_no_internal_encoding_iso_8859_1
+    load_encoding(Encoding::ISO_8859_1)
+    node = @doc.root.children.first
+
+    name = node.name
+    assert_equal(Encoding::UTF_8, name.encoding)
+    assert_equal("m\u00F6tley_cr\u00FCe", name)
+    assert_equal("109 195 182 116 108 101 121 95 99 114 195 188 101",
+                 name.bytes.to_a.join(" "))
+    assert_equal("M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.",
+                 node.content)
+
+    name = name.encode(Encoding::ISO_8859_1)
+    assert_equal(Encoding::ISO_8859_1, name.encoding)
+    assert_equal("m\xF6tley_cr\xFCe".force_encoding(Encoding::ISO_8859_1), name)
+    assert_equal("109 246 116 108 101 121 95 99 114 252 101",
+                 name.bytes.to_a.join(" "))
+    assert_equal("M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.".force_encoding(Encoding::ISO_8859_1),
+                node.content.encode(Encoding::ISO_8859_1))
+  end
+
+  def test_internal_encoding_iso_8859_1
+    Encoding.default_internal = Encoding::ISO_8859_1
+    load_encoding(Encoding::ISO_8859_1)
+    node = @doc.root.children.first
+
+    name = node.name
+    assert_equal(Encoding::ISO_8859_1, name.encoding)
+    assert_equal("109 246 116 108 101 121 95 99 114 252 101",
+                 name.bytes.to_a.join(" "))
+    assert_equal("m\xF6tley_cr\xFCe".force_encoding(Encoding::ISO_8859_1), name)
+    assert_equal("109 246 116 108 101 121 95 99 114 252 101",
+                 name.bytes.to_a.join(" "))
+    assert_equal("M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.".force_encoding(Encoding::ISO_8859_1),
+                node.content.encode(Encoding::ISO_8859_1))
+  end
+
+  def test_no_internal_encoding_utf_8
+    load_encoding(Encoding::UTF_8)
+    node = @doc.root.children.first
+
+    name = node.name
+    assert_equal(@encoding, name.encoding)
+    assert_equal("109 195 182 116 108 101 121 95 99 114 195 188 101",
+                 name.bytes.to_a.join(" "))
+
+    name = name.encode(Encoding::ISO_8859_1)
+    assert_equal(Encoding::ISO_8859_1, name.encoding)
+    assert_equal("109 246 116 108 101 121 95 99 114 252 101",
+                 name.bytes.to_a.join(" "))
+  end
+
+  def test_internal_encoding_utf_8
+    Encoding.default_internal = Encoding::ISO_8859_1
+    load_encoding(Encoding::UTF_8)
+    node = @doc.root.children.first
+
+    name = node.name
+    assert_equal(Encoding::ISO_8859_1, name.encoding)
+    assert_equal("109 246 116 108 101 121 95 99 114 252 101",
+                 name.bytes.to_a.join(" "))
+  end
+
+  def test_encoding_conversions
+    assert_equal("UTF-8", LibXML::XML::Encoding.to_s(LibXML::XML::Encoding::UTF_8))
+    assert_equal(LibXML::XML::Encoding::UTF_8, LibXML::XML::Encoding.from_s("UTF-8"))
+  end
+end

data/test/{tc_encoding_sax.rb → test_encoding_sax.rb}

@@ -1,12 +1,13 @@
 # encoding: UTF-8
-require './test_helper'
-require 'test/unit'
+require_relative './test_helper'
 
 class SaxEncodingCallbacks
   attr_reader :encoding
-  include Test::Unit::Assertions
+  attr_accessor :assertions
+  include Minitest::Assertions
 
   def initialize
+    @assertions = 0
     @encoding = Encoding::UTF_8
   end
 
@@ -90,7 +91,7 @@ class SaxEncodingCallbacks
   end
 end
 
-class TestEncodingSax < Test::Unit::TestCase
+class TestEncodingSax < Minitest::Test
   def setup
     Encoding.default_internal = nil
   end
@@ -101,13 +102,13 @@ class TestEncodingSax < Test::Unit::TestCase
   end
 
   def test_encoding_iso_8859_1
-    parser = XML::SaxParser.file(file_for_encoding(Encoding::ISO_8859_1))
+    parser = LibXML::XML::SaxParser.file(file_for_encoding(Encoding::ISO_8859_1))
     parser.callbacks = SaxEncodingCallbacks.new
     parser.parse
   end
 
   def test_encoding_utf8
-    parser = XML::SaxParser.file(file_for_encoding(Encoding::UTF_8))
+    parser = LibXML::XML::SaxParser.file(file_for_encoding(Encoding::UTF_8))
     parser.callbacks = SaxEncodingCallbacks.new
     parser.parse
   end

data/test/test_error.rb

@@ -0,0 +1,178 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+require 'stringio'
+
+class TestError < Minitest::Test
+  # def test_error_codes
+  #   assert_equal(4, LibXML::XML::Error::DTD)
+  #   assert_equal(4, LibXML::XML::Error.const_get('DTD'))
+  #
+  #   assert_equal(4, LibXML::XML::Error::DOCUMENT_EMPTY)
+  #   assert_equal(4, LibXML::XML::Error.const_get('DOCUMENT_EMPTY'))
+  # end
+  #
+  # def test_invalid_handler
+  #   assert_raises(RuntimeError) do
+  #     LibXML::XML::Error.set_handler
+  #   end
+  # end
+  #
+  # def test_handler
+  #   exception = nil
+  #   LibXML::XML::Error.set_handler do |error|
+  #     exception = error
+  #   end
+  #
+  #   # Raise the error
+  #   error = assert_raises(LibXML::XML::Error) do
+  #     LibXML::XML::Reader.string('<foo').read
+  #   end
+  #   assert_equal(exception, error)
+  #
+  #   # Check the handler worked
+  #   refute_nil(exception)
+  #   assert_kind_of(LibXML::XML::Error, exception)
+  #   assert_equal("Fatal error: Couldn't find end of Start Tag foo at :1.", exception.message)
+  #   assert_equal(LibXML::XML::Error::PARSER, exception.domain)
+  #   assert_equal(LibXML::XML::Error::GT_REQUIRED, exception.code)
+  #   assert_equal(LibXML::XML::Error::FATAL, exception.level)
+  #   assert_nil(exception.file)
+  #   assert_equal(1, exception.line)
+  #   assert_equal('foo', exception.str1)
+  #   assert_nil(exception.str2)
+  #   assert_nil(exception.str3)
+  #   assert_equal(0, exception.int1)
+  #   assert_equal(5, exception.int2)
+  #   assert_nil(exception.node)
+  # end
+  #
+  # def test_reset_handler
+  #   exception = nil
+  #   LibXML::XML::Error.set_handler do |error|
+  #     exception = error
+  #   end
+  #
+  #   LibXML::XML::Error.reset_handler
+  #   LibXML::XML::Reader.string('<foo')
+  #   assert_nil(exception)
+  # end
+  #
+  # def test_get_handler
+  #   assert_respond_to(LibXML::XML::Error, :get_handler)
+  #   assert_equal(0, LibXML::XML::Error.method(:get_handler).arity)
+  #
+  #   saved_handler = LibXML::XML::Error.get_handler
+  #   LibXML::XML::Error.set_handler{ puts "New handler" }
+  #   refute_equal(LibXML::XML::Error.get_handler, saved_handler)
+  #
+  #   LibXML::XML::Error.set_handler(&saved_handler)
+  #   assert_equal(LibXML::XML::Error.get_handler, saved_handler)
+  # end
+  #
+  # def test_verbose_handler
+  #   LibXML::XML::Error.set_handler(&LibXML::XML::Error::VERBOSE_HANDLER)
+  #   output = StringIO.new
+  #   original_stderr = Object::STDERR
+  #
+  #   Object.const_set(:STDERR, output)
+  #   begin
+  #     assert_raises(LibXML::XML::Error) do
+  #       LibXML::XML::Parser.string('<foo><bar/></foz>').parse
+  #     end
+  #   ensure
+  #     Object.const_set(:STDERR, original_stderr)
+  #   end
+  #   assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.\n", output.string)
+  # end
+  #
+  # def test_no_hanlder
+  #   LibXML::XML::Error.reset_handler
+  #   output = StringIO.new
+  #   original_stderr = Object::STDERR
+  #
+  #   Object.const_set(:STDERR, output)
+  #   begin
+  #     assert_raises(LibXML::XML::Error) do
+  #       LibXML::XML::Parser.string('<foo><bar/></foz>').parse
+  #     end
+  #   ensure
+  #     Object.const_set(:STDERR, original_stderr)
+  #   end
+  #   assert_equal('', output.string)
+  # end
+  #
+  # def test_parse_error
+  #   exception = assert_raises(LibXML::XML::Error) do
+  #     LibXML::XML::Parser.string('<foo><bar/></foz>').parse
+  #   end
+  #
+  #   assert_instance_of(LibXML::XML::Error, exception)
+  #   assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.", exception.message)
+  #   assert_equal(LibXML::XML::Error::PARSER, exception.domain)
+  #   assert_equal(LibXML::XML::Error::TAG_NAME_MISMATCH, exception.code)
+  #   assert_equal(LibXML::XML::Error::FATAL, exception.level)
+  #   assert_nil(exception.file)
+  #   assert_equal(1, exception.line)
+  # end
+  #
+  # def test_xpath_error
+  #   doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+  #
+  #   exception = assert_raises(LibXML::XML::Error) do
+  #     doc.find('/foo[bar=test')
+  #   end
+  #
+  #   assert_instance_of(LibXML::XML::Error, exception)
+  #   assert_equal("Error: Invalid predicate.", exception.message)
+  #   assert_equal(LibXML::XML::Error::XPATH, exception.domain)
+  #   assert_equal(LibXML::XML::Error::XPATH_INVALID_PREDICATE_ERROR, exception.code)
+  #   assert_equal(LibXML::XML::Error::ERROR, exception.level)
+  #   assert_nil(exception.file)
+  #   assert_nil(nil)
+  # end
+
+  def test_double_parse
+    LibXML::XML::Parser.register_error_handler(lambda {|msg| nil })
+    parser = LibXML::XML::Parser.string("<test>something</test>")
+    parser.parse
+
+    error = assert_raises(LibXML::XML::Error) do
+      # Try parsing a second time
+      parser.parse
+    end
+
+    assert_equal(" LibXML::XML::Error.", error.to_s)
+  end
+
+  # def test_libxml_parser_empty_string
+  #   xp = LibXML::XML::Parser.new
+  #
+  #   error = assert_raises(TypeError) do
+  #     xp.string = nil
+  #   end
+  #   assert_equal('wrong argument type nil (expected String)', error.to_s)
+  #
+  #   error = assert_raises(ArgumentError) do
+  #     xp.string = ''
+  #   end
+  #   assert_equal('Must specify a string with one or more characters', error.to_s)
+  # end
+  #
+  # def test_error_domain_to_s
+  #   exception = assert_raises(LibXML::XML::Error) do
+  #     LibXML::XML::Parser.string('<foo href="http://example.org/cgi?k1=v1&k2=v2"></foo>').parse
+  #   end
+  #
+  #   assert_equal(LibXML::XML::Error::PARSER, exception.domain)
+  #   assert_equal("PARSER",exception.domain_to_s)
+  # end
+  #
+  # def test_error_code_to_s
+  #   exception = assert_raises(LibXML::XML::Error) do
+  #     LibXML::XML::Parser.string('<foo href="http://example.org/cgi?k1=v1&k2=v2"></foo>').parse
+  #   end
+  #   assert_equal(LibXML::XML::Error::ENTITYREF_SEMICOL_MISSING, exception.code)
+  #   assert_equal("ENTITYREF_SEMICOL_MISSING",exception.code_to_s)
+  # end
+end

data/test/test_helper.rb

@@ -2,13 +2,8 @@
 
 # To make testing/debugging easier, test within this source tree versus an installed gem
 
-dir = File.dirname(__FILE__)
-root = File.expand_path(File.join(dir, '..'))
-lib = File.expand_path(File.join(root, 'lib'))
-ext = File.expand_path(File.join(root, 'ext', 'libxml'))
-
-$LOAD_PATH << lib
-$LOAD_PATH << ext
-
-require 'xml'
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'libxml-ruby'
 
+STDOUT.write "\nlibxml2: #{LibXML::XML::LIBXML_VERSION}\n#{RUBY_DESCRIPTION}\n\n"

data/test/test_html_parser.rb

@@ -0,0 +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

data/test/test_html_parser_context.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+
+class TestHtmlParserContext < Minitest::Test
+  def test_default_options
+    context = LibXML::XML::HTMLParser::Context.new
+    assert_equal(0, context.options)
+  end
+
+  def test_no_options
+    context = LibXML::XML::HTMLParser::Context.new
+    context.options = 0
+    assert_equal(0, context.options)
+  end
+
+  def test_options
+    context = LibXML::XML::HTMLParser::Context.new
+    context.options = LibXML::XML::HTMLParser::Options::NOERROR
+    assert_equal(LibXML::XML::HTMLParser::Options::NOERROR, context.options)
+  end
+end