libxml-ruby 2.0.0-x86-mingw32

data/test/tc_attr_decl.rb

@@ -0,0 +1,133 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class AttrDeclTest < Test::Unit::TestCase
+  def setup
+    xp = XML::Parser.string(<<-EOS)
+	<!DOCTYPE test [
+	  <!ELEMENT root (property*)>
+	  <!ELEMENT property EMPTY>
+	  <!ATTLIST property name       NMTOKEN          #REQUIRED>
+	  <!ATTLIST property access     (r | w | rw)    "rw">
+	]>
+	<root>
+	  <property name="readonly" access="r" />
+	  <property name="readwrite" />
+	</root>
+    EOS
+    @doc = xp.parse
+  end
+  
+  def teardown
+    @doc = nil
+  end
+
+  def test_attributes
+    # Get a element with an access attribute
+    elem = @doc.find_first('/root/property[@name="readonly"]')
+    assert_equal(2, elem.attributes.length)
+    assert_not_nil(elem['access'])
+
+    # Get a element node without a access attribute
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    assert_equal(1, elem.attributes.length)
+    assert_nil(elem['access'])
+  end
+
+  def test_attr
+    # Get a property node without a access attribute
+    elem = @doc.find_first('/root/property[@name="readonly"]')
+
+    # Get the attr_decl
+    attr = elem.attributes.get_attribute('access')
+    assert_not_nil(attr)
+    assert_equal(XML::Node::ATTRIBUTE_NODE, attr.node_type)
+    assert_equal('attribute', attr.node_type_name)
+
+    # Get its value
+    assert_equal('r', attr.value)
+  end
+
+  def test_attr_decl
+    # Get a property node without a access attribute
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+
+    # Get the attr_decl
+    attr_decl = elem.attributes.get_attribute('access')
+    assert_not_nil(attr_decl)
+    assert_equal(XML::Node::ATTRIBUTE_DECL, attr_decl.node_type)
+    assert_equal('attribute declaration', attr_decl.node_type_name)
+
+    # Get its value
+    assert_equal('rw', attr_decl.value)
+  end
+
+  def test_type
+    # Get a property node without a access attribute
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    assert_not_nil(attr_decl)
+    assert_equal(XML::Node::ATTRIBUTE_DECL, attr_decl.node_type)
+    assert_equal('attribute declaration', attr_decl.node_type_name)
+  end
+  
+  def test_name
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    assert_equal('access', attr_decl.name)
+  end
+
+  def test_value
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    assert_equal('rw', attr_decl.value)
+  end
+
+  def test_to_s
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    assert_equal('access = rw', attr_decl.to_s)
+  end
+
+  def test_prev
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    first_decl = attr_decl.prev
+    assert_equal(XML::Node::ATTRIBUTE_DECL, first_decl.node_type)
+    assert_equal('name', first_decl.name)
+    assert_nil(first_decl.value)
+
+    elem_decl = first_decl.prev
+    assert_equal(XML::Node::ELEMENT_DECL, elem_decl.node_type)
+  end
+
+  def test_next
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    next_decl = attr_decl.next
+    assert_nil(next_decl)
+  end
+
+  def test_doc
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    assert_same(@doc, attr_decl.doc)
+  end
+
+  def test_parent
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    parent = attr_decl.parent
+    assert_instance_of(XML::Dtd, parent)
+  end
+end

data/test/tc_attributes.rb

@@ -0,0 +1,135 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class AttributesTest < Test::Unit::TestCase
+  def setup
+    xp = XML::Parser.string(<<-EOS)
+    <CityModel
+      xmlns="http://www.opengis.net/examples"
+      xmlns:city="http://www.opengis.net/examples"
+      xmlns:gml="http://www.opengis.net/gml"
+      xmlns:xlink="http://www.w3.org/1999/xlink"
+      xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance"
+      xsi:schemaLocation="http://www.opengis.net/examples city.xsd">
+     <cityMember name="Cambridge" 
+                 xlink:type="simple"
+                 xlink:title="Trinity Lane"
+                 xlink:href="http://www.foo.net/cgi-bin/wfs?FeatureID=C10239"
+                 gml:remoteSchema="city.xsd#xpointer(//complexType[@name='RoadType'])"/>
+    </CityModel>
+    EOS
+    
+    @doc = xp.parse
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def city_member
+    @doc.find('/city:CityModel/city:cityMember').first
+  end
+
+  def test_attributes
+    attributes = city_member.attributes
+    assert_instance_of(XML::Attributes, attributes)
+    assert_equal(5, attributes.length)
+  end
+
+  def test_each
+    attributes = city_member.attributes
+    length = attributes.inject(0) do |result, attr|
+      assert_instance_of(XML::Attr, attr)
+      result + 1
+    end
+    assert_equal(5, length)
+  end
+
+  def test_get_attribute
+    attributes = city_member.attributes
+
+    attr = attributes.get_attribute('name')
+    assert_instance_of(XML::Attr, attr)
+
+    attr = attributes.get_attribute('does_not_exist')
+    assert_nil(attr)
+
+    attr = attributes.get_attribute('name')
+    assert_instance_of(XML::Attr, attr)
+
+    attr = attributes.get_attribute('href')
+    assert_instance_of(XML::Attr, attr)
+    assert_instance_of(XML::Namespace, attr.ns)
+    assert_equal('xlink', attr.ns.prefix)
+    assert_equal('http://www.w3.org/1999/xlink', attr.ns.href)
+
+    attr = attributes.get_attribute_ns('http://www.w3.org/1999/xlink', 'href')
+    assert_instance_of(XML::Attr, attr)
+
+    attr = attributes.get_attribute_ns('http://www.opengis.net/gml', 'remoteSchema')
+    assert_instance_of(XML::Attr, attr)
+
+    attr = attributes.get_attribute_ns('http://i.dont.exist', 'nor do i')
+    assert_nil(attr)
+  end
+
+  def test_property
+    attr = city_member.property('name')
+    assert_instance_of(String, attr)
+    assert_equal('Cambridge', attr)
+  end
+
+  def test_get_values
+    assert_equal('Cambridge', city_member[:name])
+    assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', city_member[:href])
+
+    attributes = city_member.attributes
+    assert_equal('Cambridge', attributes[:name])
+    assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', attributes[:href])
+  end
+
+  def test_set_values
+    city_member[:name] = 'London'
+    assert_equal('London', city_member[:name])
+
+    city_member[:href] = 'foo'
+    assert_equal('foo', city_member[:href])
+
+    attributes = city_member.attributes
+
+    attributes[:name] = 'London'
+    assert_equal('London', attributes[:name])
+
+    attributes[:href] = 'foo'
+    assert_equal('foo', attributes[:href])
+  end
+
+  def test_str_sym()
+    attributes = city_member.attributes
+    assert_equal('Cambridge', attributes[:name])
+    assert_equal('Cambridge', attributes['name'])
+  end
+
+  def test_remove_first
+    attributes = @doc.find_first('/city:CityModel/city:cityMember').attributes
+    assert_equal(5, attributes.length)
+    attr = attributes.first
+    attr.remove!
+    assert_equal(4, attributes.length)
+  end
+
+  def test_remove_all
+    node = @doc.find_first('/city:CityModel/city:cityMember')
+    assert_equal(5, node.attributes.length)
+
+    attrs = Array.new
+    node.attributes.each do |attr|
+      attrs << attr
+      attr.remove!
+    end
+    assert_equal(5, attrs.length)
+    assert_equal(0, node.attributes.length)
+  end
+end

data/test/tc_deprecated_require.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+require 'xml/libxml'
+require 'test/unit'
+
+class TestDeprecatedRequire < Test::Unit::TestCase
+  def test_basic
+    xp = XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    assert_instance_of(XML::Parser, xp)
+    @doc = xp.parse
+    assert_instance_of(XML::Document, @doc)
+  end
+end

data/test/tc_document.rb

@@ -0,0 +1,119 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+require 'test/unit'
+
+
+class TestDocument < Test::Unit::TestCase
+  def setup
+    xp = XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    assert_instance_of(XML::Parser, xp)
+    @doc = xp.parse
+    assert_instance_of(XML::Document, @doc)
+  end
+
+  def teardown
+    @doc = nil
+  end
+
+  def test_klass
+    assert_instance_of(XML::Document, @doc)
+  end
+
+  def test_context
+    context = @doc.context
+    assert_instance_of(XML::XPath::Context, context)
+  end
+
+  def test_find
+    set = @doc.find('/ruby_array/fixnum')
+    assert_instance_of(XML::XPath::Object, set)
+    assert_raise(NoMethodError) {
+      xpt = set.xpath
+    }
+  end
+
+  def test_compression
+    if XML.enabled_zlib?
+      0.upto(9) do |i|
+        assert_equal(i, @doc.compression = i)
+        assert_equal(i, @doc.compression)
+      end
+
+      9.downto(0) do |i|
+        assert_equal(i, @doc.compression = i)
+        assert_equal(i, @doc.compression)
+      end
+
+      10.upto(20) do |i|
+        # assert_equal(9, @doc.compression = i)
+        assert_equal(i, @doc.compression = i) # This works around a bug in Ruby 1.8
+        assert_equal(9, @doc.compression)
+      end
+
+      -1.downto(-10) do |i|
+        # assert_equal(0, @doc.compression = i)
+        assert_equal(i, @doc.compression = i) # FIXME This bug should get fixed ASAP
+        assert_equal(0, @doc.compression)
+      end
+    end
+  end
+
+  def test_version
+    assert_equal('1.0', @doc.version)
+
+    doc = XML::Document.new('6.9')
+    assert_equal('6.9', doc.version)
+  end
+
+  def test_write_root
+    @doc.root = XML::Node.new('rubynet')
+    assert_instance_of(XML::Node, @doc.root)
+    assert_instance_of(XML::Document, @doc.root.doc)
+    assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<rubynet/>\n",
+                 @doc.to_s(:indent => false))
+  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_doc_node_type
+    assert_equal(XML::Node::DOCUMENT_NODE, XML::Document.new.node_type)
+  end
+
+  def test_doc_node_type_name
+    assert_equal('document_xml', XML::Document.new.node_type_name)
+  end
+
+  def test_xhtml
+		doc = XML::Document.new
+		assert(!doc.xhtml?)
+    XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", nil, doc, true
+		assert(doc.xhtml?)
+	end
+
+  def test_import_node
+    doc1 = XML::Parser.string('<nums><one></one></nums>').parse
+    doc2 = XML::Parser.string('<nums><two></two></nums>').parse
+
+    node = doc1.root.child
+
+    doc2.root << doc2.import(node)
+
+    assert_equal("<nums>\n  <two/>\n  <one/>\n</nums>",
+                 doc2.root.to_s)
+  end
+end

data/test/tc_document_write.rb

@@ -0,0 +1,187 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'tmpdir'
+require 'test/unit'
+
+class TestDocumentWrite < Test::Unit::TestCase
+  def setup
+    load_encoding("utf-8")
+  end
+
+  def teardown
+    XML.default_keep_blanks = true
+    @doc = nil
+  end
+
+  def load_encoding(name)
+    @encoding = Encoding.find(name) if defined?(Encoding)
+    @file_name = "model/bands.#{name.downcase}.xml"
+
+    # Strip spaces to make testing easier
+    XML.default_keep_blanks = false
+    file = File.join(File.dirname(__FILE__), @file_name)
+    @doc = XML::Document.file(file)
+  end
+
+  # ---  to_s tests  ---
+  def test_to_s_default
+    # Default to_s has indentation
+    if defined?(Encoding)
+      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n  <m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                   @doc.to_s)
+    else
+      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                   @doc.to_s)
+    end
+  end
+
+  def test_to_s_no_global_indentation
+    # No indentation due to global setting
+    XML.indent_tree_output = false
+    value = @doc.to_s
+
+    if defined?(Encoding)
+      assert_equal(Encoding::UTF_8, value.encoding)
+      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n<m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe>\n<iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                   value)
+    else
+      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n<m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n<iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                   value)
+    end
+  ensure
+    XML.indent_tree_output = true
+  end
+
+  def test_to_s_no_indentation
+    # No indentation due to local setting
+    value = @doc.to_s(:indent => false)
+    if defined?(Encoding)
+      assert_equal(Encoding::UTF_8, value.encoding)
+      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\"><m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden></bands>\n",
+                   value)
+    else
+      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\"><m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden></bands>\n",
+                   value)
+    end
+  end
+
+  def test_to_s_encoding
+    # Test encodings
+
+    # UTF8:
+    # ö - c3 b6 in hex, \303\266 in octal
+    # ü - c3 bc in hex, \303\274 in octal
+    value = @doc.to_s(:encoding => XML::Encoding::UTF_8)
+    if defined?(Encoding)
+      assert_equal(Encoding::UTF_8, value.encoding)
+      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n  <m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                   value)
+    else
+      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                   value)
+    end
+
+    # ISO_8859_1:
+    # ö - f6 in hex, \366 in octal
+    # ü - fc in hex, \374 in octal
+    value = @doc.to_s(:encoding => XML::Encoding::ISO_8859_1)
+    if defined?(Encoding)
+      assert_equal(Encoding::ISO8859_1, value.encoding)
+      assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\">\n  <m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n".force_encoding(Encoding::ISO8859_1),
+                   @doc.to_s(:encoding => XML::Encoding::ISO_8859_1))
+    else
+      assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">M\366tley Cr\374e is an American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                   @doc.to_s(:encoding => XML::Encoding::ISO_8859_1))
+    end
+    
+    # Invalid encoding
+    error = assert_raise(ArgumentError) do
+      @doc.to_s(:encoding => -9999)
+    end
+    assert_equal('Unknown encoding value: -9999', error.to_s)
+  end
+
+  # --- save tests -----
+  def test_save_utf8
+    temp_filename = File.join(Dir.tmpdir, "tc_document_write_test_save_utf8.xml")
+
+    bytes = @doc.save(temp_filename)
+    assert_equal(305, bytes)
+
+    if defined?(Encoding)
+      contents = File.read(temp_filename, nil, nil, :encoding => Encoding::UTF_8)
+      assert_equal(Encoding::UTF_8, contents.encoding)
+      assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<bands genre=\"metal\">\n  <m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                    contents)
+    else
+      contents = File.read(temp_filename)
+      assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                 contents)
+    end
+  ensure
+    File.delete(temp_filename)
+  end
+
+  def test_save_utf8_no_indents
+    temp_filename = File.join(Dir.tmpdir, "tc_document_write_test_save_utf8_no_indents.xml")
+
+    bytes = @doc.save(temp_filename, :indent => false)
+    assert_equal(298, bytes)
+
+    if defined?(Encoding)
+      contents = File.read(temp_filename, nil, nil, :encoding => Encoding::UTF_8)
+      assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<bands genre=\"metal\"><m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden></bands>\n",
+                 contents)
+    else
+      contents = File.read(temp_filename)
+      assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<bands genre=\"metal\"><m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden></bands>\n",
+                 contents)
+    end
+  ensure
+    File.delete(temp_filename)
+  end
+
+  def test_save_iso_8859_1
+    temp_filename = File.join(Dir.tmpdir, "tc_document_write_test_save_iso_8859_1.xml")
+    bytes = @doc.save(temp_filename, :encoding => XML::Encoding::ISO_8859_1)
+    assert_equal(304, bytes)
+
+    if defined?(Encoding)
+      contents = File.read(temp_filename, nil, nil, :encoding => Encoding::ISO8859_1)
+      assert_equal(Encoding::ISO8859_1, contents.encoding)
+      assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\">\n  <m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n".force_encoding(Encoding::ISO8859_1),
+                 contents)
+    else
+      contents = File.read(temp_filename)
+      assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\">\n  <m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                 contents)
+    end
+  ensure
+    File.delete(temp_filename)
+  end
+
+  def test_save_iso_8859_1_no_indent
+    temp_filename = File.join(Dir.tmpdir, "tc_document_write_test_save_iso_8859_1_no_indent.xml")
+    bytes = @doc.save(temp_filename, :indent => false, :encoding => XML::Encoding::ISO_8859_1)
+    assert_equal(297, bytes)
+
+    if defined?(Encoding)
+      contents = File.read(temp_filename, nil, nil, :encoding => Encoding::ISO8859_1)
+      assert_equal(Encoding::ISO8859_1, contents.encoding)
+      assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\"><m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden></bands>\n".force_encoding(Encoding::ISO8859_1),
+                   contents)
+    else
+      contents = File.read(temp_filename)
+      assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\"><m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden></bands>\n",
+                   contents)
+    end
+  ensure
+    File.delete(temp_filename)
+  end
+
+  # --- Debug ---
+  def test_debug
+    assert(@doc.debug)
+  end
+end