pdf-labels 1.0.0 → 1.0.1

data/vendor/xml-mapping/test/xpath_test.rb

@@ -1,273 +0,0 @@
-require File.dirname(__FILE__)+"/tests_init"
-
-require 'test/unit'
-
-require "rexml/document"
-require "xml/xxpath"
-
-
-class XPathTest < Test::Unit::TestCase
-  include REXML
-
-  def setup
-    @d = Document.new <<-EOS
-    <bla>
-      <foo>x</foo>
-      <bar>bar1</bar>
-      <foo key='xy'>
-        y
-        <u/>
-      </foo>
-    </bla>
-    EOS
-  end
-
-  def test_read_byname
-    assert_equal @d.root.elements.to_a("foo"), XML::XXPath.new("foo").all(@d.root)
-    assert_equal @d.root.elements.to_a("foo")[1].elements.to_a("u"), XML::XXPath.new("foo/u").all(@d.root)
-    assert_equal [], XML::XXPath.new("foo/notthere").all(@d.root)
-  end
-
-
-  def test_read_byidx
-    assert_equal [@d.root.elements[1]], XML::XXPath.new("foo[1]").all(@d.root)
-    assert_equal [@d.root.elements[3]], XML::XXPath.new("foo[2]").all(@d.root)
-    assert_equal [], XML::XXPath.new("foo[10]").all(@d.root)
-    assert_equal [], XML::XXPath.new("foo[3]").all(@d.root)
-  end
-
-
-  def test_read_byall
-    assert_equal @d.root.elements.to_a, XML::XXPath.new("*").all(@d.root)
-    assert_equal [], XML::XXPath.new("notthere/*").all(@d.root)
-  end
-
-
-  def test_read_byattr
-    assert_equal [@d.root.elements[3]], XML::XXPath.new("foo[@key='xy']").all(@d.root)
-    assert_equal [], XML::XXPath.new("foo[@key='notthere']").all(@d.root)
-    assert_equal [], XML::XXPath.new("notthere[@key='xy']").all(@d.root)
-  end
-
-
-  def test_attribute
-    elt = @d.root.elements[3]
-    attr1 = XML::XXPath::Accessors::Attribute.new(elt,"key",false)
-    attr2 = XML::XXPath::Accessors::Attribute.new(elt,"key",false)
-    assert_not_nil attr1
-    assert_not_nil attr2
-    assert_equal attr1,attr2  # tests Attribute.==
-    assert_nil XML::XXPath::Accessors::Attribute.new(elt,"notthere",false)
-    assert_nil XML::XXPath::Accessors::Attribute.new(elt,"notthere",false)
-    newattr = XML::XXPath::Accessors::Attribute.new(elt,"new",true)
-    assert_not_nil newattr
-    assert_equal newattr, XML::XXPath::Accessors::Attribute.new(elt,"new",false)
-    newattr.text = "lala"
-    assert_equal "lala", elt.attributes["new"]
-  end
-
-  def test_read_byattrname
-    assert_equal [XML::XXPath::Accessors::Attribute.new(@d.root.elements[3],"key",false)],
-                 XML::XXPath.new("foo/@key").all(@d.root)
-    assert_equal [], XML::XXPath.new("foo/@notthere").all(@d.root)
-  end
-
-
-  def test_read_byidx_then_name
-    assert_equal [@d.root.elements[3].elements[1]], XML::XXPath.new("foo[2]/u").all(@d.root)
-    assert_equal [], XML::XXPath.new("foo[2]/notthere").all(@d.root)
-    assert_equal [], XML::XXPath.new("notthere[2]/u").all(@d.root)
-    assert_equal [], XML::XXPath.new("foo[3]/u").all(@d.root)
-  end
-
-  def test_read_first
-    assert_equal @d.root.elements[3].elements[1], XML::XXPath.new("foo[2]/u").first(@d.root)
-  end
-
-  def test_read_first_nil
-    assert_equal nil, XML::XXPath.new("foo[2]/notthere").first(@d.root, :allow_nil=>true)
-  end
-
-  def test_read_first_exception
-    assert_raises(XML::XXPathError) {
-      XML::XXPath.new("foo[2]/notthere").first(@d.root)
-    }
-  end
-
-
-  def test_write_noop
-    assert_equal @d.root.elements[1], XML::XXPath.new("foo").first(@d.root, :ensure_created=>true)
-    assert_equal @d.root.elements[3].elements[1], XML::XXPath.new("foo[2]/u").first(@d.root, :ensure_created=>true)
-    # TODO: deep-compare of REXML documents?
-  end
-
-  def test_write_byname_then_name
-    s1 = @d.elements[1].elements.size
-    s2 = @d.elements[1].elements[1].elements.size
-    node = XML::XXPath.new("foo/new1").first(@d.root, :ensure_created=>true)
-    assert_equal "new1", node.name
-    assert node.attributes.empty?
-    assert_equal @d.elements[1].elements[1].elements[1], node
-    assert_equal s1, @d.elements[1].elements.size
-    assert_equal s2+1, @d.elements[1].elements[1].elements.size
-  end
-
-
-  def test_write_byidx
-    XML::XXPath.new("foo[2]").first(@d.root, :ensure_created=>true)
-    # TODO: deep-compare of REXML documents?
-    assert_equal 2, @d.root.elements.select{|elt| elt.name=="foo"}.size
-    node = XML::XXPath.new("foo[10]").first(@d.root, :ensure_created=>true)
-    assert_equal 10, @d.root.elements.select{|elt| elt.name=="foo"}.size
-    assert_equal "foo", node.name
-  end
-
-
-  def test_write_byattrname
-    elt = @d.root.elements[3]
-    s1 = elt.attributes.size
-    attr_key = XML::XXPath.new("foo[2]/@key").first(@d.root, :ensure_created=>true)
-    assert_equal elt.attributes["key"], attr_key.text
-
-    attr_new = XML::XXPath.new("foo[2]/@new").first(@d.root, :ensure_created=>true)
-    attr_new.text = "haha"
-    assert_equal "haha", attr_new.text
-    assert_equal "haha", elt.attributes["new"]
-    assert_equal s1+1, elt.attributes.size
-  end
-
-
-  def test_write_byname_and_attr
-    node1 = XML::XXPath.new("hiho[@blubb='bla']").first(@d.root,:ensure_created=>true)
-    node2 = XML::XXPath.new("hiho[@blubb='bla']").first(@d.root,:ensure_created=>true)
-    node3 = XML::XXPath.new("hiho[@blubb2='bla2']").first(@d.root,:ensure_created=>true)
-    assert_equal node1, node2
-    assert_equal node2, node3
-    assert_equal "hiho", node1.name
-    assert_equal 4, @d.root.elements.size
-    assert_equal @d.root.elements[4], node1
-    assert_equal @d.root.elements[4], node3
-    assert_equal 'bla', node3.attributes['blubb']
-    assert_equal 'bla2', node3.attributes['blubb2']
-
-    node4 = XML::XXPath.new("hiho[@blubb='foo42']").first(@d.root,:ensure_created=>true)
-    assert_not_equal node3, node4
-    assert_equal 5, @d.root.elements.size
-    assert_equal @d.root.elements[5], node4
-    assert_equal 'foo42', node4.attributes['blubb']
-  end
-
-
-  def test_create_new_byname
-    s1 = @d.elements[1].elements.size
-    s2 = @d.elements[1].elements[1].elements.size
-    startnode = @d.elements[1].elements[1]
-    node1 = XML::XXPath.new("new1").create_new(startnode)
-    node2 = XML::XXPath.new("new1").first(startnode, :create_new=>true) #same as .create_new(...)
-    assert_equal "new1", node1.name
-    assert_equal "new1", node2.name
-    assert node1.attributes.empty?
-    assert node2.attributes.empty?
-    assert_equal @d.elements[1].elements[1].elements[1], node1
-    assert_equal @d.elements[1].elements[1].elements[2], node2
-    assert_equal s1, @d.elements[1].elements.size
-    assert_equal s2+2, @d.elements[1].elements[1].elements.size
-  end
-
-
-  def test_create_new_byname_then_name
-    s1 = @d.elements[1].elements.size
-    node1 = XML::XXPath.new("foo/new1").create_new(@d.root)
-    node2 = XML::XXPath.new("foo/new1").create_new(@d.root)
-    assert_equal "new1", node1.name
-    assert_equal "new1", node2.name
-    assert node1.attributes.empty?
-    assert node2.attributes.empty?
-    assert_equal @d.elements[1].elements[s1+1].elements[1], node1
-    assert_equal @d.elements[1].elements[s1+2].elements[1], node2
-    assert_equal s1+2, @d.elements[1].elements.size
-  end
-
-
-  def test_create_new_byidx
-    assert_raises(XML::XXPathError) {
-      XML::XXPath.new("foo[2]").create_new(@d.root)
-    }
-    node1 = XML::XXPath.new("foo[3]").create_new(@d.root)
-    assert_raises(XML::XXPathError) {
-      XML::XXPath.new("foo[3]").create_new(@d.root)
-    }
-    assert_equal @d.elements[1].elements[4], node1
-    assert_equal "foo", node1.name
-    node2 = XML::XXPath.new("foo[4]").create_new(@d.root)
-    assert_equal @d.elements[1].elements[5], node2
-    assert_equal "foo", node2.name
-    node3 = XML::XXPath.new("foo[10]").create_new(@d.root)
-    assert_raises(XML::XXPathError) {
-      XML::XXPath.new("foo[10]").create_new(@d.root)
-    }
-    XML::XXPath.new("foo[11]").create_new(@d.root)
-    assert_equal @d.elements[1].elements[11], node3
-    assert_equal "foo", node3.name
-    # @d.write
-  end
-
-  def test_create_new_byname_then_idx
-    node1 = XML::XXPath.new("hello/bar[3]").create_new(@d.root)
-    node2 = XML::XXPath.new("hello/bar[3]").create_new(@d.root)
-      # same as create_new
-    node3 = XML::XXPath.new("hello/bar[3]").create_new(@d.root)
-    assert_equal @d.elements[1].elements[4].elements[3], node1
-    assert_equal @d.elements[1].elements[5].elements[3], node2
-    assert_equal @d.elements[1].elements[6].elements[3], node3
-    assert_not_equal node1, node2
-    assert_not_equal node1, node3
-    assert_not_equal node2, node3
-  end
-
-
-  def test_create_new_byattrname
-    node1 = XML::XXPath.new("@lala").create_new(@d.root)
-    assert_raises(XML::XXPathError) {
-      XML::XXPath.new("@lala").create_new(@d.root)
-    }
-    assert node1.kind_of?(XML::XXPath::Accessors::Attribute)
-    node1.text = "val1"
-    assert_equal "val1", @d.elements[1].attributes["lala"]
-    foo2 = XML::XXPath.new("foo[2]").first(@d.root)
-    assert_raises(XML::XXPathError) {
-      XML::XXPath.new("@key").create_new(foo2)
-    }
-    node2 = XML::XXPath.new("@bar").create_new(foo2)
-    assert node2.kind_of?(XML::XXPath::Accessors::Attribute)
-    node2.text = "val2"
-    assert_equal "val2", @d.elements[1].elements[3].attributes["bar"]
-  end
-
-
-  def test_create_new_byname_and_attr
-    node1 = XML::XXPath.new("hiho[@blubb='bla']").create_new(@d.root)
-    node2 = XML::XXPath.new("hiho[@blubb='bla']").create_new(@d.root)
-    node3 = XML::XXPath.new("hiho[@blubb2='bla']").create_new(@d.root)
-    assert_equal "hiho", node1.name
-    assert_equal "hiho", node2.name
-    assert_equal @d.root.elements[4], node1
-    assert_equal @d.root.elements[5], node2
-    assert_equal @d.root.elements[6], node3
-    assert_not_equal @d.root.elements[5], node1
-  end
-
-
-  def test_unspecifiedness
-    node1 = XML::XXPath.new("foo/hello").create_new(@d.root)
-    assert(!(node1.unspecified?))
-    assert_equal @d.root, node1.parent.parent
-    node2 = XML::XXPath.new("foo/*").create_new(@d.root)
-    assert_equal @d.root, node2.parent.parent
-    assert node2.unspecified?
-    node2.name = "newone"
-    assert_equal "newone", node2.name
-    assert(!(node2.unspecified?))
-  end
-
-end