libxml-ruby 3.2.1 → 4.1.1

data/lib/libxml/error.rb

@@ -3,24 +3,24 @@
 module LibXML
   module XML
     class Error
-      # Create mapping from domain constant value to keys
+      # Create mapping from domain constant values to keys
       DOMAIN_CODE_MAP = [:NO_ERROR, :PARSER, :TREE, :NAMESPACE, :DTD, :HTML, :MEMORY,
                          :OUTPUT, :IO, :FTP, :HTTP, :XINCLUDE, :XPATH, :XPOINTER, :REGEXP,
                          :DATATYPE, :SCHEMASP, :SCHEMASV, :RELAXNGP, :RELAXNGV, :CATALOG,
                          :C14N, :XSLT, :VALID, :CHECK, :WRITER, :MODULE, :I18N, :SCHEMATRONV].inject(Hash.new) do |hash, code|
         if const_defined?(code)
-          hash[const_get(code)] = code.to_s
+          hash[const_get(code)] = code
         end
         hash
       end
 
-      # Create mapping from domain constant value to keys
+      # Create mapping from error constant values (so need to remove domain_codes) to keys
       ERROR_CODE_MAP = Hash.new.tap do |map|
         (constants -
          DOMAIN_CODE_MAP.values - #Domains
          [:NONE, :WARNING, :ERROR, :FATAL] # Levels
          ).each do |code|
-          map[const_get(code)] = code.to_s
+          map[const_get(code)] = code
         end
       end
       
@@ -70,11 +70,11 @@ module LibXML
       end
 
       def domain_to_s
-        DOMAIN_CODE_MAP[self.domain]
+        DOMAIN_CODE_MAP[self.domain].to_s
       end
 
       def code_to_s
-        ERROR_CODE_MAP[self.code]
+        ERROR_CODE_MAP[self.code].to_s
       end
 
       def to_s
@@ -92,4 +92,4 @@ module LibXML
   end
 end
 
-LibXML::XML::Error.set_handler(&LibXML::XML::Error::VERBOSE_HANDLER)
+LibXML::XML::Error.set_handler(&LibXML::XML::Error::VERBOSE_HANDLER)

data/libxml-ruby.gemspec

@@ -7,7 +7,7 @@ version = File.read('ext/libxml/ruby_xml_version.h').match(/\s*RUBY_LIBXML_VERSI
 Gem::Specification.new do |spec|
   spec.name        = 'libxml-ruby'
   spec.version     = version
-  spec.homepage    = 'http://xml4r.github.com/libxml-ruby'
+  spec.homepage    = 'https://xml4r.github.io/libxml-ruby/'
   spec.summary     = 'Ruby Bindings for LibXML2'
   spec.description = <<-EOS
     The Libxml-Ruby project provides Ruby language bindings for the GNOME

data/test/model/shiporder.rnc

@@ -5,9 +5,9 @@
 #
 namespace xsi = "http://www.w3.org/2001/XMLSchema-instance"
 
-start = shiporder
+start = shiporderType
 
-shiporder  = element shiporder { attribute orderid { text }, 
+shiporderType  = element shiporder { attribute orderid { text },
                                  attribute xsi:noNamespaceSchemaLocation { text }, 
                                orderperson, shipto, item* }
 

data/test/model/shiporder.rng

@@ -7,9 +7,9 @@
 -->
 <grammar xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://relaxng.org/ns/structure/1.0">
   <start>
-    <ref name="shiporder"/>
+    <ref name="shiporderType"/>
   </start>
-  <define name="shiporder">
+  <define name="shiporderType">
     <element name="shiporder">
       <attribute name="orderid"/>
       <attribute name="xsi:noNamespaceSchemaLocation"/>

data/test/model/shiporder.xsd

@@ -1,8 +1,12 @@
 <?xml version="1.0" encoding="iso-8859-1" ?>
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-  <xs:element name="shiporder" type="shiporder"/>
 
-  <xs:complexType name="shiporder">
+  <xs:import namespace="http://xml4r.org/ibxml-ruby/test/shiporder"
+             schemaLocation="shiporder_import.xsd"/>
+
+  <xs:element name="shiporder" type="shiporderType"/>
+
+  <xs:complexType name="shiporderType">
     <xs:annotation>
       <xs:documentation>Shiporder type documentation</xs:documentation>
     </xs:annotation>
@@ -37,4 +41,4 @@
     <xs:attribute name="foo" default="1" type="xs:integer" use="optional"/>
     <xs:attribute name="bar" use="prohibited"/>
   </xs:complexType>
-</xs:schema>
+</xs:schema>

data/test/model/shiporder_bad.xsd

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="iso-8859-1" ?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:element name="shiporder" type="shiporderType"/>
+
+  <xs:complexType name="shiporderType">
+    <xs:anntation>
+      <xs:documentation>Shiporder type documentation</xs:documentation>
+    </xs:anntation>
+    <xs:sequence>
+      <xs:element name="orderperson" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>orderperson element documentation</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="shipto">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="name" type="xs:string"/>
+            <xs:element name="address" type="xs:string"/>
+            <xs:element name="city" type="xs:string"/>
+            <xs:element name="country" type="xs:string"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+      <xs:element name="item" maxOccurs="unbounded">
+        <xs:complexType>
+          <xs:seq>
+            <xs:element name="title" type="xs:string"/>
+            <xs:element name="note" type="xs:string" minOccurs="0"/>
+            <xs:element name="quantity" type="xs:positiveInteger"/>
+            <xs:element name="price" type="xs:decimal"/>
+          </xs:seq>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+    <xs:attribute name="orderid" type="xs:string" use="required"/>
+    <xs:attribute name="foo" default="1" type="xs:integer" use="optional"/>
+    <xs:attribute name="bar" use="prohibited"/>
+  </xs:complexType>
+</xs:schema>

data/test/model/shiporder_import.xsd

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="iso-8859-1" ?>
+<xs:schema xmlns="http://xml4r.org/libxml-ruby/test/shiporder"
+           xmlns:xs="http://www.w3.org/2001/XMLSchema"
+           targetNamespace="http://xml4r.org/libxml-ruby/test/shiporder">
+
+  <xs:element name="shiporder" type="shiporderFooType"/>
+  <xs:complexType name="shiporderFooType">
+    <xs:annotation>
+      <xs:documentation>Shiporder type documentation for Testing of imported schema</xs:documentation>
+    </xs:annotation>
+    <xs:sequence>
+      <xs:element name="orderperson" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>orderperson element documentation</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="shipto">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="name" type="xs:string"/>
+            <xs:element name="address" type="xs:string"/>
+            <xs:element name="city" type="xs:string"/>
+            <xs:element name="country" type="xs:string"/>
+            <xs:element name="phone" type="xs:string"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+      <xs:element name="item" maxOccurs="unbounded">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="title" type="xs:string"/>
+            <xs:element name="note" type="xs:string" minOccurs="0"/>
+            <xs:element name="quantity" type="xs:positiveInteger"/>
+            <xs:element name="price" type="xs:decimal"/>
+            <xs:element name="discount" type="xs:decimal"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+    <xs:attribute name="orderid" type="xs:string" use="required"/>
+    <xs:attribute name="foo" default="1" type="xs:integer" use="optional"/>
+    <xs:attribute name="bar" type="xs:string" use="optional"/>
+    <xs:attribute name="xyzzy" type="xs:string" use="prohibited"/>
+  </xs:complexType>
+</xs:schema>

data/test/test_document.rb

@@ -126,6 +126,7 @@ class TestDocument < Minitest::Test
   def test_nonet
     xml_string = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
     xml = LibXML::XML::Document.string(xml_string, options: LibXML::XML::Parser::Options::NONET)
-    schema_document = LibXML::XML::Document.file('d:/src/libxml-ruby/test/model/atom.xml', options: LibXML::XML::Parser::Options::NONET)
+    file = File.join(File.dirname(__FILE__), 'model/atom.xml')
+    schema_document = LibXML::XML::Document.file(file, options: LibXML::XML::Parser::Options::NONET)
   end
 end

data/test/test_dtd.rb

@@ -84,7 +84,8 @@ class TestDtd < Minitest::Test
     assert_nil(error.file)
     assert_nil(error.line)
     assert_equal('invalid', error.str1)
-    assert_nil(error.str2)
+    # Different answers across operating systems
+    # assert_nil(error.str2)
     assert_nil(error.str3)
     assert_equal(0, error.int1)
     assert_equal(0, error.int2)

data/test/test_error.rb

@@ -4,135 +4,153 @@ 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_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)
+
+    if saved_handler
+      LibXML::XML::Error.set_handler &saved_handler
+    else
+      LibXML::XML::Error.reset_handler
+    end
+
+    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_handler
+    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::Error.set_handler {|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_double_parse_register_handler
     LibXML::XML::Parser.register_error_handler(lambda {|msg| nil })
     parser = LibXML::XML::Parser.string("<test>something</test>")
     parser.parse
@@ -145,34 +163,32 @@ class TestError < Minitest::Test
     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
+  def test_libxml_parser_empty_string
+    error = assert_raises(TypeError) do
+      LibXML::XML::Parser.string(nil)
+    end
+    assert_equal('wrong argument type nil (expected String)', error.to_s)
+
+    error = assert_raises(ArgumentError) do
+      LibXML::XML::Parser.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

@@ -5,3 +5,9 @@
 require 'bundler/setup'
 require 'minitest/autorun'
 require 'libxml-ruby'
+
+def windows?
+  !(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/).nil?
+end
+
+STDOUT.write "\nlibxml2: #{LibXML::XML::LIBXML_VERSION}\n#{RUBY_DESCRIPTION}\n\n"

data/test/test_parser.rb

@@ -271,7 +271,7 @@ class TestParser < Minitest::Test
     assert_equal('foz', error.str2)
     assert_nil(error.str3)
     assert_equal(1, error.int1)
-    assert_equal(20, error.int2)
+    assert([18, 20].include?(error.int2))
     assert_nil(error.node)
   end
 

data/test/test_parser_context.rb

@@ -127,12 +127,6 @@ class TestParserContext < Minitest::Test
     end
   end
 
-  if ENV['NOTWORKING']
-    def test_num_chars
-      assert_equal(17, context.num_chars)
-    end
-  end
-
   def test_replace_entities
     context = LibXML::XML::Parser::Context.new
     assert(!context.replace_entities?)
@@ -185,7 +179,7 @@ class TestParserContext < Minitest::Test
     assert_nil(context.name_node)
     assert_equal(0, context.name_depth)
     assert_equal(10, context.name_depth_max)
-    assert_equal(17, context.num_chars)
+    assert([0, 17].include?(context.num_chars))
     assert_equal(false, context.replace_entities?)
     assert_equal(1, context.space_depth)
     assert_equal(10, context.space_depth_max)

data/test/test_reader.rb

@@ -249,9 +249,10 @@ class TestReader < Minitest::Test
   end
 
   def test_bytes_consumed
+    ending_are_rn = File.binread(XML_FILE).include? "\r\n"
     reader = LibXML::XML::Reader.file(XML_FILE)
     reader.read
-    assert_equal(428, reader.byte_consumed)
+    assert_equal(ending_are_rn ? 428 : 416, reader.byte_consumed)
   end
 
   def test_node