ruby--ruby/test/rexml/test_contrib.rb

# coding: binary

require "rexml_test_utils"

require "rexml/document"
require "rexml/parseexception"
require "rexml/formatters/default"

class ContribTester < Test::Unit::TestCase
  include REXMLTestUtils
  include REXML

  XML_STRING_01 = <<DELIMITER
<?xml version="1.0" encoding="UTF-8"?>
<biblio>
  <entry type="Book">
    <author>Thomas, David; Hunt, Andrew</author>
    <language>english</language>
    <publisher>Addison-Wesley</publisher>
    <title>Programming Ruby. The Pragmatic Programmer's Guide</title>
    <year>2000</year>
  </entry>
  <entry type="Book">
    <author>Blammo, Blah</author>
    <language>english</language>
    <publisher>Hubbabubba</publisher>
    <title>Foozboozer's Life</title>
    <type>Book</type>
    <year>2002</year>
  </entry>
</biblio>
DELIMITER

  XML_STRING_02 = <<DELIMITER
<biblio>
  <entry type="Book">
    <language>english</language>
    <publisher>Addison-Wesley</publisher>
    <title>Programming Ruby. The Pragmatic Programmer's Guide</title>
    <type>Book</type>
    <year>2000</year>
  </entry>
  <entry type="Book">
    <author>Blammo, Blah</author>
    <language>english</language>
    <publisher>Hubbabubba</publisher>
    <title>Foozboozer's Life</title>
    <type>Book</type>
    <year>2002</year>
  </entry>
</biblio>
DELIMITER

  # Tobias Reif <tobiasreif@pinkjuice.com>
  def test_bad_doctype_Tobias
    source = <<-EOF
     <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN"
        "http://www.w3.org/TR/SVG/DTD/svg10.dtd"
       [
       <!-- <!ENTITY % fast-slow "0 0  .5 1">-->
       <!--<!ENTITY % slow-fast ".5 0  1 1">-->
       <!ENTITY hover_ani
        '<animateTransform attributeName="transform"
         type="scale" restart="whenNotActive" values="1;0.96"
         dur="0.5s" calcMode="spline" keySplines="0 0  .5 1"
         fill="freeze" begin="mouseover"/>
         <animateTransform  attributeName="transform"
         type="scale" restart="whenNotActive" values="0.96;1"
         dur="0.5s" calcMode="spline" keySplines=".5 0  1 1"
         fill="freeze" begin="mouseover+0.5s"/>'
       >
       ]
     >
    EOF
    doc = REXML::Document.new source
    doc.write(out="")
    assert(out[/>'>/] != nil, "Couldn't find >'>")
    assert(out[/\]>/] != nil, "Couldn't find ]>")
  end

  # Peter Verhage
  def test_namespace_Peter
    source = <<-EOF
    <?xml version="1.0"?>
    <config:myprog-config xmlns:config="http://someurl/program/version">
    <!-- main options -->
      <config:main>
        <config:parameter name="name"  value="value"/>
      </config:main>
    </config:myprog-config>
    EOF
    doc = REXML::Document.new source
    assert_equal "myprog-config", doc.root.name
    count = 0
    REXML::XPath.each(doc, "x:myprog-config/x:main/x:parameter", 
      {"x"=>"http://someurl/program/version"}) { |element|
        assert_equal "name", element.attributes["name"]
      count += 1;
    }
    assert_equal 1, count
    assert_equal "myprog-config", doc.elements["config:myprog-config"].name
  end

  # Tobias Reif <tobiasreif@pinkjuice.com>
  def test_complex_xpath_Tobias
    source = <<-EOF
    <root>
      <foo>
        <bar style="baz"/>
        <blah style="baz"/>
        <blam style="baz"/>
      </foo>
      <wax>
        <fudge>
          <noodle/>
        </fudge>
      </wax>
    </root>
    EOF
    # elements that have child elements
    #  but not grandchildren
    #  and not children that don't have a style attribute
    #  and not children that have a unique style attribute
    complex_path = "*[* "+
      "and not(*/node()) "+
      "and not(*[not(@style)]) "+
      "and not(*/@style != */@style)]"
    doc = REXML::Document.new source
    results = REXML::XPath.match( doc.root, complex_path )
    assert(results)
    assert_equal 1, results.size
    assert_equal "foo", results[0].name
  end

  # "Chris Morris" <chrismo@charter.net>
  def test_extra_newline_on_read_Chris
    text = 'test text'
    e = REXML::Element.new('Test')
    e.add_text(text)
    REXML::Formatters::Default.new.write(e,out="")

    doc = REXML::Document.new(out)
    outtext = doc.root.text

    assert_equal(text, outtext)
  end

  # Tobias Reif <tobiasreif@pinkjuice.com>
  def test_other_xpath_Tobias
    schema = <<-DELIM
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
      elementFormDefault="qualified">
      <xs:element name="rect">
        <xs:complexType>
          <xs:attribute name="width" type="xs:byte" use="required"/>
          <xs:attribute name="height" type="xs:byte" use="required"/>
        </xs:complexType>
      </xs:element>
      <xs:element name="svg">
        <xs:complexType>
          <xs:sequence>
            <xs:element ref="rect"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:schema>
    DELIM

    doc = REXML::Document.new schema

    result = REXML::XPath.first(doc.root, 'xs:element[descendant::xs:element[@ref]]')
    assert result
    assert_equal "svg", result.attributes['name']
    result = REXML::XPath.first(doc, 'element[descendant::element[@ref]]')
    assert_nil result
  end

  #this first test succeeds, to check if stuff is set up correctly
  def test_xpath_01_TobiasReif
    doc = Document.new XML_STRING_01.dup
    desired_result = Document.new '<author>Thomas, David; Hunt, Andrew</author>'
    xpath = '//author'
    result = XPath.first(doc, xpath)
    assert_equal desired_result.to_s, result.to_s
  end
  
  def test_xpath_whitespace_TobiasReif
    # same as above, with whitespace in XPath
    doc = Document.new(XML_STRING_01.dup)
    desired_result = Document.new('<author>Thomas, David; Hunt, Andrew</author>')
    xpath = "\/\/author\n \n"
    result = XPath.first(doc, xpath)
    failure_message = "\n[[[TR: AFAIK, whitespace should be allowed]]]\n"
    assert_equal(desired_result.to_s, result.to_s, failure_message)
  end
  
  def test_xpath_02_TobiasReif
    doc = Document.new XML_STRING_01.dup
    desired_result = Document.new '<author>Thomas, David; Hunt, Andrew</author>'
    # Could that quirky
    #  Programmer',&quot;'&quot;,'s
    # be handled automatically, somehow?
    # Or is there a simpler way? (the below XPath should match the author element above,
    # AFAIK; I tested it inside an XSLT)
    xpath = %q{/biblio/entry[
    title/text()=concat('Programming Ruby. The Pragmatic Programmer',"'",'s Guide')
    and
    year='2000'
    ]/author}
    result = XPath.first(doc, xpath)
    failure_message = "\nHow to handle the apos inside the string inside the XPath?\nXPath = #{xpath}\n"
    assert_equal desired_result.to_s, result.to_s, failure_message
  end
  
  def test_xpath_03_TobiasReif
    doc = Document.new XML_STRING_02.dup
    desired_result_string = "<entry type='Book'>
    <language>english</language>
    <publisher>Addison-Wesley</publisher>
    <title>Programming Ruby. The Pragmatic Programmer's Guide</title>
    <type>Book</type>
    <year>2000</year>
  </entry>"
    desired_result_tree = Document.new desired_result_string
    xpath = "/biblio/entry[not(author)]"
    result = XPath.first(doc, xpath)
    assert_equal desired_result_string, result.to_s
  end

  def test_umlaut
    koln_iso = "K\xf6ln"
    koln_utf = "K\xc3\xb6ln"
    source_iso = "<?xml version='1.0' encoding='ISO-8859-1'?><test>#{koln_iso}</test>"
    source_utf = "<?xml version='1.0' encoding='UTF-8'?><test>#{koln_utf}</test>"

    if String.method_defined? :encode
      koln_iso.force_encoding('iso-8859-1')
      koln_utf.force_encoding('utf-8')
      source_iso.force_encoding('iso-8859-1')
      source_utf.force_encoding('utf-8')
    end

    doc = REXML::Document.new(source_iso)
    assert_equal('ISO-8859-1', doc.xml_decl.encoding)
    assert_equal(koln_utf, doc.root.text)
    doc.write(out="")
    assert_equal(source_iso, out )
    doc.xml_decl.encoding = 'UTF-8'
    doc.write(out="")
    assert_equal(source_utf, out)

    doc = Document.new <<-EOF
<?xml version="1.0" encoding="ISO-8859-1"?>
<intranet>
<position><aktuell datum="01-10-11">Technik</aktuell></position>
<hauptspalte>
<headline>Technik</headline>
Die Technik ist das R<EFBFBD>ckgrat der meisten Gesch<EFBFBD>ftsprozesse bei Home of the Brave. Deshalb sollen hier alle relevanten technischen Abl<EFBFBD>ufe, Daten und Einrichtungen beschrieben werden, damit jeder im Bedarfsfall die n<EFBFBD>tigen Informationen, Anweisungen und Verhaltensempfehlungen nachlesen und/oder abrufen kann.
</hauptspalte>
<nebenspalte>
  <link ziel="Flash/">Flash</link><umbruch/>
  N<EFBFBD>tzliches von Flashern f<EFBFBD>r Flasher.<umbruch/>
  <link neu="ja" ziel="Cvs/">CVS-FAQ</link><umbruch/>
  FAQ zur Benutzung von CVS bei HOB
</nebenspalte>
</intranet>
EOF
    tn = XPath.first(doc, "//nebenspalte/text()[2]")
    expected_iso = "N<EFBFBD>tzliches von Flashern f<>r Flasher."
                expected_utf = expected_iso.unpack('C*').pack('U*')
                if expected_utf.respond_to? :encode
      expected_iso.force_encoding("iso-8859-1")
      expected_utf.force_encoding(Encoding::UTF_8)
                end
    assert_equal(expected_utf, tn.to_s.strip)
    f = REXML::Formatters::Default.new
    f.write( tn, Output.new(o = "", "ISO-8859-1") )
    assert_equal(expected_iso, o.strip)

    doc = Document.new File.new(fixture_path('xmlfile-bug.xml'))
    tn = XPath.first(doc, "//nebenspalte/text()[2]")
    assert_equal(expected_utf, tn.to_s.strip)
    f.write( tn, Output.new(o = "", "ISO-8859-1") )
    assert_equal(expected_iso, o.strip)
  end

  def test_element_cloning_namespace_Chris
    aDoc = REXML::Document.new '<h1 tpl:content="title" xmlns:tpl="1">Dummy title</h1>'

    anElement = anElement = aDoc.elements[1]
    elementAttrPrefix = anElement.attributes.get_attribute('content').prefix

    aClone = anElement.clone
    cloneAttrPrefix = aClone.attributes.get_attribute('content').prefix

    assert_equal( elementAttrPrefix , cloneAttrPrefix )
  end

  def test_namespaces_in_attlist_tobias
    in_string = File.open(fixture_path('foo.xml'), 'r') do |file|
       file.read
    end

    doc = Document.new in_string

    assert_nil XPath.first(doc,'//leg')
    assert_equal 'http://www.foo.com/human', doc.root.elements[1].namespace
    assert_equal 'human leg', 
      XPath.first(doc, '//x:leg/text()', {'x'=>'http://www.foo.com/human'}).to_s
  end

  #  Alun ap Rhisiart
  def test_less_than_in_element_content
    source = File.new(fixture_path('ProductionSupport.xml'))
    h = Hash.new
    doc = REXML::Document.new source
    doc.elements.each("//CommonError") { |el| 
      h[el.elements['Key'].text] = 'okay' 
    }
    assert(h.include?('MotorInsuranceContract(Object)>>#error:'))
  end

  # XPaths provided by Thomas Sawyer
  def test_various_xpath
    #@doc = REXML::Document.new('<r a="1"><p><c b="2"/></p></r>')
    doc = REXML::Document.new('<r a="1"><p><c b="2">3</c></p></r>')

    [['/r', REXML::Element],
     ['/r/p/c', REXML::Element],
     ['/r/attribute::a', Attribute],
     ['/r/@a', Attribute],
     ['/r/attribute::*', Attribute],
     ['/r/@*', Attribute],
     ['/r/p/c/attribute::b', Attribute],
     ['/r/p/c/@b', Attribute],
     ['/r/p/c/attribute::*', Attribute],
     ['/r/p/c/@*', Attribute],
     ['//c/attribute::b', Attribute],
     ['//c/@b', Attribute],
     ['//c/attribute::*', Attribute],
     ['//c/@*', Attribute],
     ['.//node()', REXML::Node ],
     ['.//node()[@a]', REXML::Element ],
     ['.//node()[@a="1"]', REXML::Element ],
     ['.//node()[@b]', REXML::Element ], # no show, why?
     ['.//node()[@b="2"]', REXML::Element ]
    ].each do |xpath,kind|
      begin
        REXML::XPath.each( doc, xpath ) do |what|
          assert_kind_of( kind, what, "\n\nWrong type (#{what.class}) returned for #{xpath} (expected #{kind.name})\n\n" )
        end
      rescue Exception
        puts "PATH WAS: #{xpath}"
        raise
      end
    end

    [
     ['/r', 'attribute::a', Attribute ],
     ['/r', '@a', Attribute ],
     ['/r', 'attribute::*', Attribute ],
     ['/r', '@*', Attribute ],
     ['/r/p/c', 'attribute::b', Attribute ],
     ['/r/p/c', '@b', Attribute ],
     ['/r/p/c', 'attribute::*', Attribute ],
     ['/r/p/c', '@*', Attribute ]
    ].each do |nodepath, xpath, kind|
      begin
        context = REXML::XPath.first(doc, nodepath)
        REXML::XPath.each( context, xpath ) do |what|
          assert_kind_of kind, what, "Wrong type (#{what.class}) returned for #{xpath} (expected #{kind.name})\n"
        end
      rescue Exception
        puts "PATH WAS: #{xpath}"
        raise
      end
    end
  end

  def test_entities_Holden_Glova
    document = <<-EOL
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE rubynet [
    <!ENTITY rbconfig.MAJOR "1">
    <!ENTITY rbconfig.MINOR "7">
    <!ENTITY rbconfig.TEENY "2">
    <!ENTITY rbconfig.ruby_version "&rbconfig.MAJOR;.&rbconfig.MINOR;">
    <!ENTITY rbconfig.arch "i386-freebsd5">
    <!ENTITY rbconfig.prefix "/usr/local">
    <!ENTITY rbconfig.libdir "&rbconfig.prefix;/lib">
    <!ENTITY rbconfig.includedir "&rbconfig.prefix;/include">
    <!ENTITY rbconfig.sitedir "&rbconfig.prefix;/lib/ruby/site_ruby">
    <!ENTITY rbconfig.sitelibdir "&rbconfig.sitedir;/&rbconfig.ruby_version;">
    <!ENTITY rbconfig.sitearchdir "&rbconfig.sitelibdir;/&rbconfig.arch;">
    ]>
    <rubynet>
      <pkg version="version1.0">
        <files>
          <file>
            <filename>uga.rb</filename>
            <mode>0444</mode>
            <path>&rbconfig.libdir;/rexml</path>
            <content encoding="xml">... the file here</content>
          </file>
          <file>
            <filename>booga.h</filename>
            <mode>0444</mode>
            <path>&rbconfig.includedir;</path>
            <content encoding="xml">... the file here</content>
          </file>
          <file>
            <filename>foo.so</filename>
            <mode>0555</mode>
            <path>&rbconfig.sitearchdir;/rexml</path>
            <content encoding="mime64">Li4uIHRoZSBmaWxlIGhlcmU=\n</content>
          </file>
        </files>
      </pkg>
    </rubynet>
    EOL

    file_xpath = '/rubynet/pkg/files/file'

    root = REXML::Document.new(document)

    root.elements.each(file_xpath) do |metadata|
      text = metadata.elements['path'].get_text.value
      assert text !~ /&rbconfig/, "'#{text}' failed"
    end

    #Error occurred in test_package_file_opens(TC_PackageInstall): 
    # ArgumentError:
    #illegal access mode &rbconfig.prefix;/lib/rexml
    #
    #[synack@Evergreen] src $ ruby --version
    #ruby 1.6.7 (2002-03-01) [i686-linux-gnu]
    #
    #It looks like it expanded the first entity, but didn't reparse it for more
    #entities. possible bug - or have I mucked this up?
  end

  def test_whitespace_after_xml_decl
    d = Document.new <<EOL
<?xml version='1.0'?>
  <blo>
    <wak>
    </wak>
</blo>
EOL
  end

  def test_external_entity
    xp = '//channel/title'

    %w{working.rss broken.rss}.each do |path|
      File.open(File.join(fixture_path(path))) do |file|
        doc = REXML::Document.new file.readlines.join('')

        # check to make sure everything is kosher
        assert_equal( doc.root.class, REXML::Element )
        assert_equal( doc.root.elements.class, REXML::Elements )

        # get the title of the feed
        assert( doc.root.elements[xp].kind_of?( REXML::Element ) )
      end
    end
  end

  def test_maintain_dtd 
    src = %q{<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE ivattacks SYSTEM "../../ivacm.dtd" [
<!ENTITY % extern-packages SYSTEM "../../ivpackages.dtd">
<!ENTITY % extern-packages SYSTEM "../../common-declarations.dtd">
%extern-packages;
%extern-common;
]>}
    doc = Document.new( src )
    doc.write( out="" )
    src = src.tr('"', "'")
    out = out.tr('"', "'")
    assert_equal( src, out )
  end

  def test_text_nodes_nomatch
    source = "<root><child>test</child></root>"
    d = REXML::Document.new( source )
    r = REXML::XPath.match( d, %q{/root/child[text()="no-test"]} )
    assert_equal( 0, r.size )
  end

  def test_raw_Terje_Elde
    f = REXML::Formatters::Default.new
    txt = 'abc&#248;def'
    a = Text.new( txt,false,nil,true )
    f.write(a,out="")
    assert_equal( txt, out )

    txt = '<sean><russell>abc&#248;def</russell></sean>'
    a = Document.new( txt, { :raw => ["russell"] } )
    f.write(a,out="")
    assert_equal( txt, out )
  end

  def test_indenting_error
    a=Element.new("test1")
    b=Element.new("test2")
    c=Element.new("test3")
    b << c
    a << b

    REXML::Formatters::Pretty.new.write(a,s="")
  end

  def test_pos
    testfile = "/tmp/tidal#{$$}"
    testdata = %Q{<calibration>
<section name="parameters">
<param name="barpress">760</param>
<param name="hertz">50</param>
</section>
</calibration>
}

    File.open(testfile, 'w') do |f|
        f.puts testdata
    end
    File.open(testfile) do |f|
        d = REXML::Document.new(f)
    end
    #File.unlink(testfile)
  end

  def test_deep_clone
    a = Document.new( '<?xml version="1.0"?><!DOCTYPE html PUBLIC
    "-//W3C//DTD
    XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html
    xmlns="http:///www.w3.org/1999/xhtml"></html>' )
    b = a.deep_clone
    assert_equal a.to_s, b.to_s
  end

  def test_double_escaping
    data = '<title>AT&amp;T</title>'
    xml = "<description><![CDATA[#{data}]]></description>"

    doc = REXML::Document.new(xml)
    description = doc.find {|e| e.name=="description"}
    assert_equal data, description.text
  end

  def test_ticket_12
    cfg = "<element><anotherelement><child1>a</child1><child2>b</child2></anotherelement></element>"

    config = REXML::Document.new( cfg )

    assert_equal( "a", config.elements[ "//child1" ].text )
  end

=begin
 # This is a silly test, and is low priority
 def test_namespace_serialization_tobi_reif
   doc = Document.new '<doc xmlns:b="http://www.foo.foo">
 <b:p/>
</doc>'
   ns = 'http://www.foo.foo'
   ns_declaration={'f'=>ns}
   returned = XPath.match(doc,'//f:p',ns_declaration)
   # passes:
   assert( (returned[0].namespace==ns), 'namespace should be '+ns)
   serialized = returned.to_s
   serialized_and_parsed = Document.new(serialized)
   puts 'serialized: '+serialized
     # ... currently brings <b:p/>
     # prefix b is undeclared (!)
   assert( (serialized_and_parsed.namespace==ns),
     'namespace should still be '+ns.inspect+
     ' and not '+serialized_and_parsed.namespace.inspect)
   # ... currently results in a failure:
   # 'namespace should still be "http://www.foo.foo" and not ""'
 end
=end
end