github
/
ruby
зеркало из https://github.com/github/ruby.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Ignore rexml examples on ruby/spec

This commit is contained in:
Hiroshi SHIBATA 2020-01-12 08:14:26 +09:00 коммит произвёл SHIBATA Hiroshi
Родитель 83240f315a
Коммит e61cab3a36
104 изменённых файлов: 1863 добавлений и 1551 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

17
spec/ruby/library/rexml/attribute/clone_spec.rb
Просмотреть файл

@ -1,11 +1,14 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#clone" do
it "returns a copy of this Attribute" do
orig = REXML::Attribute.new("name", "value&&")
orig.should == orig.clone
orig.clone.to_s.should == orig.to_s
orig.clone.to_string.should == orig.to_string
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Attribute#clone" do
it "returns a copy of this Attribute" do
orig = REXML::Attribute.new("name", "value&&")
orig.should == orig.clone
orig.clone.to_s.should == orig.to_s
orig.clone.to_string.should == orig.to_string
end
end
end

39
spec/ruby/library/rexml/attribute/element_spec.rb
Просмотреть файл

@ -1,23 +1,26 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#element" do
it "returns the parent element" do
e = REXML::Element.new "root"
ruby_version_is ''...'2.8' do
require 'rexml/document'
REXML::Attribute.new("name", "value", e).element.should == e
REXML::Attribute.new("name", "default_constructor").element.should == nil
end
end
describe "REXML::Attribute#element=" do
it "sets the parent element" do
e = REXML::Element.new "root"
f = REXML::Element.new "temp"
a = REXML::Attribute.new("name", "value", e)
a.element.should == e
a.element = f
a.element.should == f
describe "REXML::Attribute#element" do
it "returns the parent element" do
e = REXML::Element.new "root"
REXML::Attribute.new("name", "value", e).element.should == e
REXML::Attribute.new("name", "default_constructor").element.should == nil
end
end
describe "REXML::Attribute#element=" do
it "sets the parent element" do
e = REXML::Element.new "root"
f = REXML::Element.new "temp"
a = REXML::Attribute.new("name", "value", e)
a.element.should == e
a.element = f
a.element.should == f
end
end
end

25
spec/ruby/library/rexml/attribute/equal_value_spec.rb
Просмотреть файл

@ -1,18 +1,21 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#==" do
it "returns true if other has equal name and value" do
a1 = REXML::Attribute.new("foo", "bar")
a1.should == a1.clone
ruby_version_is ''...'2.8' do
require 'rexml/document'
a2 = REXML::Attribute.new("foo", "bar")
a1.should == a2
describe "REXML::Attribute#==" do
it "returns true if other has equal name and value" do
a1 = REXML::Attribute.new("foo", "bar")
a1.should == a1.clone
a3 = REXML::Attribute.new("foo", "bla")
a1.should_not == a3
a2 = REXML::Attribute.new("foo", "bar")
a1.should == a2
a4 = REXML::Attribute.new("baz", "bar")
a1.should_not == a4
a3 = REXML::Attribute.new("foo", "bla")
a1.should_not == a3
a4 = REXML::Attribute.new("baz", "bar")
a1.should_not == a4
end
end
end

21
spec/ruby/library/rexml/attribute/hash_spec.rb
Просмотреть файл

@ -1,13 +1,16 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#hash" do
# These are not really complete, any idea on how to make them more
# "testable" will be appreciated.
it "returns a hashcode made of the name and value of self" do
a = REXML::Attribute.new("name", "value")
a.hash.should be_kind_of(Numeric)
b = REXML::Attribute.new(a)
a.hash.should == b.hash
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Attribute#hash" do
# These are not really complete, any idea on how to make them more
# "testable" will be appreciated.
it "returns a hashcode made of the name and value of self" do
a = REXML::Attribute.new("name", "value")
a.hash.should be_kind_of(Numeric)
b = REXML::Attribute.new(a)
a.hash.should == b.hash
end
end
end

45
spec/ruby/library/rexml/attribute/initialize_spec.rb
Просмотреть файл

@ -1,29 +1,32 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#initialize" do
before :each do
@e = REXML::Element.new "root"
@name = REXML::Attribute.new("name", "Nicko")
@e.add_attribute @name
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "receives two strings for name and value" do
@e.attributes["name"].should == "Nicko"
@e.add_attribute REXML::Attribute.new("last_name", nil)
@e.attributes["last_name"].should == ""
end
describe "REXML::Attribute#initialize" do
before :each do
@e = REXML::Element.new "root"
@name = REXML::Attribute.new("name", "Nicko")
@e.add_attribute @name
end
it "receives an Attribute and clones it" do
copy = REXML::Attribute.new(@name)
copy.should == @name
end
it "receives two strings for name and value" do
@e.attributes["name"].should == "Nicko"
@e.add_attribute REXML::Attribute.new("last_name", nil)
@e.attributes["last_name"].should == ""
end
it "receives a parent node" do
last_name = REXML::Attribute.new("last_name", "McBrain", @e)
last_name.element.should == @e
it "receives an Attribute and clones it" do
copy = REXML::Attribute.new(@name)
copy.should == @name
end
last_name = REXML::Attribute.new(@name, @e)
last_name.element.should == @e
it "receives a parent node" do
last_name = REXML::Attribute.new("last_name", "McBrain", @e)
last_name.element.should == @e
last_name = REXML::Attribute.new(@name, @e)
last_name.element.should == @e
end
end
end

29
spec/ruby/library/rexml/attribute/inspect_spec.rb
Просмотреть файл

@ -1,19 +1,22 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#inspect" do
it "returns the name and value as a string" do
a = REXML::Attribute.new("my_name", "my_value")
a.inspect.should == "my_name='my_value'"
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "accepts attributes with no value" do
a = REXML::Attribute.new("my_name")
a.inspect.should == "my_name=''"
end
describe "REXML::Attribute#inspect" do
it "returns the name and value as a string" do
a = REXML::Attribute.new("my_name", "my_value")
a.inspect.should == "my_name='my_value'"
end
it "does not escape text" do
a = REXML::Attribute.new("name", "<>")
a.inspect.should == "name='<>'"
it "accepts attributes with no value" do
a = REXML::Attribute.new("my_name")
a.inspect.should == "my_name=''"
end
it "does not escape text" do
a = REXML::Attribute.new("name", "<>")
a.inspect.should == "name='<>'"
end
end
end

39
spec/ruby/library/rexml/attribute/namespace_spec.rb
Просмотреть файл

@ -1,24 +1,27 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#namespace" do
it "returns the namespace url" do
e = REXML::Element.new("root")
e.add_attribute REXML::Attribute.new("xmlns:ns", "http://some_uri")
e.namespace("ns").should == "http://some_uri"
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns nil if namespace is not defined" do
e = REXML::Element.new("root")
e.add_attribute REXML::Attribute.new("test", "value")
e.namespace("test").should == nil
e.namespace("ns").should == nil
end
describe "REXML::Attribute#namespace" do
it "returns the namespace url" do
e = REXML::Element.new("root")
e.add_attribute REXML::Attribute.new("xmlns:ns", "http://some_uri")
e.namespace("ns").should == "http://some_uri"
end
it "defaults arg to nil" do
e = REXML::Element.new("root")
e.add_attribute REXML::Attribute.new("xmlns:ns", "http://some_uri")
e.namespace.should == ""
e.namespace("ns").should == "http://some_uri"
it "returns nil if namespace is not defined" do
e = REXML::Element.new("root")
e.add_attribute REXML::Attribute.new("test", "value")
e.namespace("test").should == nil
e.namespace("ns").should == nil
end
it "defaults arg to nil" do
e = REXML::Element.new("root")
e.add_attribute REXML::Attribute.new("xmlns:ns", "http://some_uri")
e.namespace.should == ""
e.namespace("ns").should == "http://some_uri"
end
end
end

15
spec/ruby/library/rexml/attribute/node_type_spec.rb
Просмотреть файл

@ -1,10 +1,13 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#node_type" do
it "always returns :attribute" do
attr = REXML::Attribute.new("foo", "bar")
attr.node_type.should == :attribute
REXML::Attribute.new(attr).node_type.should == :attribute
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Attribute#node_type" do
it "always returns :attribute" do
attr = REXML::Attribute.new("foo", "bar")
attr.node_type.should == :attribute
REXML::Attribute.new(attr).node_type.should == :attribute
end
end
end

25
spec/ruby/library/rexml/attribute/prefix_spec.rb
Просмотреть файл

@ -1,18 +1,21 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#prefix" do
it "returns the namespace of the Attribute" do
ans = REXML::Attribute.new("ns:someattr", "some_value")
out = REXML::Attribute.new("out:something", "some_other_value")
ruby_version_is ''...'2.8' do
require 'rexml/document'
ans.prefix.should == "ns"
out.prefix.should == "out"
end
describe "REXML::Attribute#prefix" do
it "returns the namespace of the Attribute" do
ans = REXML::Attribute.new("ns:someattr", "some_value")
out = REXML::Attribute.new("out:something", "some_other_value")
it "returns an empty string for Attributes with no prefixes" do
attr = REXML::Attribute.new("foo", "bar")
ans.prefix.should == "ns"
out.prefix.should == "out"
end
attr.prefix.should == ""
it "returns an empty string for Attributes with no prefixes" do
attr = REXML::Attribute.new("foo", "bar")
attr.prefix.should == ""
end
end
end

31
spec/ruby/library/rexml/attribute/remove_spec.rb
Просмотреть файл

@ -1,20 +1,23 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#remove" do
before :each do
@e = REXML::Element.new "Root"
@attr = REXML::Attribute.new("foo", "bar")
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "deletes this Attribute from parent" do
@e.add_attribute(@attr)
@e.attributes["foo"].should_not == nil
@attr.remove
@e.attributes["foo"].should == nil
end
describe "REXML::Attribute#remove" do
before :each do
@e = REXML::Element.new "Root"
@attr = REXML::Attribute.new("foo", "bar")
end
it "does not anything if element has no parent" do
-> {@attr.remove}.should_not raise_error(Exception)
it "deletes this Attribute from parent" do
@e.add_attribute(@attr)
@e.attributes["foo"].should_not == nil
@attr.remove
@e.attributes["foo"].should == nil
end
it "does not anything if element has no parent" do
-> {@attr.remove}.should_not raise_error(Exception)
end
end
end

21
spec/ruby/library/rexml/attribute/to_s_spec.rb
Просмотреть файл

@ -1,14 +1,17 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#to_s" do
it "returns the value of the Attribute" do
REXML::Attribute.new("name", "some_value").to_s.should == "some_value"
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns the escaped value if it was created from Attribute" do
orig = REXML::Attribute.new("name", "<&>")
copy = REXML::Attribute.new(orig)
copy.to_s.should == "&lt;&amp;&gt;"
describe "REXML::Attribute#to_s" do
it "returns the value of the Attribute" do
REXML::Attribute.new("name", "some_value").to_s.should == "some_value"
end
it "returns the escaped value if it was created from Attribute" do
orig = REXML::Attribute.new("name", "<&>")
copy = REXML::Attribute.new(orig)
copy.to_s.should == "&lt;&amp;&gt;"
end
end
end

21
spec/ruby/library/rexml/attribute/to_string_spec.rb
Просмотреть файл

@ -1,14 +1,17 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#to_string" do
it "returns the attribute as XML" do
attr = REXML::Attribute.new("name", "value")
attr_empty = REXML::Attribute.new("name")
attr_ns = REXML::Attribute.new("xmlns:ns", "http://uri")
ruby_version_is ''...'2.8' do
require 'rexml/document'
attr.to_string.should == "name='value'"
attr_empty.to_string.should == "name=''"
attr_ns.to_string.should == "xmlns:ns='http://uri'"
describe "REXML::Attribute#to_string" do
it "returns the attribute as XML" do
attr = REXML::Attribute.new("name", "value")
attr_empty = REXML::Attribute.new("name")
attr_ns = REXML::Attribute.new("xmlns:ns", "http://uri")
attr.to_string.should == "name='value'"
attr_empty.to_string.should == "name=''"
attr_ns.to_string.should == "xmlns:ns='http://uri'"
end
end
end

21
spec/ruby/library/rexml/attribute/value_spec.rb
Просмотреть файл

@ -1,14 +1,17 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#value" do
it "returns the value of the Attribute unnormalized" do
attr = REXML::Attribute.new("name", "value")
attr_ents = REXML::Attribute.new("name", "<&>")
attr_empty = REXML::Attribute.new("name")
ruby_version_is ''...'2.8' do
require 'rexml/document'
attr.value.should == "value"
attr_ents.value.should == "<&>"
attr_empty.value.should == ""
describe "REXML::Attribute#value" do
it "returns the value of the Attribute unnormalized" do
attr = REXML::Attribute.new("name", "value")
attr_ents = REXML::Attribute.new("name", "<&>")
attr_empty = REXML::Attribute.new("name")
attr.value.should == "value"
attr_ents.value.should == "<&>"
attr_empty.value.should == ""
end
end
end

35
spec/ruby/library/rexml/attribute/write_spec.rb
Просмотреть файл

@ -1,23 +1,26 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#write" do
before :each do
@attr = REXML::Attribute.new("name", "Charlotte")
@s = ""
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "writes the name and value to output" do
@attr.write(@s)
@s.should == "name='Charlotte'"
end
describe "REXML::Attribute#write" do
before :each do
@attr = REXML::Attribute.new("name", "Charlotte")
@s = ""
end
it "currently ignores the second argument" do
@attr.write(@s, 3)
@s.should == "name='Charlotte'"
it "writes the name and value to output" do
@attr.write(@s)
@s.should == "name='Charlotte'"
end
@s = ""
@attr.write(@s, "foo")
@s.should == "name='Charlotte'"
it "currently ignores the second argument" do
@attr.write(@s, 3)
@s.should == "name='Charlotte'"
@s = ""
@attr.write(@s, "foo")
@s.should == "name='Charlotte'"
end
end
end

27
spec/ruby/library/rexml/attribute/xpath_spec.rb
Просмотреть файл

@ -1,19 +1,22 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attribute#xpath" do
ruby_version_is ''...'2.8' do
require 'rexml/document'
before :each do
@e = REXML::Element.new "root"
@attr = REXML::Attribute.new("year", "1989")
end
describe "REXML::Attribute#xpath" do
it "returns the path for Attribute" do
@e.add_attribute @attr
@attr.xpath.should == "root/@year"
end
before :each do
@e = REXML::Element.new "root"
@attr = REXML::Attribute.new("year", "1989")
end
it "raises an error if attribute has no parent" do
-> { @attr.xpath }.should raise_error(Exception)
it "returns the path for Attribute" do
@e.add_attribute @attr
@attr.xpath.should == "root/@year"
end
it "raises an error if attribute has no parent" do
-> { @attr.xpath }.should raise_error(Exception)
end
end
end

11
spec/ruby/library/rexml/attributes/add_spec.rb
Просмотреть файл

@ -1,7 +1,10 @@
require_relative '../../../spec_helper'
require_relative 'shared/add'
require 'rexml/document'
describe "REXML::Attributes#add" do
it_behaves_like :rexml_attribute_add, :add
ruby_version_is ''...'2.8' do
require_relative 'shared/add'
require 'rexml/document'
describe "REXML::Attributes#add" do
it_behaves_like :rexml_attribute_add, :add
end
end

11
spec/ruby/library/rexml/attributes/append_spec.rb
Просмотреть файл

@ -1,7 +1,10 @@
require_relative '../../../spec_helper'
require_relative 'shared/add'
require 'rexml/document'
describe "REXML::Attributes#<<" do
it_behaves_like :rexml_attribute_add, :<<
ruby_version_is ''...'2.8' do
require_relative 'shared/add'
require 'rexml/document'
describe "REXML::Attributes#<<" do
it_behaves_like :rexml_attribute_add, :<<
end
end

51
spec/ruby/library/rexml/attributes/delete_all_spec.rb
Просмотреть файл

@ -1,31 +1,34 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attributes#delete_all" do
before :each do
@e = REXML::Element.new("root")
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "deletes all attributes that match name" do
uri = REXML::Attribute.new("uri", "http://something")
@e.attributes << uri
@e.attributes.delete_all("uri")
@e.attributes.should be_empty
@e.attributes["uri"].should == nil
end
describe "REXML::Attributes#delete_all" do
before :each do
@e = REXML::Element.new("root")
end
it "deletes all attributes that match name with a namespace" do
ns_uri = REXML::Attribute.new("xmlns:uri", "http://something_here_too")
@e.attributes << ns_uri
@e.attributes.delete_all("xmlns:uri")
@e.attributes.should be_empty
@e.attributes["xmlns:uri"].should == nil
end
it "deletes all attributes that match name" do
uri = REXML::Attribute.new("uri", "http://something")
@e.attributes << uri
@e.attributes.delete_all("uri")
@e.attributes.should be_empty
@e.attributes["uri"].should == nil
end
it "returns the removed attribute" do
uri = REXML::Attribute.new("uri", "http://something_here_too")
@e.attributes << uri
attrs = @e.attributes.delete_all("uri")
attrs.first.should == uri
it "deletes all attributes that match name with a namespace" do
ns_uri = REXML::Attribute.new("xmlns:uri", "http://something_here_too")
@e.attributes << ns_uri
@e.attributes.delete_all("xmlns:uri")
@e.attributes.should be_empty
@e.attributes["xmlns:uri"].should == nil
end
it "returns the removed attribute" do
uri = REXML::Attribute.new("uri", "http://something_here_too")
@e.attributes << uri
attrs = @e.attributes.delete_all("uri")
attrs.first.should == uri
end
end
end

43
spec/ruby/library/rexml/attributes/delete_spec.rb
Просмотреть файл

@ -1,27 +1,30 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attributes#delete" do
before :each do
@e = REXML::Element.new("root")
@name = REXML::Attribute.new("name", "Pepe")
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "takes an attribute name and deletes the attribute" do
@e.attributes.delete("name")
@e.attributes["name"].should be_nil
@e.attributes.should be_empty
end
describe "REXML::Attributes#delete" do
before :each do
@e = REXML::Element.new("root")
@name = REXML::Attribute.new("name", "Pepe")
end
it "takes an Attribute and deletes it" do
@e.attributes.delete(@name)
@e.attributes["name"].should be_nil
@e.attributes.should be_empty
end
it "takes an attribute name and deletes the attribute" do
@e.attributes.delete("name")
@e.attributes["name"].should be_nil
@e.attributes.should be_empty
end
it "returns the element with the attribute removed" do
ret_val = @e.attributes.delete(@name)
ret_val.should == @e
ret_val.attributes.should be_empty
it "takes an Attribute and deletes it" do
@e.attributes.delete(@name)
@e.attributes["name"].should be_nil
@e.attributes.should be_empty
end
it "returns the element with the attribute removed" do
ret_val = @e.attributes.delete(@name)
ret_val.should == @e
ret_val.attributes.should be_empty
end
end
end

33
spec/ruby/library/rexml/attributes/each_attribute_spec.rb
Просмотреть файл

@ -1,22 +1,25 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attributes#each_attribute" do
it "iterates over the attributes yielding actual Attribute objects" do
e = REXML::Element.new("root")
name = REXML::Attribute.new("name", "Joe")
ns_uri = REXML::Attribute.new("xmlns:ns", "http://some_uri")
e.add_attribute name
e.add_attribute ns_uri
ruby_version_is ''...'2.8' do
require 'rexml/document'
attributes = []
describe "REXML::Attributes#each_attribute" do
it "iterates over the attributes yielding actual Attribute objects" do
e = REXML::Element.new("root")
name = REXML::Attribute.new("name", "Joe")
ns_uri = REXML::Attribute.new("xmlns:ns", "http://some_uri")
e.add_attribute name
e.add_attribute ns_uri
e.attributes.each_attribute do |attr|
attributes << attr
attributes = []
e.attributes.each_attribute do |attr|
attributes << attr
end
attributes = attributes.sort_by {|a| a.name }
attributes.first.should == name
attributes.last.should == ns_uri
end
attributes = attributes.sort_by {|a| a.name }
attributes.first.should == name
attributes.last.should == ns_uri
end
end

37
spec/ruby/library/rexml/attributes/each_spec.rb
Просмотреть файл

@ -1,23 +1,26 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attributes#each" do
before :each do
@e = REXML::Element.new("root")
@name = REXML::Attribute.new("name", "Joe")
@ns_uri = REXML::Attribute.new("xmlns:ns", "http://some_uri")
@e.add_attribute @name
@e.add_attribute @ns_uri
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "iterates over the attributes yielding expanded-name/value" do
attributes = []
@e.attributes.each do |attr|
attr.should be_kind_of(Array)
attributes << attr
describe "REXML::Attributes#each" do
before :each do
@e = REXML::Element.new("root")
@name = REXML::Attribute.new("name", "Joe")
@ns_uri = REXML::Attribute.new("xmlns:ns", "http://some_uri")
@e.add_attribute @name
@e.add_attribute @ns_uri
end
it "iterates over the attributes yielding expanded-name/value" do
attributes = []
@e.attributes.each do |attr|
attr.should be_kind_of(Array)
attributes << attr
end
attributes = attributes.sort_by {|a| a.first }
attributes.first.should == ["name", "Joe"]
attributes.last.should == ["xmlns:ns", "http://some_uri"]
end
attributes = attributes.sort_by {|a| a.first }
attributes.first.should == ["name", "Joe"]
attributes.last.should == ["xmlns:ns", "http://some_uri"]
end
end

27
spec/ruby/library/rexml/attributes/element_reference_spec.rb
Просмотреть файл

@ -1,18 +1,21 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attributes#[]" do
before :each do
@e = REXML::Element.new("root")
@lang = REXML::Attribute.new("language", "english")
@e.attributes << @lang
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns the value of an attribute" do
@e.attributes["language"].should == "english"
end
describe "REXML::Attributes#[]" do
before :each do
@e = REXML::Element.new("root")
@lang = REXML::Attribute.new("language", "english")
@e.attributes << @lang
end
it "returns nil if the attribute does not exist" do
@e.attributes["chunky bacon"].should == nil
it "returns the value of an attribute" do
@e.attributes["language"].should == "english"
end
it "returns nil if the attribute does not exist" do
@e.attributes["chunky bacon"].should == nil
end
end
end

39
spec/ruby/library/rexml/attributes/element_set_spec.rb
Просмотреть файл

@ -1,25 +1,28 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attributes#[]=" do
before :each do
@e = REXML::Element.new("song")
@name = REXML::Attribute.new("name", "Holy Smoke!")
@e.attributes << @name
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "sets an attribute" do
@e.attributes["author"] = "_why's foxes"
@e.attributes["author"].should == "_why's foxes"
end
describe "REXML::Attributes#[]=" do
before :each do
@e = REXML::Element.new("song")
@name = REXML::Attribute.new("name", "Holy Smoke!")
@e.attributes << @name
end
it "overwrites an existing attribute" do
@e.attributes["name"] = "Chunky Bacon"
@e.attributes["name"].should == "Chunky Bacon"
end
it "sets an attribute" do
@e.attributes["author"] = "_why's foxes"
@e.attributes["author"].should == "_why's foxes"
end
it "deletes an attribute is value is nil" do
@e.attributes["name"] = nil
@e.attributes.length.should == 0
it "overwrites an existing attribute" do
@e.attributes["name"] = "Chunky Bacon"
@e.attributes["name"].should == "Chunky Bacon"
end
it "deletes an attribute is value is nil" do
@e.attributes["name"] = nil
@e.attributes.length.should == 0
end
end
end

23
spec/ruby/library/rexml/attributes/get_attribute_ns_spec.rb
Просмотреть файл

@ -1,14 +1,17 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attributes#get_attribute_ns" do
it "returns an attribute by name and namespace" do
e = REXML::Element.new("root")
attr = REXML::Attribute.new("xmlns:ns", "http://some_url")
e.attributes << attr
attr.prefix.should == "xmlns"
# This might be a bug in Attribute, commenting until those specs
# are ready
# e.attributes.get_attribute_ns(attr.prefix, "name").should == "http://some_url"
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Attributes#get_attribute_ns" do
it "returns an attribute by name and namespace" do
e = REXML::Element.new("root")
attr = REXML::Attribute.new("xmlns:ns", "http://some_url")
e.attributes << attr
attr.prefix.should == "xmlns"
# This might be a bug in Attribute, commenting until those specs
# are ready
# e.attributes.get_attribute_ns(attr.prefix, "name").should == "http://some_url"
end
end
end

45
spec/ruby/library/rexml/attributes/get_attribute_spec.rb
Просмотреть файл

@ -1,29 +1,32 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attributes#get_attribute" do
before :each do
@e = REXML::Element.new("root")
@name = REXML::Attribute.new("name", "Dave")
@e.attributes << @name
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "fetches an attributes" do
@e.attributes.get_attribute("name").should == @name
end
describe "REXML::Attributes#get_attribute" do
before :each do
@e = REXML::Element.new("root")
@name = REXML::Attribute.new("name", "Dave")
@e.attributes << @name
end
it "fetches an namespaced attribute" do
ns_name = REXML::Attribute.new("im:name", "Murray")
@e.attributes << ns_name
@e.attributes.get_attribute("name").should == @name
@e.attributes.get_attribute("im:name").should == ns_name
end
it "fetches an attributes" do
@e.attributes.get_attribute("name").should == @name
end
it "returns an Attribute" do
@e.attributes.get_attribute("name").should be_kind_of(REXML::Attribute)
end
it "fetches an namespaced attribute" do
ns_name = REXML::Attribute.new("im:name", "Murray")
@e.attributes << ns_name
@e.attributes.get_attribute("name").should == @name
@e.attributes.get_attribute("im:name").should == ns_name
end
it "returns nil if it attribute does not exist" do
@e.attributes.get_attribute("fake").should be_nil
it "returns an Attribute" do
@e.attributes.get_attribute("name").should be_kind_of(REXML::Attribute)
end
it "returns nil if it attribute does not exist" do
@e.attributes.get_attribute("fake").should be_nil
end
end
end

27
spec/ruby/library/rexml/attributes/initialize_spec.rb
Просмотреть файл

@ -1,18 +1,21 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attributes#initialize" do
it "is auto initialized by Element" do
e = REXML::Element.new "root"
e.attributes.should be_kind_of(REXML::Attributes)
ruby_version_is ''...'2.8' do
require 'rexml/document'
e.attributes << REXML::Attribute.new("name", "Paul")
e.attributes["name"].should == "Paul"
end
describe "REXML::Attributes#initialize" do
it "is auto initialized by Element" do
e = REXML::Element.new "root"
e.attributes.should be_kind_of(REXML::Attributes)
it "receives a parent node" do
e = REXML::Element.new "root"
e.attributes << REXML::Attribute.new("name", "Vic")
e.attributes["name"].should == "Vic"
e.attributes << REXML::Attribute.new("name", "Paul")
e.attributes["name"].should == "Paul"
end
it "receives a parent node" do
e = REXML::Element.new "root"
e.attributes << REXML::Attribute.new("name", "Vic")
e.attributes["name"].should == "Vic"
end
end
end

11
spec/ruby/library/rexml/attributes/length_spec.rb
Просмотреть файл

@ -1,7 +1,10 @@
require_relative '../../../spec_helper'
require_relative 'shared/length'
require 'rexml/document'
describe "REXML::Attributes#length" do
it_behaves_like :rexml_attribute_length, :length
ruby_version_is ''...'2.8' do
require_relative 'shared/length'
require 'rexml/document'
describe "REXML::Attributes#length" do
it_behaves_like :rexml_attribute_length, :length
end
end

9
spec/ruby/library/rexml/attributes/namespaces_spec.rb
Просмотреть файл

@ -1,6 +1,9 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attributes#namespaces" do
it "needs to be reviewed for spec completeness"
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Attributes#namespaces" do
it "needs to be reviewed for spec completeness"
end
end

37
spec/ruby/library/rexml/attributes/prefixes_spec.rb
Просмотреть файл

@ -1,24 +1,27 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attributes#prefixes" do
before :each do
@e = REXML::Element.new("root")
a1 = REXML::Attribute.new("xmlns:a", "bar")
a2 = REXML::Attribute.new("xmlns:b", "bla")
a3 = REXML::Attribute.new("xmlns:c", "baz")
@e.attributes << a1
@e.attributes << a2
@e.attributes << a3
ruby_version_is ''...'2.8' do
require 'rexml/document'
@e.attributes << REXML::Attribute.new("xmlns", "foo")
end
describe "REXML::Attributes#prefixes" do
before :each do
@e = REXML::Element.new("root")
a1 = REXML::Attribute.new("xmlns:a", "bar")
a2 = REXML::Attribute.new("xmlns:b", "bla")
a3 = REXML::Attribute.new("xmlns:c", "baz")
@e.attributes << a1
@e.attributes << a2
@e.attributes << a3
it "returns an array with the prefixes of each attribute" do
@e.attributes.prefixes.sort.should == ["a", "b", "c"]
end
@e.attributes << REXML::Attribute.new("xmlns", "foo")
end
it "does not include the default namespace" do
@e.attributes.prefixes.include?("xmlns").should == false
it "returns an array with the prefixes of each attribute" do
@e.attributes.prefixes.sort.should == ["a", "b", "c"]
end
it "does not include the default namespace" do
@e.attributes.prefixes.include?("xmlns").should == false
end
end
end

11
spec/ruby/library/rexml/attributes/size_spec.rb
Просмотреть файл

@ -1,7 +1,10 @@
require_relative '../../../spec_helper'
require_relative 'shared/length'
require 'rexml/document'
describe "REXML::Attributes#size" do
it_behaves_like :rexml_attribute_length, :size
ruby_version_is ''...'2.8' do
require_relative 'shared/length'
require 'rexml/document'
describe "REXML::Attributes#size" do
it_behaves_like :rexml_attribute_length, :size
end
end

27
spec/ruby/library/rexml/attributes/to_a_spec.rb
Просмотреть файл

@ -1,19 +1,22 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Attributes#to_a" do
it "returns an array with the attributes" do
e = REXML::Element.new("root")
name = REXML::Attribute.new("name", "Dave")
last = REXML::Attribute.new("last_name", "Murray")
ruby_version_is ''...'2.8' do
require 'rexml/document'
e.attributes << name
e.attributes << last
describe "REXML::Attributes#to_a" do
it "returns an array with the attributes" do
e = REXML::Element.new("root")
name = REXML::Attribute.new("name", "Dave")
last = REXML::Attribute.new("last_name", "Murray")
e.attributes.to_a.sort{|a,b|a.to_s<=>b.to_s}.should == [name, last]
end
e.attributes << name
e.attributes << last
it "returns an empty array if it has no attributes" do
REXML::Element.new("root").attributes.to_a.should == []
e.attributes.to_a.sort{|a,b|a.to_s<=>b.to_s}.should == [name, last]
end
it "returns an empty array if it has no attributes" do
REXML::Element.new("root").attributes.to_a.should == []
end
end
end

15
spec/ruby/library/rexml/cdata/clone_spec.rb
Просмотреть файл

@ -1,10 +1,13 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::CData#clone" do
it "makes a copy of itself" do
c = REXML::CData.new("some text")
c.clone.to_s.should == c.to_s
c.clone.should == c
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::CData#clone" do
it "makes a copy of itself" do
c = REXML::CData.new("some text")
c.clone.to_s.should == c.to_s
c.clone.should == c
end
end
end

37
spec/ruby/library/rexml/cdata/initialize_spec.rb
Просмотреть файл

@ -1,24 +1,27 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::CData#initialize" do
it "creates a new CData object" do
c = REXML::CData.new("some text")
c.should be_kind_of(REXML::CData)
c.should be_kind_of(REXML::Text)
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "respects whitespace if whitespace is true" do
c = REXML::CData.new("whitespace test", true)
c1 = REXML::CData.new("whitespace test", false)
describe "REXML::CData#initialize" do
it "creates a new CData object" do
c = REXML::CData.new("some text")
c.should be_kind_of(REXML::CData)
c.should be_kind_of(REXML::Text)
end
c.to_s.should == "whitespace test"
c1.to_s.should == "whitespace test"
end
it "respects whitespace if whitespace is true" do
c = REXML::CData.new("whitespace test", true)
c1 = REXML::CData.new("whitespace test", false)
it "receives parent as third argument" do
e = REXML::Element.new("root")
REXML::CData.new("test", true, e)
e.to_s.should == "<root><![CDATA[test]]></root>"
c.to_s.should == "whitespace test"
c1.to_s.should == "whitespace test"
end
it "receives parent as third argument" do
e = REXML::Element.new("root")
REXML::CData.new("test", true, e)
e.to_s.should == "<root><![CDATA[test]]></root>"
end
end
end

11
spec/ruby/library/rexml/cdata/to_s_spec.rb
Просмотреть файл

@ -1,7 +1,10 @@
require_relative '../../../spec_helper'
require_relative 'shared/to_s'
require 'rexml/document'
describe "REXML::CData#to_s" do
it_behaves_like :rexml_cdata_to_s, :to_s
ruby_version_is ''...'2.8' do
require_relative 'shared/to_s'
require 'rexml/document'
describe "REXML::CData#to_s" do
it_behaves_like :rexml_cdata_to_s, :to_s
end
end

11
spec/ruby/library/rexml/cdata/value_spec.rb
Просмотреть файл

@ -1,7 +1,10 @@
require_relative '../../../spec_helper'
require_relative 'shared/to_s'
require 'rexml/document'
describe "REXML::CData#value" do
it_behaves_like :rexml_cdata_to_s, :value
ruby_version_is ''...'2.8' do
require_relative 'shared/to_s'
require 'rexml/document'
describe "REXML::CData#value" do
it_behaves_like :rexml_cdata_to_s, :value
end
end

51
spec/ruby/library/rexml/document/add_element_spec.rb
Просмотреть файл

@ -1,31 +1,34 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Document#add_element" do
it "adds arg1 with attributes arg2 as root node" do
d = REXML::Document.new
e = REXML::Element.new("root")
d.add_element e
d.root.should == e
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "sets arg2 as arg1's attributes" do
d = REXML::Document.new
e = REXML::Element.new("root")
attr = {"foo" => "bar"}
d.add_element(e,attr)
d.root.attributes["foo"].should == attr["foo"]
end
describe "REXML::Document#add_element" do
it "adds arg1 with attributes arg2 as root node" do
d = REXML::Document.new
e = REXML::Element.new("root")
d.add_element e
d.root.should == e
end
it "accepts a node name as arg1 and adds it as root" do
d = REXML::Document.new
d.add_element "foo"
d.root.name.should == "foo"
end
it "sets arg2 as arg1's attributes" do
d = REXML::Document.new
e = REXML::Element.new("root")
attr = {"foo" => "bar"}
d.add_element(e,attr)
d.root.attributes["foo"].should == attr["foo"]
end
it "sets arg1's context to the root's context" do
d = REXML::Document.new("", {"foo" => "bar"})
d.add_element "foo"
d.root.context.should == d.context
it "accepts a node name as arg1 and adds it as root" do
d = REXML::Document.new
d.add_element "foo"
d.root.name.should == "foo"
end
it "sets arg1's context to the root's context" do
d = REXML::Document.new("", {"foo" => "bar"})
d.add_element "foo"
d.root.context.should == d.context
end
end
end

99
spec/ruby/library/rexml/document/add_spec.rb
Просмотреть файл

@ -1,57 +1,60 @@
require 'rexml/document'
require_relative '../../../spec_helper'
# This spec defines Document#add and Document#<<
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe :rexml_document_add, shared: true do
before :each do
@doc = REXML::Document.new("<root/>")
@decl = REXML::XMLDecl.new("1.0")
# This spec defines Document#add and Document#<<
describe :rexml_document_add, shared: true do
before :each do
@doc = REXML::Document.new("<root/>")
@decl = REXML::XMLDecl.new("1.0")
end
it "sets document's XML declaration" do
@doc.send(@method, @decl)
@doc.xml_decl.should == @decl
end
it "inserts XML declaration as first node" do
@doc.send(@method, @decl)
@doc.children[0].version.should == "1.0"
end
it "overwrites existing XML declaration" do
@doc.send(@method, @decl)
@doc.send(@method, REXML::XMLDecl.new("2.0"))
@doc.xml_decl.version.should == "2.0"
end
it "sets document DocType" do
@doc.send(@method, REXML::DocType.new("transitional"))
@doc.doctype.name.should == "transitional"
end
it "overwrites existing DocType" do
@doc.send(@method, REXML::DocType.new("transitional"))
@doc.send(@method, REXML::DocType.new("strict"))
@doc.doctype.name.should == "strict"
end
it "adds root node unless it exists" do
d = REXML::Document.new("")
elem = REXML::Element.new "root"
d.send(@method, elem)
d.root.should == elem
end
it "refuses to add second root" do
-> { @doc.send(@method, REXML::Element.new("foo")) }.should raise_error(RuntimeError)
end
end
it "sets document's XML declaration" do
@doc.send(@method, @decl)
@doc.xml_decl.should == @decl
describe "REXML::Document#add" do
it_behaves_like :rexml_document_add, :add
end
it "inserts XML declaration as first node" do
@doc.send(@method, @decl)
@doc.children[0].version.should == "1.0"
end
it "overwrites existing XML declaration" do
@doc.send(@method, @decl)
@doc.send(@method, REXML::XMLDecl.new("2.0"))
@doc.xml_decl.version.should == "2.0"
end
it "sets document DocType" do
@doc.send(@method, REXML::DocType.new("transitional"))
@doc.doctype.name.should == "transitional"
end
it "overwrites existing DocType" do
@doc.send(@method, REXML::DocType.new("transitional"))
@doc.send(@method, REXML::DocType.new("strict"))
@doc.doctype.name.should == "strict"
end
it "adds root node unless it exists" do
d = REXML::Document.new("")
elem = REXML::Element.new "root"
d.send(@method, elem)
d.root.should == elem
end
it "refuses to add second root" do
-> { @doc.send(@method, REXML::Element.new("foo")) }.should raise_error(RuntimeError)
describe "REXML::Document#<<" do
it_behaves_like :rexml_document_add, :<<
end
end
describe "REXML::Document#add" do
it_behaves_like :rexml_document_add, :add
end
describe "REXML::Document#<<" do
it_behaves_like :rexml_document_add, :<<
end

33
spec/ruby/library/rexml/document/clone_spec.rb
Просмотреть файл

@ -1,20 +1,23 @@
require 'rexml/document'
require_relative '../../../spec_helper'
# According to the MRI documentation (http://www.ruby-doc.org/stdlib/libdoc/rexml/rdoc/index.html),
# clone's behavior "should be obvious". Apparently "obvious" means cloning
# only the attributes and the context of the document, not its children.
describe "REXML::Document#clone" do
it "clones document attributes" do
d = REXML::Document.new("foo")
d.attributes["foo"] = "bar"
e = d.clone
e.attributes.should == d.attributes
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "clones document context" do
d = REXML::Document.new("foo", {"foo" => "bar"})
e = d.clone
e.context.should == d.context
# According to the MRI documentation (http://www.ruby-doc.org/stdlib/libdoc/rexml/rdoc/index.html),
# clone's behavior "should be obvious". Apparently "obvious" means cloning
# only the attributes and the context of the document, not its children.
describe "REXML::Document#clone" do
it "clones document attributes" do
d = REXML::Document.new("foo")
d.attributes["foo"] = "bar"
e = d.clone
e.attributes.should == d.attributes
end
it "clones document context" do
d = REXML::Document.new("foo", {"foo" => "bar"})
e = d.clone
e.context.should == d.context
end
end
end

23
spec/ruby/library/rexml/document/doctype_spec.rb
Просмотреть файл

@ -1,15 +1,18 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Document#doctype" do
it "returns the doctype" do
d = REXML::Document.new
dt = REXML::DocType.new("foo")
d.add dt
d.doctype.should == dt
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns nil if there's no doctype" do
REXML::Document.new.doctype.should == nil
describe "REXML::Document#doctype" do
it "returns the doctype" do
d = REXML::Document.new
dt = REXML::DocType.new("foo")
d.add dt
d.doctype.should == dt
end
it "returns nil if there's no doctype" do
REXML::Document.new.doctype.should == nil
end
end
end

33
spec/ruby/library/rexml/document/encoding_spec.rb
Просмотреть файл

@ -1,22 +1,25 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Document#encoding" do
before :each do
@doc = REXML::Document.new
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns encoding from XML declaration" do
@doc.add REXML::XMLDecl.new(nil, "UTF-16", nil)
@doc.encoding.should == "UTF-16"
end
describe "REXML::Document#encoding" do
before :each do
@doc = REXML::Document.new
end
it "returns encoding from XML declaration (for UTF-16 as well)" do
@doc.add REXML::XMLDecl.new("1.0", "UTF-8", nil)
@doc.encoding.should == "UTF-8"
end
it "returns encoding from XML declaration" do
@doc.add REXML::XMLDecl.new(nil, "UTF-16", nil)
@doc.encoding.should == "UTF-16"
end
it "uses UTF-8 as default encoding" do
@doc.encoding.should == "UTF-8"
it "returns encoding from XML declaration (for UTF-16 as well)" do
@doc.add REXML::XMLDecl.new("1.0", "UTF-8", nil)
@doc.encoding.should == "UTF-8"
end
it "uses UTF-8 as default encoding" do
@doc.encoding.should == "UTF-8"
end
end
end

27
spec/ruby/library/rexml/document/expanded_name_spec.rb
Просмотреть файл

@ -1,16 +1,19 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe :document_expanded_name, shared: true do
it "returns an empty string for root" do # root nodes have no expanded name
REXML::Document.new.send(@method).should == ""
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe :document_expanded_name, shared: true do
it "returns an empty string for root" do # root nodes have no expanded name
REXML::Document.new.send(@method).should == ""
end
end
describe "REXML::Document#expanded_name" do
it_behaves_like :document_expanded_name, :expanded_name
end
describe "REXML::Document#name" do
it_behaves_like :document_expanded_name, :name
end
end
describe "REXML::Document#expanded_name" do
it_behaves_like :document_expanded_name, :expanded_name
end
describe "REXML::Document#name" do
it_behaves_like :document_expanded_name, :name
end

55
spec/ruby/library/rexml/document/new_spec.rb
Просмотреть файл

@ -1,36 +1,39 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Document#new" do
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "initializes context of {} unless specified" do
d = REXML::Document.new("<foo />")
d.context.should == {}
end
describe "REXML::Document#new" do
it "has empty attributes if source is nil" do
d = REXML::Document.new(nil)
d.elements.should be_empty
end
it "initializes context of {} unless specified" do
d = REXML::Document.new("<foo />")
d.context.should == {}
end
it "can use other document context" do
s = REXML::Document.new("")
d = REXML::Document.new(s)
d.context.should == s.context
end
it "has empty attributes if source is nil" do
d = REXML::Document.new(nil)
d.elements.should be_empty
end
it "clones source attributes" do
s = REXML::Document.new("<root />")
s.attributes["some_attr"] = "some_val"
d = REXML::Document.new(s)
d.attributes.should == s.attributes
end
it "can use other document context" do
s = REXML::Document.new("")
d = REXML::Document.new(s)
d.context.should == s.context
end
it "raises an error if source is not a Document, String or IO" do
-> {REXML::Document.new(3)}.should raise_error(RuntimeError)
end
it "clones source attributes" do
s = REXML::Document.new("<root />")
s.attributes["some_attr"] = "some_val"
d = REXML::Document.new(s)
d.attributes.should == s.attributes
end
it "does not perform XML validation" do
REXML::Document.new("Invalid document").should be_kind_of(REXML::Document)
it "raises an error if source is not a Document, String or IO" do
-> {REXML::Document.new(3)}.should raise_error(RuntimeError)
end
it "does not perform XML validation" do
REXML::Document.new("Invalid document").should be_kind_of(REXML::Document)
end
end
end

11
spec/ruby/library/rexml/document/node_type_spec.rb
Просмотреть файл

@ -1,8 +1,11 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Document#node_type" do
it "returns :document" do
REXML::Document.new.node_type.should == :document
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Document#node_type" do
it "returns :document" do
REXML::Document.new.node_type.should == :document
end
end
end

17
spec/ruby/library/rexml/document/root_spec.rb
Просмотреть файл

@ -1,12 +1,15 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Document#root" do
it "returns document root tag name" do
REXML::Document.new("<foo/>").root.name.should == "foo"
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns nil if there is not root" do
REXML::Document.new.root.should == nil
describe "REXML::Document#root" do
it "returns document root tag name" do
REXML::Document.new("<foo/>").root.name.should == "foo"
end
it "returns nil if there is not root" do
REXML::Document.new.root.should == nil
end
end
end

31
spec/ruby/library/rexml/document/stand_alone_spec.rb
Просмотреть файл

@ -1,19 +1,22 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Document#stand_alone?" do
it "returns the XMLDecl standalone value" do
d = REXML::Document.new
decl = REXML::XMLDecl.new("1.0", "UTF-8", "yes")
d.add decl
d.stand_alone?.should == "yes"
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
# According to the docs this should return the default XMLDecl but that
# will carry some more problems when printing the document. Currently, it
# returns nil. See http://www.ruby-forum.com/topic/146812#650061
it "returns the default value when no XML declaration present" do
REXML::Document.new.stand_alone?.should == nil
end
describe "REXML::Document#stand_alone?" do
it "returns the XMLDecl standalone value" do
d = REXML::Document.new
decl = REXML::XMLDecl.new("1.0", "UTF-8", "yes")
d.add decl
d.stand_alone?.should == "yes"
end
# According to the docs this should return the default XMLDecl but that
# will carry some more problems when printing the document. Currently, it
# returns nil. See http://www.ruby-forum.com/topic/146812#650061
it "returns the default value when no XML declaration present" do
REXML::Document.new.stand_alone?.should == nil
end
end
end

21
spec/ruby/library/rexml/document/version_spec.rb
Просмотреть файл

@ -1,14 +1,17 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Document#version" do
it "returns XML version from declaration" do
d = REXML::Document.new
d.add REXML::XMLDecl.new("1.1")
d.version.should == "1.1"
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns the default version when declaration is not present" do
REXML::Document.new.version.should == REXML::XMLDecl::DEFAULT_VERSION
describe "REXML::Document#version" do
it "returns XML version from declaration" do
d = REXML::Document.new
d.add REXML::XMLDecl.new("1.1")
d.version.should == "1.1"
end
it "returns the default version when declaration is not present" do
REXML::Document.new.version.should == REXML::XMLDecl::DEFAULT_VERSION
end
end
end

57
spec/ruby/library/rexml/document/write_spec.rb
Просмотреть файл

@ -1,35 +1,38 @@
require 'rexml/document'
require 'rexml/formatters/transitive'
require_relative '../../../spec_helper'
# Maybe this can be cleaned
describe "REXML::Document#write" do
before :each do
@d = REXML::Document.new
city = REXML::Element.new "Springfield"
street = REXML::Element.new "EvergreenTerrace"
address = REXML::Element.new "House742"
@d << city << street << address
@str = ""
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
require 'rexml/formatters/transitive'
it "returns document source as string" do
@d.write(@str)
@str.should == "<Springfield><EvergreenTerrace><House742/></EvergreenTerrace></Springfield>"
end
# Maybe this can be cleaned
describe "REXML::Document#write" do
before :each do
@d = REXML::Document.new
city = REXML::Element.new "Springfield"
street = REXML::Element.new "EvergreenTerrace"
address = REXML::Element.new "House742"
@d << city << street << address
@str = ""
end
it "returns document indented" do
@d.write(@str, 2)
@str.should =~ /\s*<Springfield>\s*<EvergreenTerrace>\s*<House742\/>\s*<\/EvergreenTerrace>\s*<\/Springfield>/
end
it "returns document source as string" do
@d.write(@str)
@str.should == "<Springfield><EvergreenTerrace><House742/></EvergreenTerrace></Springfield>"
end
it "returns document with transitive support" do
@d.write(@str, 2, true)
@str.should =~ /\s*<Springfield\s*><EvergreenTerrace\s*><House742\s*\/><\/EvergreenTerrace\s*><\/Springfield\s*>/
end
it "returns document indented" do
@d.write(@str, 2)
@str.should =~ /\s*<Springfield>\s*<EvergreenTerrace>\s*<House742\/>\s*<\/EvergreenTerrace>\s*<\/Springfield>/
end
it "returns document with support for IE" do
@d.write(@str, -1, false, true)
@str.should == "<Springfield><EvergreenTerrace><House742 /></EvergreenTerrace></Springfield>"
it "returns document with transitive support" do
@d.write(@str, 2, true)
@str.should =~ /\s*<Springfield\s*><EvergreenTerrace\s*><House742\s*\/><\/EvergreenTerrace\s*><\/Springfield\s*>/
end
it "returns document with support for IE" do
@d.write(@str, -1, false, true)
@str.should == "<Springfield><EvergreenTerrace><House742 /></EvergreenTerrace></Springfield>"
end
end
end

23
spec/ruby/library/rexml/document/xml_decl_spec.rb
Просмотреть файл

@ -1,15 +1,18 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Document#xml_decl" do
it "returns XML declaration of the document" do
d = REXML::Document.new
decl = REXML::XMLDecl.new("1.0", "UTF-16", "yes")
d.add decl
d.xml_decl.should == decl
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns default XML declaration unless present" do
REXML::Document.new.xml_decl.should == REXML::XMLDecl.new
describe "REXML::Document#xml_decl" do
it "returns XML declaration of the document" do
d = REXML::Document.new
decl = REXML::XMLDecl.new("1.0", "UTF-16", "yes")
d.add decl
d.xml_decl.should == decl
end
it "returns default XML declaration unless present" do
REXML::Document.new.xml_decl.should == REXML::XMLDecl.new
end
end
end

65
spec/ruby/library/rexml/element/add_attribute_spec.rb
Просмотреть файл

@ -1,41 +1,44 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#add_attribute" do
before :each do
@person = REXML::Element.new "person"
@person.attributes["name"] = "Bill"
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "adds a new attribute" do
@person.add_attribute("age", "17")
@person.attributes["age"].should == "17"
end
describe "REXML::Element#add_attribute" do
before :each do
@person = REXML::Element.new "person"
@person.attributes["name"] = "Bill"
end
it "overwrites an existing attribute" do
@person.add_attribute("name", "Bill")
@person.attributes["name"].should == "Bill"
end
it "adds a new attribute" do
@person.add_attribute("age", "17")
@person.attributes["age"].should == "17"
end
it "accepts a pair of strings" do
@person.add_attribute("male", "true")
@person.attributes["male"].should == "true"
end
it "overwrites an existing attribute" do
@person.add_attribute("name", "Bill")
@person.attributes["name"].should == "Bill"
end
it "accepts an Attribute for key" do
attr = REXML::Attribute.new("male", "true")
@person.add_attribute attr
@person.attributes["male"].should == "true"
end
it "accepts a pair of strings" do
@person.add_attribute("male", "true")
@person.attributes["male"].should == "true"
end
it "ignores value if key is an Attribute" do
attr = REXML::Attribute.new("male", "true")
@person.add_attribute(attr, "false")
@person.attributes["male"].should == "true"
end
it "accepts an Attribute for key" do
attr = REXML::Attribute.new("male", "true")
@person.add_attribute attr
@person.attributes["male"].should == "true"
end
it "returns the attribute added" do
attr = REXML::Attribute.new("name", "Tony")
@person.add_attribute(attr).should == attr
it "ignores value if key is an Attribute" do
attr = REXML::Attribute.new("male", "true")
@person.add_attribute(attr, "false")
@person.attributes["male"].should == "true"
end
it "returns the attribute added" do
attr = REXML::Attribute.new("name", "Tony")
@person.add_attribute(attr).should == attr
end
end
end

35
spec/ruby/library/rexml/element/add_attributes_spec.rb
Просмотреть файл

@ -1,22 +1,25 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#add_attributes" do
before :each do
@person = REXML::Element.new "person"
@person.attributes["name"] = "Bill"
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "adds multiple attributes from a hash" do
@person.add_attributes({"name" => "Joe", "age" => "27"})
@person.attributes["name"].should == "Joe"
@person.attributes["age"].should == "27"
end
describe "REXML::Element#add_attributes" do
before :each do
@person = REXML::Element.new "person"
@person.attributes["name"] = "Bill"
end
it "adds multiple attributes from an array" do
attrs = { "name" => "Joe", "age" => "27"}
@person.add_attributes attrs.to_a
@person.attributes["name"].should == "Joe"
@person.attributes["age"].should == "27"
it "adds multiple attributes from a hash" do
@person.add_attributes({"name" => "Joe", "age" => "27"})
@person.attributes["name"].should == "Joe"
@person.attributes["age"].should == "27"
end
it "adds multiple attributes from an array" do
attrs = { "name" => "Joe", "age" => "27"}
@person.add_attributes attrs.to_a
@person.attributes["name"].should == "Joe"
@person.attributes["age"].should == "27"
end
end
end

62
spec/ruby/library/rexml/element/add_element_spec.rb
Просмотреть файл

@ -1,39 +1,41 @@
require 'rexml/document'
require_relative '../../../spec_helper'
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Element#add_element" do
before :each do
@root = REXML::Element.new("root")
end
describe "REXML::Element#add_element" do
before :each do
@root = REXML::Element.new("root")
end
it "adds a child without attributes" do
name = REXML::Element.new("name")
@root.add_element name
@root.elements["name"].name.should == name.name
@root.elements["name"].attributes.should == name.attributes
@root.elements["name"].context.should == name.context
end
it "adds a child without attributes" do
name = REXML::Element.new("name")
@root.add_element name
@root.elements["name"].name.should == name.name
@root.elements["name"].attributes.should == name.attributes
@root.elements["name"].context.should == name.context
end
it "adds a child with attributes" do
person = REXML::Element.new("person")
@root.add_element(person, {"name" => "Madonna"})
@root.elements["person"].name.should == person.name
@root.elements["person"].attributes.should == person.attributes
@root.elements["person"].context.should == person.context
end
it "adds a child with attributes" do
person = REXML::Element.new("person")
@root.add_element(person, {"name" => "Madonna"})
@root.elements["person"].name.should == person.name
@root.elements["person"].attributes.should == person.attributes
@root.elements["person"].context.should == person.context
end
it "adds a child with name" do
@root.add_element "name"
@root.elements["name"].name.should == "name"
@root.elements["name"].attributes.should == {}
@root.elements["name"].context.should == nil
end
it "adds a child with name" do
@root.add_element "name"
@root.elements["name"].name.should == "name"
@root.elements["name"].attributes.should == {}
@root.elements["name"].context.should == nil
end
it "returns the added child" do
name = @root.add_element "name"
@root.elements["name"].name.should == name.name
@root.elements["name"].attributes.should == name.attributes
@root.elements["name"].context.should == name.context
it "returns the added child" do
name = @root.add_element "name"
@root.elements["name"].name.should == name.name
@root.elements["name"].attributes.should == name.attributes
@root.elements["name"].context.should == name.context
end
end
end

35
spec/ruby/library/rexml/element/add_namespace_spec.rb
Просмотреть файл

@ -1,23 +1,26 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#add_namespace" do
before :each do
@elem = REXML::Element.new("person")
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "adds a namespace to element" do
@elem.add_namespace("foo", "bar")
@elem.namespace("foo").should == "bar"
end
describe "REXML::Element#add_namespace" do
before :each do
@elem = REXML::Element.new("person")
end
it "accepts a prefix string as prefix" do
@elem.add_namespace("xmlns:foo", "bar")
@elem.namespace("foo").should == "bar"
end
it "adds a namespace to element" do
@elem.add_namespace("foo", "bar")
@elem.namespace("foo").should == "bar"
end
it "uses prefix as URI if uri is nil" do
@elem.add_namespace("some_uri", nil)
@elem.namespace.should == "some_uri"
it "accepts a prefix string as prefix" do
@elem.add_namespace("xmlns:foo", "bar")
@elem.namespace("foo").should == "bar"
end
it "uses prefix as URI if uri is nil" do
@elem.add_namespace("some_uri", nil)
@elem.namespace.should == "some_uri"
end
end
end

37
spec/ruby/library/rexml/element/add_text_spec.rb
Просмотреть файл

@ -1,24 +1,27 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#add_text" do
before :each do
@name = REXML::Element.new "Name"
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "adds text to an element" do
@name.add_text "Ringo"
@name.to_s.should == "<Name>Ringo</Name>"
end
describe "REXML::Element#add_text" do
before :each do
@name = REXML::Element.new "Name"
end
it "accepts a Text" do
@name.add_text(REXML::Text.new("Ringo"))
@name.to_s.should == "<Name>Ringo</Name>"
end
it "adds text to an element" do
@name.add_text "Ringo"
@name.to_s.should == "<Name>Ringo</Name>"
end
it "joins the new text with the old one" do
@name.add_text "Ringo"
@name.add_text " Starr"
@name.to_s.should == "<Name>Ringo Starr</Name>"
it "accepts a Text" do
@name.add_text(REXML::Text.new("Ringo"))
@name.to_s.should == "<Name>Ringo</Name>"
end
it "joins the new text with the old one" do
@name.add_text "Ringo"
@name.add_text " Starr"
@name.to_s.should == "<Name>Ringo Starr</Name>"
end
end
end

27
spec/ruby/library/rexml/element/attribute_spec.rb
Просмотреть файл

@ -1,17 +1,20 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#attribute" do
it "returns an attribute by name" do
person = REXML::Element.new "Person"
attribute = REXML::Attribute.new("drink", "coffee")
person.add_attribute(attribute)
person.attribute("drink").should == attribute
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "supports attributes inside namespaces" do
e = REXML::Element.new("element")
e.add_attributes({"xmlns:ns" => "http://some_uri"})
e.attribute("ns", "ns").to_s.should == "http://some_uri"
describe "REXML::Element#attribute" do
it "returns an attribute by name" do
person = REXML::Element.new "Person"
attribute = REXML::Attribute.new("drink", "coffee")
person.add_attribute(attribute)
person.attribute("drink").should == attribute
end
it "supports attributes inside namespaces" do
e = REXML::Element.new("element")
e.add_attributes({"xmlns:ns" => "http://some_uri"})
e.attribute("ns", "ns").to_s.should == "http://some_uri"
end
end
end

27
spec/ruby/library/rexml/element/attributes_spec.rb
Просмотреть файл

@ -1,19 +1,22 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#attributes" do
it "returns element's Attributes" do
p = REXML::Element.new "Person"
ruby_version_is ''...'2.8' do
require 'rexml/document'
name = REXML::Attribute.new("name", "John")
attrs = REXML::Attributes.new(p)
attrs.add name
describe "REXML::Element#attributes" do
it "returns element's Attributes" do
p = REXML::Element.new "Person"
p.add_attribute name
p.attributes.should == attrs
end
name = REXML::Attribute.new("name", "John")
attrs = REXML::Attributes.new(p)
attrs.add name
it "returns an empty hash if element has no attributes" do
REXML::Element.new("Person").attributes.should == {}
p.add_attribute name
p.attributes.should == attrs
end
it "returns an empty hash if element has no attributes" do
REXML::Element.new("Person").attributes.should == {}
end
end
end

37
spec/ruby/library/rexml/element/cdatas_spec.rb
Просмотреть файл

@ -1,24 +1,27 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#cdatas" do
before :each do
@e = REXML::Element.new("Root")
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns the array of children cdatas" do
c = REXML::CData.new("Primary")
d = REXML::CData.new("Secondary")
@e << c
@e << d
@e.cdatas.should == [c, d]
end
describe "REXML::Element#cdatas" do
before :each do
@e = REXML::Element.new("Root")
end
it "freezes the returned array" do
@e.cdatas.frozen?.should == true
end
it "returns the array of children cdatas" do
c = REXML::CData.new("Primary")
d = REXML::CData.new("Secondary")
@e << c
@e << d
@e.cdatas.should == [c, d]
end
it "returns an empty array if element has no cdata" do
@e.cdatas.should == []
it "freezes the returned array" do
@e.cdatas.frozen?.should == true
end
it "returns an empty array if element has no cdata" do
@e.cdatas.should == []
end
end
end

47
spec/ruby/library/rexml/element/clone_spec.rb
Просмотреть файл

@ -1,29 +1,32 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#clone" do
before :each do
@e = REXML::Element.new "a"
end
it "creates a copy of element" do
@e.clone.to_s.should == @e.to_s
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "copies the attributes" do
@e.add_attribute("foo", "bar")
@e.clone.to_s.should == @e.to_s
end
describe "REXML::Element#clone" do
before :each do
@e = REXML::Element.new "a"
end
it "creates a copy of element" do
@e.clone.to_s.should == @e.to_s
end
it "does not copy the text" do
@e.add_text "some text..."
@e.clone.to_s.should_not == @e
@e.clone.to_s.should == "<a/>"
end
it "copies the attributes" do
@e.add_attribute("foo", "bar")
@e.clone.to_s.should == @e.to_s
end
it "does not copy the child elements" do
b = REXML::Element.new "b"
@e << b
@e.clone.should_not == @e
@e.clone.to_s.should == "<a/>"
it "does not copy the text" do
@e.add_text "some text..."
@e.clone.to_s.should_not == @e
@e.clone.to_s.should == "<a/>"
end
it "does not copy the child elements" do
b = REXML::Element.new "b"
@e << b
@e.clone.should_not == @e
@e.clone.to_s.should == "<a/>"
end
end
end

31
spec/ruby/library/rexml/element/comments_spec.rb
Просмотреть файл

@ -1,20 +1,23 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#comments" do
before :each do
@e = REXML::Element.new "root"
@c1 = REXML::Comment.new "this is a comment"
@c2 = REXML::Comment.new "this is another comment"
@e << @c1
@e << @c2
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns the array of comments" do
@e.comments.should == [@c1, @c2]
end
describe "REXML::Element#comments" do
before :each do
@e = REXML::Element.new "root"
@c1 = REXML::Comment.new "this is a comment"
@c2 = REXML::Comment.new "this is another comment"
@e << @c1
@e << @c2
end
it "returns a frozen object" do
@e.comments.frozen?.should == true
it "returns the array of comments" do
@e.comments.should == [@c1, @c2]
end
it "returns a frozen object" do
@e.comments.frozen?.should == true
end
end
end

62
spec/ruby/library/rexml/element/delete_attribute_spec.rb
Просмотреть файл

@ -1,39 +1,43 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#delete_attribute" do
before :each do
@e = REXML::Element.new("Person")
@attr = REXML::Attribute.new("name", "Sean")
@e.add_attribute(@attr)
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "deletes an attribute from the element" do
@e.delete_attribute("name")
@e.attributes["name"].should be_nil
end
# Bug was filled with a patch in Ruby's tracker #20298
quarantine! do
it "receives an Attribute" do
describe "REXML::Element#delete_attribute" do
before :each do
@e = REXML::Element.new("Person")
@attr = REXML::Attribute.new("name", "Sean")
@e.add_attribute(@attr)
@e.delete_attribute(@attr)
end
it "deletes an attribute from the element" do
@e.delete_attribute("name")
@e.attributes["name"].should be_nil
end
end
# Docs say that it returns the removed attribute but then examples
# show it returns the element with the attribute removed.
# Also fixed in #20298
it "returns the element with the attribute removed" do
elem = @e.delete_attribute("name")
elem.attributes.should be_empty
elem.to_s.should eql("<Person/>")
end
# Bug was filled with a patch in Ruby's tracker #20298
quarantine! do
it "receives an Attribute" do
@e.add_attribute(@attr)
@e.delete_attribute(@attr)
@e.attributes["name"].should be_nil
end
end
it "returns nil if the attribute does not exist" do
@e.delete_attribute("name")
at = @e.delete_attribute("name")
at.should be_nil
# Docs say that it returns the removed attribute but then examples
# show it returns the element with the attribute removed.
# Also fixed in #20298
it "returns the element with the attribute removed" do
elem = @e.delete_attribute("name")
elem.attributes.should be_empty
elem.to_s.should eql("<Person/>")
end
it "returns nil if the attribute does not exist" do
@e.delete_attribute("name")
at = @e.delete_attribute("name")
at.should be_nil
end
end
end

81
spec/ruby/library/rexml/element/delete_element_spec.rb
Просмотреть файл

@ -1,49 +1,52 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#delete_element" do
before :each do
@root = REXML::Element.new("root")
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "deletes the child element" do
node = REXML::Element.new("some_node")
@root.add_element node
@root.delete_element node
@root.elements.size.should == 0
end
describe "REXML::Element#delete_element" do
before :each do
@root = REXML::Element.new("root")
end
it "deletes a child via XPath" do
@root.add_element "some_node"
@root.delete_element "some_node"
@root.elements.size.should == 0
end
it "deletes the child element" do
node = REXML::Element.new("some_node")
@root.add_element node
@root.delete_element node
@root.elements.size.should == 0
end
it "deletes the child at index" do
@root.add_element "some_node"
@root.delete_element 1
@root.elements.size.should == 0
end
it "deletes a child via XPath" do
@root.add_element "some_node"
@root.delete_element "some_node"
@root.elements.size.should == 0
end
# According to the docs this should return the deleted element
# but it won't if it's an Element.
it "deletes Element and returns it" do
node = REXML::Element.new("some_node")
@root.add_element node
del_node = @root.delete_element node
del_node.should == node
end
it "deletes the child at index" do
@root.add_element "some_node"
@root.delete_element 1
@root.elements.size.should == 0
end
# Note how passing the string will return the removed element
# but passing the Element as above won't.
it "deletes an element and returns it" do
node = REXML::Element.new("some_node")
@root.add_element node
del_node = @root.delete_element "some_node"
del_node.should == node
end
# According to the docs this should return the deleted element
# but it won't if it's an Element.
it "deletes Element and returns it" do
node = REXML::Element.new("some_node")
@root.add_element node
del_node = @root.delete_element node
del_node.should == node
end
it "returns nil unless element exists" do
@root.delete_element("something").should == nil
# Note how passing the string will return the removed element
# but passing the Element as above won't.
it "deletes an element and returns it" do
node = REXML::Element.new("some_node")
@root.add_element node
del_node = @root.delete_element "some_node"
del_node.should == node
end
it "returns nil unless element exists" do
@root.delete_element("something").should == nil
end
end
end

37
spec/ruby/library/rexml/element/delete_namespace_spec.rb
Просмотреть файл

@ -1,25 +1,28 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#delete_namespace" do
ruby_version_is ''...'2.8' do
require 'rexml/document'
before :each do
@doc = REXML::Document.new "<a xmlns:foo='bar' xmlns='twiddle'/>"
end
describe "REXML::Element#delete_namespace" do
it "deletes a namespace from the element" do
@doc.root.delete_namespace 'foo'
@doc.root.namespace("foo").should be_nil
@doc.root.to_s.should == "<a xmlns='twiddle'/>"
end
before :each do
@doc = REXML::Document.new "<a xmlns:foo='bar' xmlns='twiddle'/>"
end
it "deletes default namespace when called with no args" do
@doc.root.delete_namespace
@doc.root.namespace.should be_empty
@doc.root.to_s.should == "<a xmlns:foo='bar'/>"
end
it "deletes a namespace from the element" do
@doc.root.delete_namespace 'foo'
@doc.root.namespace("foo").should be_nil
@doc.root.to_s.should == "<a xmlns='twiddle'/>"
end
it "returns the element" do
@doc.root.delete_namespace.should == @doc.root
it "deletes default namespace when called with no args" do
@doc.root.delete_namespace
@doc.root.namespace.should be_empty
@doc.root.to_s.should == "<a xmlns:foo='bar'/>"
end
it "returns the element" do
@doc.root.delete_namespace.should == @doc.root
end
end
end

23
spec/ruby/library/rexml/element/document_spec.rb
Просмотреть файл

@ -1,16 +1,19 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#document" do
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns the element's document" do
d = REXML::Document.new("<root><elem/></root>")
d << REXML::XMLDecl.new
d.root.document.should == d
d.root.document.to_s.should == d.to_s
end
describe "REXML::Element#document" do
it "returns nil if it belongs to no document" do
REXML::Element.new("standalone").document.should be_nil
it "returns the element's document" do
d = REXML::Document.new("<root><elem/></root>")
d << REXML::XMLDecl.new
d.root.document.should == d
d.root.document.to_s.should == d.to_s
end
it "returns nil if it belongs to no document" do
REXML::Element.new("standalone").document.should be_nil
end
end
end

57
spec/ruby/library/rexml/element/each_element_with_attribute_spec.rb
Просмотреть файл

@ -1,35 +1,38 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#each_element_with_attributes" do
before :each do
@document = REXML::Element.new("people")
@father = REXML::Element.new("Person")
@father.attributes["name"] = "Joe"
@son = REXML::Element.new("Child")
@son.attributes["name"] = "Fred"
@document.root << @father
@document.root << @son
@childs = []
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns childs with attribute" do
@document.each_element_with_attribute("name") { |elem| @childs << elem }
@childs[0].should == @father
@childs[1].should == @son
end
describe "REXML::Element#each_element_with_attributes" do
before :each do
@document = REXML::Element.new("people")
@father = REXML::Element.new("Person")
@father.attributes["name"] = "Joe"
@son = REXML::Element.new("Child")
@son.attributes["name"] = "Fred"
@document.root << @father
@document.root << @son
@childs = []
end
it "takes attribute value as second argument" do
@document.each_element_with_attribute("name", "Fred"){ |elem| elem.should == @son }
end
it "returns childs with attribute" do
@document.each_element_with_attribute("name") { |elem| @childs << elem }
@childs[0].should == @father
@childs[1].should == @son
end
it "takes max number of childs as third argument" do
@document.each_element_with_attribute("name", nil, 1) { |elem| @childs << elem }
@childs.size.should == 1
@childs[0].should == @father
end
it "takes attribute value as second argument" do
@document.each_element_with_attribute("name", "Fred"){ |elem| elem.should == @son }
end
it "takes XPath filter as fourth argument" do
@document.each_element_with_attribute("name", nil, 0, "Child"){ |elem| elem.should == @son}
it "takes max number of childs as third argument" do
@document.each_element_with_attribute("name", nil, 1) { |elem| @childs << elem }
@childs.size.should == 1
@childs[0].should == @father
end
it "takes XPath filter as fourth argument" do
@document.each_element_with_attribute("name", nil, 0, "Child"){ |elem| elem.should == @son}
end
end
end

49
spec/ruby/library/rexml/element/each_element_with_text_spec.rb
Просмотреть файл

@ -1,31 +1,34 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#each_element_with_text" do
before :each do
@document = REXML::Element.new("people")
ruby_version_is ''...'2.8' do
require 'rexml/document'
@joe = REXML::Element.new("Person")
@joe.text = "Joe"
@fred = REXML::Element.new("Person")
@fred.text = "Fred"
@another = REXML::Element.new("AnotherPerson")
@another.text = "Fred"
@document.root << @joe
@document.root << @fred
@document.root << @another
@childs = []
end
describe "REXML::Element#each_element_with_text" do
before :each do
@document = REXML::Element.new("people")
it "returns childs with text" do
@document.each_element_with_text("Joe"){|c| c.should == @joe}
end
@joe = REXML::Element.new("Person")
@joe.text = "Joe"
@fred = REXML::Element.new("Person")
@fred.text = "Fred"
@another = REXML::Element.new("AnotherPerson")
@another.text = "Fred"
@document.root << @joe
@document.root << @fred
@document.root << @another
@childs = []
end
it "takes max as second argument" do
@document.each_element_with_text("Fred", 1){ |c| c.should == @fred}
end
it "returns childs with text" do
@document.each_element_with_text("Joe"){|c| c.should == @joe}
end
it "takes XPath filter as third argument" do
@document.each_element_with_text("Fred", 0, "Person"){ |c| c.should == @fred}
it "takes max as second argument" do
@document.each_element_with_text("Fred", 1){ |c| c.should == @fred}
end
it "takes XPath filter as third argument" do
@document.each_element_with_text("Fred", 0, "Person"){ |c| c.should == @fred}
end
end
end

29
spec/ruby/library/rexml/element/element_reference_spec.rb
Просмотреть файл

@ -1,20 +1,23 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#[]" do
ruby_version_is ''...'2.8' do
require 'rexml/document'
before :each do
@doc = REXML::Document.new("<root foo='bar'></root>")
@child = REXML::Element.new("child")
@doc.root.add_element @child
end
describe "REXML::Element#[]" do
it "return attribute value if argument is string or symbol" do
@doc.root[:foo].should == 'bar'
@doc.root['foo'].should == 'bar'
end
before :each do
@doc = REXML::Document.new("<root foo='bar'></root>")
@child = REXML::Element.new("child")
@doc.root.add_element @child
end
it "return nth element if argument is int" do
@doc.root[0].should == @child
it "return attribute value if argument is string or symbol" do
@doc.root[:foo].should == 'bar'
@doc.root['foo'].should == 'bar'
end
it "return nth element if argument is int" do
@doc.root[0].should == @child
end
end
end

27
spec/ruby/library/rexml/element/get_text_spec.rb
Просмотреть файл

@ -1,18 +1,21 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#get_text" do
before :each do
@doc = REXML::Document.new "<p>some text<b>this is bold!</b> more text</p>"
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns the first text child node" do
@doc.root.get_text.value.should == "some text"
@doc.root.get_text.should be_kind_of(REXML::Text)
end
describe "REXML::Element#get_text" do
before :each do
@doc = REXML::Document.new "<p>some text<b>this is bold!</b> more text</p>"
end
it "returns text from an element matching path" do
@doc.root.get_text("b").value.should == "this is bold!"
@doc.root.get_text("b").should be_kind_of(REXML::Text)
it "returns the first text child node" do
@doc.root.get_text.value.should == "some text"
@doc.root.get_text.should be_kind_of(REXML::Text)
end
it "returns text from an element matching path" do
@doc.root.get_text("b").value.should == "this is bold!"
@doc.root.get_text("b").should be_kind_of(REXML::Text)
end
end
end

25
spec/ruby/library/rexml/element/has_attributes_spec.rb
Просмотреть файл

@ -1,17 +1,20 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#has_attributes?" do
before :each do
@e = REXML::Element.new("test_elem")
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns true when element has any attributes" do
@e.add_attribute("name", "Joe")
@e.has_attributes?.should be_true
end
describe "REXML::Element#has_attributes?" do
before :each do
@e = REXML::Element.new("test_elem")
end
it "returns false if element has no attributes" do
@e.has_attributes?.should be_false
it "returns true when element has any attributes" do
@e.add_attribute("name", "Joe")
@e.has_attributes?.should be_true
end
it "returns false if element has no attributes" do
@e.has_attributes?.should be_false
end
end
end

27
spec/ruby/library/rexml/element/has_elements_spec.rb
Просмотреть файл

@ -1,18 +1,21 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#has_elements?" do
before :each do
@e = REXML::Element.new("root")
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns true if element has child elements" do
child = REXML::Element.new("child")
@e << child
@e.has_elements?.should be_true
end
describe "REXML::Element#has_elements?" do
before :each do
@e = REXML::Element.new("root")
end
it "returns false if element doesn't have child elements" do
@e.has_elements?.should be_false
it "returns true if element has child elements" do
child = REXML::Element.new("child")
@e << child
@e.has_elements?.should be_true
end
it "returns false if element doesn't have child elements" do
@e.has_elements?.should be_false
end
end
end

23
spec/ruby/library/rexml/element/has_text_spec.rb
Просмотреть файл

@ -1,16 +1,19 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#has_text?" do
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns true if element has a Text child" do
e = REXML::Element.new("Person")
e.text = "My text"
e.has_text?.should be_true
end
describe "REXML::Element#has_text?" do
it "returns false if it has no Text childs" do
e = REXML::Element.new("Person")
e.has_text?.should be_false
it "returns true if element has a Text child" do
e = REXML::Element.new("Person")
e.text = "My text"
e.has_text?.should be_true
end
it "returns false if it has no Text childs" do
e = REXML::Element.new("Person")
e.has_text?.should be_false
end
end
end

41
spec/ruby/library/rexml/element/inspect_spec.rb
Просмотреть файл

@ -1,27 +1,30 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#inspect" do
ruby_version_is ''...'2.8' do
require 'rexml/document'
before :each do
@name = REXML::Element.new "name"
end
describe "REXML::Element#inspect" do
it "returns the node as a string" do
@name.inspect.should == "<name/>"
end
before :each do
@name = REXML::Element.new "name"
end
it "inserts '...' if the node has children" do
e = REXML::Element.new "last_name"
@name << e
@name.inspect.should == "<name> ... </>"
# This might make more sense but differs from MRI's default behavior
# @name.inspect.should == "<name> ... </name>"
end
it "returns the node as a string" do
@name.inspect.should == "<name/>"
end
it "inserts the attributes in the string" do
@name.add_attribute "language"
@name.attributes["language"] = "english"
@name.inspect.should == "<name language='english'/>"
it "inserts '...' if the node has children" do
e = REXML::Element.new "last_name"
@name << e
@name.inspect.should == "<name> ... </>"
# This might make more sense but differs from MRI's default behavior
# @name.inspect.should == "<name> ... </name>"
end
it "inserts the attributes in the string" do
@name.add_attribute "language"
@name.attributes["language"] = "english"
@name.inspect.should == "<name language='english'/>"
end
end
end

33
spec/ruby/library/rexml/element/instructions_spec.rb
Просмотреть файл

@ -1,21 +1,24 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#instructions" do
before :each do
@elem = REXML::Element.new("root")
end
it "returns the Instruction children nodes" do
inst = REXML::Instruction.new("xml-stylesheet", "href='headlines.css'")
@elem << inst
@elem.instructions.first.should == inst
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns an empty array if it has no Instruction children" do
@elem.instructions.should be_empty
end
describe "REXML::Element#instructions" do
before :each do
@elem = REXML::Element.new("root")
end
it "returns the Instruction children nodes" do
inst = REXML::Instruction.new("xml-stylesheet", "href='headlines.css'")
@elem << inst
@elem.instructions.first.should == inst
end
it "freezes the returned array" do
@elem.instructions.frozen?.should be_true
it "returns an empty array if it has no Instruction children" do
@elem.instructions.should be_empty
end
it "freezes the returned array" do
@elem.instructions.frozen?.should be_true
end
end
end

41
spec/ruby/library/rexml/element/namespace_spec.rb
Просмотреть файл

@ -1,27 +1,30 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#namespace" do
before :each do
@doc = REXML::Document.new("<a xmlns='1' xmlns:y='2'><b/><c xmlns:z='3'/></a>")
@elem = @doc.elements["//b"]
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns the default namespace" do
@elem.namespace.should == "1"
end
describe "REXML::Element#namespace" do
before :each do
@doc = REXML::Document.new("<a xmlns='1' xmlns:y='2'><b/><c xmlns:z='3'/></a>")
@elem = @doc.elements["//b"]
end
it "accepts a namespace prefix" do
@elem.namespace("y").should == "2"
@doc.elements["//c"].namespace("z").should == "3"
end
it "returns the default namespace" do
@elem.namespace.should == "1"
end
it "returns an empty String if default namespace is not defined" do
e = REXML::Document.new("<a/>")
e.root.namespace.should be_empty
end
it "accepts a namespace prefix" do
@elem.namespace("y").should == "2"
@doc.elements["//c"].namespace("z").should == "3"
end
it "returns nil if namespace is not defined" do
@elem.namespace("z").should be_nil
it "returns an empty String if default namespace is not defined" do
e = REXML::Document.new("<a/>")
e.root.namespace.should be_empty
end
it "returns nil if namespace is not defined" do
@elem.namespace("z").should be_nil
end
end
end

51
spec/ruby/library/rexml/element/namespaces_spec.rb
Просмотреть файл

@ -1,32 +1,35 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#namespaces" do
before :each do
doc = REXML::Document.new("<a xmlns='1' xmlns:y='2'><b/><c xmlns:z='3'/></a>")
@elem = doc.elements["//c"]
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns a hash of the namespaces" do
ns = {"y"=>"2", "z"=>"3", "xmlns"=>"1"}
@elem.namespaces.keys.sort.should == ns.keys.sort
@elem.namespaces.values.sort.should == ns.values.sort
end
describe "REXML::Element#namespaces" do
before :each do
doc = REXML::Document.new("<a xmlns='1' xmlns:y='2'><b/><c xmlns:z='3'/></a>")
@elem = doc.elements["//c"]
end
it "returns an empty hash if no namespaces exist" do
e = REXML::Element.new "element"
e.namespaces.kind_of?(Hash).should == true
e.namespaces.should be_empty
end
it "returns a hash of the namespaces" do
ns = {"y"=>"2", "z"=>"3", "xmlns"=>"1"}
@elem.namespaces.keys.sort.should == ns.keys.sort
@elem.namespaces.values.sort.should == ns.values.sort
end
it "uses namespace prefixes as keys" do
prefixes = ["y", "z", "xmlns"]
@elem.namespaces.keys.sort.should == prefixes.sort
end
it "returns an empty hash if no namespaces exist" do
e = REXML::Element.new "element"
e.namespaces.kind_of?(Hash).should == true
e.namespaces.should be_empty
end
it "uses namespace values as the hash values" do
values = ["2", "3", "1"]
@elem.namespaces.values.sort.should == values.sort
end
it "uses namespace prefixes as keys" do
prefixes = ["y", "z", "xmlns"]
@elem.namespaces.keys.sort.should == prefixes.sort
end
it "uses namespace values as the hash values" do
values = ["2", "3", "1"]
@elem.namespaces.values.sort.should == values.sort
end
end
end

55
spec/ruby/library/rexml/element/new_spec.rb
Просмотреть файл

@ -1,35 +1,38 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#new" do
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "creates element from tag name" do
REXML::Element.new("foo").name.should == "foo"
end
describe "REXML::Element#new" do
it "creates element with default attributes" do
e = REXML::Element.new
e.name.should == REXML::Element::UNDEFINED
e.context.should == nil
e.parent.should == nil
end
it "creates element from tag name" do
REXML::Element.new("foo").name.should == "foo"
end
it "creates element from another element" do
e = REXML::Element.new "foo"
f = REXML::Element.new e
e.name.should == f.name
e.context.should == f.context
e.parent.should == f.parent
end
it "creates element with default attributes" do
e = REXML::Element.new
e.name.should == REXML::Element::UNDEFINED
e.context.should == nil
e.parent.should == nil
end
it "takes parent as second argument" do
parent = REXML::Element.new "foo"
child = REXML::Element.new "bar", parent
child.parent.should == parent
end
it "creates element from another element" do
e = REXML::Element.new "foo"
f = REXML::Element.new e
e.name.should == f.name
e.context.should == f.context
e.parent.should == f.parent
end
it "takes context as third argument" do
context = {"some_key" => "some_value"}
REXML::Element.new("foo", nil, context).context.should == context
it "takes parent as second argument" do
parent = REXML::Element.new "foo"
child = REXML::Element.new "bar", parent
child.parent.should == parent
end
it "takes context as third argument" do
context = {"some_key" => "some_value"}
REXML::Element.new("foo", nil, context).context.should == context
end
end
end

31
spec/ruby/library/rexml/element/next_element_spec.rb
Просмотреть файл

@ -1,19 +1,22 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#next_element" do
before :each do
@a = REXML::Element.new "a"
@b = REXML::Element.new "b"
@c = REXML::Element.new "c"
@a.root << @b
@a.root << @c
end
it "returns next existing element" do
@a.elements["b"].next_element.should == @c
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns nil on last element" do
@a.elements["c"].next_element.should == nil
describe "REXML::Element#next_element" do
before :each do
@a = REXML::Element.new "a"
@b = REXML::Element.new "b"
@c = REXML::Element.new "c"
@a.root << @b
@a.root << @c
end
it "returns next existing element" do
@a.elements["b"].next_element.should == @c
end
it "returns nil on last element" do
@a.elements["c"].next_element.should == nil
end
end
end

11
spec/ruby/library/rexml/element/node_type_spec.rb
Просмотреть файл

@ -1,8 +1,11 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#node_type" do
it "returns :element" do
REXML::Element.new("MyElem").node_type.should == :element
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Element#node_type" do
it "returns :element" do
REXML::Element.new("MyElem").node_type.should == :element
end
end
end

35
spec/ruby/library/rexml/element/prefixes_spec.rb
Просмотреть файл

@ -1,23 +1,26 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#prefixes" do
before :each do
doc = REXML::Document.new("<a xmlns='1' xmlns:y='2'><b/><c xmlns:z='3'/></a>")
@elem = doc.elements["//c"]
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns an array of the prefixes of the namespaces" do
@elem.prefixes.should == ["y", "z"]
end
describe "REXML::Element#prefixes" do
before :each do
doc = REXML::Document.new("<a xmlns='1' xmlns:y='2'><b/><c xmlns:z='3'/></a>")
@elem = doc.elements["//c"]
end
it "does not include the default namespace" do
@elem.prefixes.include?("xmlns").should == false
end
it "returns an array of the prefixes of the namespaces" do
@elem.prefixes.should == ["y", "z"]
end
it "returns an empty array if no namespace was defined" do
doc = REXML::Document.new "<root><something/></root>"
root = doc.elements["//root"]
root.prefixes.should == []
it "does not include the default namespace" do
@elem.prefixes.include?("xmlns").should == false
end
it "returns an empty array if no namespace was defined" do
doc = REXML::Document.new "<root><something/></root>"
root = doc.elements["//root"]
root.prefixes.should == []
end
end
end

31
spec/ruby/library/rexml/element/previous_element_spec.rb
Просмотреть файл

@ -1,20 +1,23 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#previous_element" do
before :each do
@a = REXML::Element.new "a"
@b = REXML::Element.new "b"
@c = REXML::Element.new "c"
@a.root << @b
@a.root << @c
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns previous element" do
@a.elements["c"].previous_element.should == @b
end
describe "REXML::Element#previous_element" do
before :each do
@a = REXML::Element.new "a"
@b = REXML::Element.new "b"
@c = REXML::Element.new "c"
@a.root << @b
@a.root << @c
end
it "returns nil on first element" do
@a.elements["b"].previous_element.should == nil
it "returns previous element" do
@a.elements["c"].previous_element.should == @b
end
it "returns nil on first element" do
@a.elements["b"].previous_element.should == nil
end
end
end

35
spec/ruby/library/rexml/element/raw_spec.rb
Просмотреть файл

@ -1,24 +1,27 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#raw" do
it "returns true if raw mode is set to all" do
REXML::Element.new("MyElem", nil, {raw: :all}).raw.should == true
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns true if raw mode is set to expanded_name" do
REXML::Element.new("MyElem", nil, {raw: "MyElem"}).raw.should == true
end
describe "REXML::Element#raw" do
it "returns true if raw mode is set to all" do
REXML::Element.new("MyElem", nil, {raw: :all}).raw.should == true
end
it "returns false if raw mode is not set" do
REXML::Element.new("MyElem", nil, {raw: ""}).raw.should == false
end
it "returns true if raw mode is set to expanded_name" do
REXML::Element.new("MyElem", nil, {raw: "MyElem"}).raw.should == true
end
it "returns false if raw is not :all or expanded_name" do
REXML::Element.new("MyElem", nil, {raw: "Something"}).raw.should == false
end
it "returns false if raw mode is not set" do
REXML::Element.new("MyElem", nil, {raw: ""}).raw.should == false
end
it "returns nil if context is not set" do
REXML::Element.new("MyElem").raw.should == nil
it "returns false if raw is not :all or expanded_name" do
REXML::Element.new("MyElem", nil, {raw: "Something"}).raw.should == false
end
it "returns nil if context is not set" do
REXML::Element.new("MyElem").raw.should == nil
end
end
end

43
spec/ruby/library/rexml/element/root_spec.rb
Просмотреть файл

@ -1,28 +1,31 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Element#root" do
before :each do
@doc = REXML::Document.new
@root = REXML::Element.new "root"
@node = REXML::Element.new "node"
@doc << @root << @node
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns first child on documents" do
@doc.root.should == @root
end
describe "REXML::Element#root" do
before :each do
@doc = REXML::Document.new
@root = REXML::Element.new "root"
@node = REXML::Element.new "node"
@doc << @root << @node
end
it "returns self on root nodes" do
@root.root.should == @root
end
it "returns first child on documents" do
@doc.root.should == @root
end
it "returns parent's root on child nodes" do
@node.root.should == @root
end
it "returns self on root nodes" do
@root.root.should == @root
end
it "returns self on standalone nodes" do
e = REXML::Element.new "Elem" # Note that it doesn't have a parent node
e.root.should == e
it "returns parent's root on child nodes" do
@node.root.should == @root
end
it "returns self on standalone nodes" do
e = REXML::Element.new "Elem" # Note that it doesn't have a parent node
e.root.should == e
end
end
end

79
spec/ruby/library/rexml/element/text_spec.rb
Просмотреть файл

@ -1,46 +1,49 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#text" do
before :each do
@e = REXML::Element.new "name"
@e.text = "John"
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Element#text" do
before :each do
@e = REXML::Element.new "name"
@e.text = "John"
end
it "returns the text node of element" do
@e.text.should == "John"
end
it "returns the text node value" do
t = REXML::Text.new "Joe"
@e.text = t
@e.text.should == "Joe"
@e.text.should_not == t
end
it "returns nil if no text is attached" do
elem = REXML::Element.new "name"
elem.text.should == nil
end
end
it "returns the text node of element" do
@e.text.should == "John"
end
describe "REXML::Element#text=" do
before :each do
@e = REXML::Element.new "name"
@e.text = "John"
end
it "returns the text node value" do
t = REXML::Text.new "Joe"
@e.text = t
@e.text.should == "Joe"
@e.text.should_not == t
end
it "sets the text node" do
@e.to_s.should == "<name>John</name>"
end
it "returns nil if no text is attached" do
elem = REXML::Element.new "name"
elem.text.should == nil
end
end
describe "REXML::Element#text=" do
before :each do
@e = REXML::Element.new "name"
@e.text = "John"
end
it "sets the text node" do
@e.to_s.should == "<name>John</name>"
end
it "replaces existing text" do
@e.text = "Joe"
@e.to_s.should == "<name>Joe</name>"
end
it "receives nil as an argument" do
@e.text = nil
@e.to_s.should == "<name/>"
it "replaces existing text" do
@e.text = "Joe"
@e.to_s.should == "<name>Joe</name>"
end
it "receives nil as an argument" do
@e.text = nil
@e.to_s.should == "<name/>"
end
end
end

23
spec/ruby/library/rexml/element/texts_spec.rb
Просмотреть файл

@ -1,16 +1,19 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#texts" do
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns an array of the Text children" do
e = REXML::Element.new("root")
e.add_text "First"
e.add_text "Second"
e.texts.should == ["FirstSecond"]
end
describe "REXML::Element#texts" do
it "returns an empty array if it has no Text children" do
REXML::Element.new("root").texts.should == []
it "returns an array of the Text children" do
e = REXML::Element.new("root")
e.add_text "First"
e.add_text "Second"
e.texts.should == ["FirstSecond"]
end
it "returns an empty array if it has no Text children" do
REXML::Element.new("root").texts.should == []
end
end
end

33
spec/ruby/library/rexml/element/whitespace_spec.rb
Просмотреть файл

@ -1,23 +1,26 @@
require 'rexml/document'
require_relative '../../../spec_helper'
describe "REXML::Element#whitespace" do
it "returns true if whitespace is respected in the element" do
e = REXML::Element.new("root")
e.whitespace.should be_true
ruby_version_is ''...'2.8' do
require 'rexml/document'
e = REXML::Element.new("root", nil, respect_whitespace: :all)
e.whitespace.should be_true
describe "REXML::Element#whitespace" do
it "returns true if whitespace is respected in the element" do
e = REXML::Element.new("root")
e.whitespace.should be_true
e = REXML::Element.new("root", nil, respect_whitespace: ["root"])
e.whitespace.should be_true
end
e = REXML::Element.new("root", nil, respect_whitespace: :all)
e.whitespace.should be_true
it "returns false if whitespace is ignored inside element" do
e = REXML::Element.new("root", nil, compress_whitespace: :all)
e.whitespace.should be_false
e = REXML::Element.new("root", nil, respect_whitespace: ["root"])
e.whitespace.should be_true
end
e = REXML::Element.new("root", nil, compress_whitespace: ["root"])
e.whitespace.should be_false
it "returns false if whitespace is ignored inside element" do
e = REXML::Element.new("root", nil, compress_whitespace: :all)
e.whitespace.should be_false
e = REXML::Element.new("root", nil, compress_whitespace: ["root"])
e.whitespace.should be_false
end
end
end

35
spec/ruby/library/rexml/node/each_recursive_spec.rb
Просмотреть файл

@ -1,21 +1,24 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Node#each_recursive" do
before :each do
@doc = REXML::Document.new
@doc << REXML::XMLDecl.new
@root = REXML::Element.new "root"
@child1 = REXML::Element.new "child1"
@child2 = REXML::Element.new "child2"
@root << @child1
@root << @child2
@doc << @root
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "visits all subnodes of self" do
nodes = []
@doc.each_recursive { |node| nodes << node}
nodes.should == [@root, @child1, @child2]
describe "REXML::Node#each_recursive" do
before :each do
@doc = REXML::Document.new
@doc << REXML::XMLDecl.new
@root = REXML::Element.new "root"
@child1 = REXML::Element.new "child1"
@child2 = REXML::Element.new "child2"
@root << @child1
@root << @child2
@doc << @root
end
it "visits all subnodes of self" do
nodes = []
@doc.each_recursive { |node| nodes << node}
nodes.should == [@root, @child1, @child2]
end
end
end

41
spec/ruby/library/rexml/node/find_first_recursive_spec.rb
Просмотреть файл

@ -1,25 +1,28 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Node#find_first_recursive" do
before :each do
@e = REXML::Element.new("root")
@node1 = REXML::Element.new("node")
@node2 = REXML::Element.new("another node")
@subnode = REXML::Element.new("another node")
@node1 << @subnode
@e << @node1
@e << @node2
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "finds the first element that matches block" do
found = @e.find_first_recursive { |n| n.to_s == "<node><another node/></node>"}
found.should == @node1
end
describe "REXML::Node#find_first_recursive" do
before :each do
@e = REXML::Element.new("root")
@node1 = REXML::Element.new("node")
@node2 = REXML::Element.new("another node")
@subnode = REXML::Element.new("another node")
@node1 << @subnode
@e << @node1
@e << @node2
end
it "visits the nodes in preorder" do
found = @e.find_first_recursive { |n| n.to_s == "<another node/>"}
found.should == @subnode
found.should_not == @node2
it "finds the first element that matches block" do
found = @e.find_first_recursive { |n| n.to_s == "<node><another node/></node>"}
found.should == @node1
end
it "visits the nodes in preorder" do
found = @e.find_first_recursive { |n| n.to_s == "<another node/>"}
found.should == @subnode
found.should_not == @node2
end
end
end

23
spec/ruby/library/rexml/node/index_in_parent_spec.rb
Просмотреть файл

@ -1,15 +1,18 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Node#index_in_parent" do
it "returns the index (starting from 1) of self in parent" do
e = REXML::Element.new("root")
node1 = REXML::Element.new("node")
node2 = REXML::Element.new("another node")
e << node1
e << node2
ruby_version_is ''...'2.8' do
require 'rexml/document'
node1.index_in_parent.should == 1
node2.index_in_parent.should == 2
describe "REXML::Node#index_in_parent" do
it "returns the index (starting from 1) of self in parent" do
e = REXML::Element.new("root")
node1 = REXML::Element.new("node")
node2 = REXML::Element.new("another node")
e << node1
e << node2
node1.index_in_parent.should == 1
node2.index_in_parent.should == 2
end
end
end

33
spec/ruby/library/rexml/node/next_sibling_node_spec.rb
Просмотреть файл

@ -1,21 +1,24 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Node#next_sibling_node" do
before :each do
@e = REXML::Element.new("root")
@node1 = REXML::Element.new("node")
@node2 = REXML::Element.new("another node")
@e << @node1
@e << @node2
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns the next child node in parent" do
@node1.next_sibling_node.should == @node2
end
describe "REXML::Node#next_sibling_node" do
before :each do
@e = REXML::Element.new("root")
@node1 = REXML::Element.new("node")
@node2 = REXML::Element.new("another node")
@e << @node1
@e << @node2
end
it "returns nil if there are no more child nodes next" do
@node2.next_sibling_node.should == nil
@e.next_sibling_node.should == nil
it "returns the next child node in parent" do
@node1.next_sibling_node.should == @node2
end
it "returns nil if there are no more child nodes next" do
@node2.next_sibling_node.should == nil
@e.next_sibling_node.should == nil
end
end
end

31
spec/ruby/library/rexml/node/parent_spec.rb
Просмотреть файл

@ -1,20 +1,23 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Node#parent?" do
it "returns true for Elements" do
e = REXML::Element.new("foo")
e.parent?.should == true
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns true for Documents" do
e = REXML::Document.new
e.parent?.should == true
end
describe "REXML::Node#parent?" do
it "returns true for Elements" do
e = REXML::Element.new("foo")
e.parent?.should == true
end
# This includes attributes, CDatas and declarations.
it "returns false for Texts" do
e = REXML::Text.new("foo")
e.parent?.should == false
it "returns true for Documents" do
e = REXML::Document.new
e.parent?.should == true
end
# This includes attributes, CDatas and declarations.
it "returns false for Texts" do
e = REXML::Text.new("foo")
e.parent?.should == false
end
end
end

33
spec/ruby/library/rexml/node/previous_sibling_node_spec.rb
Просмотреть файл

@ -1,21 +1,24 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Node#previous_sibling_node" do
before :each do
@e = REXML::Element.new("root")
@node1 = REXML::Element.new("node")
@node2 = REXML::Element.new("another node")
@e << @node1
@e << @node2
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns the previous child node in parent" do
@node2.previous_sibling_node.should == @node1
end
describe "REXML::Node#previous_sibling_node" do
before :each do
@e = REXML::Element.new("root")
@node1 = REXML::Element.new("node")
@node2 = REXML::Element.new("another node")
@e << @node1
@e << @node2
end
it "returns nil if there are no more child nodes before" do
@node1.previous_sibling_node.should == nil
@e.previous_sibling_node.should == nil
it "returns the previous child node in parent" do
@node2.previous_sibling_node.should == @node1
end
it "returns nil if there are no more child nodes before" do
@node1.previous_sibling_node.should == nil
@e.previous_sibling_node.should == nil
end
end
end

15
spec/ruby/library/rexml/text/append_spec.rb
Просмотреть файл

@ -1,10 +1,13 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Text#<<" do
it "appends a string to this text node" do
text = REXML::Text.new("foo")
text << "bar"
text.should == "foobar"
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Text#<<" do
it "appends a string to this text node" do
text = REXML::Text.new("foo")
text << "bar"
text.should == "foobar"
end
end
end

15
spec/ruby/library/rexml/text/clone_spec.rb
Просмотреть файл

@ -1,10 +1,13 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Text#clone" do
it "creates a copy of this node" do
text = REXML::Text.new("foo")
text.clone.should == "foo"
text.clone.should == text
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Text#clone" do
it "creates a copy of this node" do
text = REXML::Text.new("foo")
text.clone.should == "foo"
text.clone.should == text
end
end
end

39
spec/ruby/library/rexml/text/comparison_spec.rb
Просмотреть файл

@ -1,25 +1,28 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Text#<=>" do
before :each do
@first = REXML::Text.new("abc")
@last = REXML::Text.new("def")
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns -1 if lvalue is less than rvalue" do
val = @first <=> @last
val.should == -1
end
describe "REXML::Text#<=>" do
before :each do
@first = REXML::Text.new("abc")
@last = REXML::Text.new("def")
end
it "returns -1 if lvalue is greater than rvalue" do
val = @last <=> @first
val.should == 1
end
it "returns -1 if lvalue is less than rvalue" do
val = @first <=> @last
val.should == -1
end
it "returns 0 if both values are equal" do
tmp = REXML::Text.new("tmp")
val = tmp <=> tmp
val.should == 0
it "returns -1 if lvalue is greater than rvalue" do
val = @last <=> @first
val.should == 1
end
it "returns 0 if both values are equal" do
tmp = REXML::Text.new("tmp")
val = tmp <=> tmp
val.should == 0
end
end
end

17
spec/ruby/library/rexml/text/empty_spec.rb
Просмотреть файл

@ -1,12 +1,15 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Text#empty?" do
it "returns true if the text is empty" do
REXML::Text.new("").empty?.should == true
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "returns false if the text is not empty" do
REXML::Text.new("some_text").empty?.should == false
describe "REXML::Text#empty?" do
it "returns true if the text is empty" do
REXML::Text.new("").empty?.should == true
end
it "returns false if the text is not empty" do
REXML::Text.new("some_text").empty?.should == false
end
end
end

35
spec/ruby/library/rexml/text/indent_text_spec.rb
Просмотреть файл

@ -1,23 +1,26 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Text#indent_text" do
before :each do
@t = REXML::Text.new("")
end
it "indents a string with default parameters" do
@t.indent_text("foo").should == "\tfoo"
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "accepts a custom indentation level as second argument" do
@t.indent_text("foo", 2, "\t", true).should == "\t\tfoo"
end
describe "REXML::Text#indent_text" do
before :each do
@t = REXML::Text.new("")
end
it "indents a string with default parameters" do
@t.indent_text("foo").should == "\tfoo"
end
it "accepts a custom separator as third argument" do
@t.indent_text("foo", 1, "\n", true).should == "\nfoo"
end
it "accepts a custom indentation level as second argument" do
@t.indent_text("foo", 2, "\t", true).should == "\t\tfoo"
end
it "accepts a fourth parameter to skip the first line" do
@t.indent_text("foo", 1, "\t", false).should == "foo"
it "accepts a custom separator as third argument" do
@t.indent_text("foo", 1, "\n", true).should == "\nfoo"
end
it "accepts a fourth parameter to skip the first line" do
@t.indent_text("foo", 1, "\t", false).should == "foo"
end
end
end

11
spec/ruby/library/rexml/text/inspect_spec.rb
Просмотреть файл

@ -1,8 +1,11 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Text#inspect" do
it "inspects the string attribute as a string" do
REXML::Text.new("a text").inspect.should == "a text".inspect
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Text#inspect" do
it "inspects the string attribute as a string" do
REXML::Text.new("a text").inspect.should == "a text".inspect
end
end
end

75
spec/ruby/library/rexml/text/new_spec.rb
Просмотреть файл

@ -1,48 +1,51 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Text.new" do
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "creates a Text child node with no parent" do
t = REXML::Text.new("test")
t.should be_kind_of(REXML::Child)
t.should == "test"
t.parent.should == nil
end
describe "REXML::Text.new" do
it "respects whitespace if second argument is true" do
t = REXML::Text.new("testing whitespace", true)
t.should == "testing whitespace"
t = REXML::Text.new(" ", true)
t.should == " "
end
it "creates a Text child node with no parent" do
t = REXML::Text.new("test")
t.should be_kind_of(REXML::Child)
t.should == "test"
t.parent.should == nil
end
it "receives a parent as third argument" do
e = REXML::Element.new("root")
t = REXML::Text.new("test", false, e)
t.parent.should == e
e.to_s.should == "<root>test</root>"
end
it "respects whitespace if second argument is true" do
t = REXML::Text.new("testing whitespace", true)
t.should == "testing whitespace"
t = REXML::Text.new(" ", true)
t.should == " "
end
it "expects escaped text if raw is true" do
t = REXML::Text.new("&lt;&amp;&gt;", false, nil, true)
t.should == "&lt;&amp;&gt;"
it "receives a parent as third argument" do
e = REXML::Element.new("root")
t = REXML::Text.new("test", false, e)
t.parent.should == e
e.to_s.should == "<root>test</root>"
end
->{ REXML::Text.new("<&>", false, nil, true)}.should raise_error(Exception)
end
it "expects escaped text if raw is true" do
t = REXML::Text.new("&lt;&amp;&gt;", false, nil, true)
t.should == "&lt;&amp;&gt;"
it "uses raw value of the parent if raw is nil" do
e1 = REXML::Element.new("root", nil, { raw: :all})
-> {REXML::Text.new("<&>", false, e1)}.should raise_error(Exception)
->{ REXML::Text.new("<&>", false, nil, true)}.should raise_error(Exception)
end
e2 = REXML::Element.new("root", nil, { raw: []})
e2.raw.should be_false
t1 = REXML::Text.new("<&>", false, e2)
t1.should == "&lt;&amp;&gt;"
end
it "uses raw value of the parent if raw is nil" do
e1 = REXML::Element.new("root", nil, { raw: :all})
-> {REXML::Text.new("<&>", false, e1)}.should raise_error(Exception)
it "escapes the values if raw is false" do
t = REXML::Text.new("<&>", false, nil, false)
t.should == "&lt;&amp;&gt;"
e2 = REXML::Element.new("root", nil, { raw: []})
e2.raw.should be_false
t1 = REXML::Text.new("<&>", false, e2)
t1.should == "&lt;&amp;&gt;"
end
it "escapes the values if raw is false" do
t = REXML::Text.new("<&>", false, nil, false)
t.should == "&lt;&amp;&gt;"
end
end
end

11
spec/ruby/library/rexml/text/node_type_spec.rb
Просмотреть файл

@ -1,8 +1,11 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Text#node_type" do
it "returns :text" do
REXML::Text.new("test").node_type.should == :text
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Text#node_type" do
it "returns :text" do
REXML::Text.new("test").node_type.should == :text
end
end
end

11
spec/ruby/library/rexml/text/normalize_spec.rb
Просмотреть файл

@ -1,8 +1,11 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Text.normalize" do
it "escapes a string with <, >, &, ' and \" " do
REXML::Text.normalize("< > & \" '").should == "&lt; &gt; &amp; &quot; &apos;"
ruby_version_is ''...'2.8' do
require 'rexml/document'
describe "REXML::Text.normalize" do
it "escapes a string with <, >, &, ' and \" " do
REXML::Text.normalize("< > & \" '").should == "&lt; &gt; &amp; &quot; &apos;"
end
end
end

17
spec/ruby/library/rexml/text/read_with_substitution_spec.rb
Просмотреть файл

@ -1,12 +1,15 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Text.read_with_substitution" do
it "reads a text and escapes entities" do
REXML::Text.read_with_substitution("&lt; &gt; &amp; &quot; &apos;").should == "< > & \" '"
end
ruby_version_is ''...'2.8' do
require 'rexml/document'
it "accepts an regex for invalid expressions and raises an error if text matches" do
-> {REXML::Text.read_with_substitution("this is illegal", /illegal/)}.should raise_error(Exception)
describe "REXML::Text.read_with_substitution" do
it "reads a text and escapes entities" do
REXML::Text.read_with_substitution("&lt; &gt; &amp; &quot; &apos;").should == "< > & \" '"
end
it "accepts an regex for invalid expressions and raises an error if text matches" do
-> {REXML::Text.read_with_substitution("this is illegal", /illegal/)}.should raise_error(Exception)
end
end
end

25
spec/ruby/library/rexml/text/to_s_spec.rb
Просмотреть файл

@ -1,17 +1,20 @@
require_relative '../../../spec_helper'
require 'rexml/document'
describe "REXML::Text#to_s" do
it "returns the string of this Text node" do
u = REXML::Text.new("sean russell", false, nil, true)
u.to_s.should == "sean russell"
ruby_version_is ''...'2.8' do
require 'rexml/document'
t = REXML::Text.new("some test text")
t.to_s.should == "some test text"
end
describe "REXML::Text#to_s" do
it "returns the string of this Text node" do
u = REXML::Text.new("sean russell", false, nil, true)
u.to_s.should == "sean russell"
it "escapes the text" do
t = REXML::Text.new("& < >")
t.to_s.should == "&amp; &lt; &gt;"
t = REXML::Text.new("some test text")
t.to_s.should == "some test text"
end
it "escapes the text" do
t = REXML::Text.new("& < >")
t.to_s.should == "&amp; &lt; &gt;"
end
end
end

Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше