This commit was manufactured by cvs2svn to create branch 'ruby_1_8'.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8@6109 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

10 files changed, 1244 insertions, 0 deletions

diff --git a/test/rss/rss-assertions.rb b/test/rss/rss-assertions.rb
new file mode 100644
index 0000000000..db9c39dd28
--- /dev/null
+++ b/test/rss/rss-assertions.rb
@@ -0,0 +1,127 @@
+# -*- tab-width: 2 -*- vim: ts=2
+
+module RSS
+	module Assertions
+		
+		def assert_parse(rss, assert_method, *args)
+			send("assert_#{assert_method}", *args) do
+				::RSS::Parser.parse(rss)
+			end
+			send("assert_#{assert_method}", *args) do
+				::RSS::Parser.parse(rss, false).validate
+			end
+		end
+		
+		def assert_ns(prefix, uri)
+			_wrap_assertion do
+				begin
+					yield
+					flunk("Not raise NSError")
+				rescue ::RSS::NSError => e
+					assert_equal(prefix, e.prefix)
+					assert_equal(uri, e.uri)
+				end
+			end
+		end
+		
+		def assert_missing_tag(tag, parent)
+			_wrap_assertion do
+				begin
+					yield
+					flunk("Not raise MissingTagError")
+				rescue ::RSS::MissingTagError => e
+					assert_equal(tag, e.tag)
+					assert_equal(parent, e.parent)
+				end
+			end
+		end
+		
+		def assert_too_much_tag(tag, parent)
+			_wrap_assertion do
+				begin
+					yield
+					flunk("Not raise TooMuchTagError")
+				rescue ::RSS::TooMuchTagError => e
+					assert_equal(tag, e.tag)
+					assert_equal(parent, e.parent)
+				end
+			end
+		end
+		
+		def assert_missing_attribute(tag, attrname)
+			_wrap_assertion do
+				begin
+					yield
+					flunk("Not raise MissingAttributeError")
+				rescue ::RSS::MissingAttributeError => e
+					assert_equal(tag, e.tag)
+					assert_equal(attrname, e.attribute)
+				end
+			end
+		end
+		
+		def assert_not_excepted_tag(tag, parent)
+			_wrap_assertion do
+				begin
+					yield
+					flunk("Not raise NotExceptedTagError")
+				rescue ::RSS::NotExceptedTagError => e
+					assert_equal(tag, e.tag)
+					assert_equal(parent, e.parent)
+				end
+			end
+		end
+		
+		def assert_not_available_value(tag, value)
+			_wrap_assertion do
+				begin
+					yield
+					flunk("Not raise NotAvailableValueError")
+				rescue ::RSS::NotAvailableValueError => e
+					assert_equal(tag, e.tag)
+					assert_equal(value, e.value)
+				end
+			end
+		end
+		
+		def assert_xml_stylesheet_attrs(xsl, attrs)
+			_wrap_assertion do
+				normalized_attrs = {}
+				attrs.each do |name, value|
+					normalized_attrs[name.to_s] = value
+				end
+				::RSS::XMLStyleSheet::ATTRIBUTES.each do |name|
+					assert_equal(normalized_attrs[name], xsl.send(name))
+				end
+			end
+		end
+		
+		def assert_xml_stylesheet(target, xsl, attrs)
+			_wrap_assertion do
+				if attrs.has_key?(:href)
+					if !attrs.has_key?(:type) and attrs.has_key?(:guess_type)
+						attrs[:type] = attrs[:guess_type]
+					end
+					assert_equal("xml-stylesheet", target)
+					assert_xml_stylesheet_attrs(xsl, attrs)
+				else
+					assert_nil(target)
+					assert_equal("", xsl.to_s)
+				end
+			end
+		end
+		
+		def assert_xml_stylesheet_pis(attrs_ary)
+			rdf = ::RSS::RDF.new()
+			xss_strs = []
+			attrs_ary.each do |attrs|
+				xss = ::RSS::XMLStyleSheet.new(*attrs)
+				xss_strs.push(xss.to_s)
+				rdf.xml_stylesheets.push(xss)
+			end
+			pi_str = rdf.to_s.gsub(/<\?xml .*\n/, "").gsub(/\s*<rdf:RDF.*\z/m, "")
+			assert_equal(xss_strs.join("\n"), pi_str)
+		end
+		
+	end
+end
diff --git a/test/rss/rss-testcase.rb b/test/rss/rss-testcase.rb
new file mode 100644
index 0000000000..349e3d4dc1
--- /dev/null
+++ b/test/rss/rss-testcase.rb
@@ -0,0 +1,164 @@
+# -*- tab-width: 2 -*- vim: ts=2
+
+require "test/unit"
+require 'rss-assertions'
+
+module RSS
+	class TestCase < Test::Unit::TestCase
+
+		include RSS
+		include Assertions
+
+		XMLDECL_VERSION = "1.0"
+		XMLDECL_ENCODING = "UTF-8"
+		XMLDECL_STANDALONE = "no"
+
+		RDF_ABOUT = "http://www.xml.com/xml/news.rss"
+		RDF_RESOURCE = "http://xml.com/universal/images/xml_tiny.gif"
+		TITLE_VALUE = "XML.com"
+		LINK_VALUE = "http://xml.com/pub"
+		URL_VALUE = "http://xml.com/universal/images/xml_tiny.gif"
+		NAME_VALUE = "hogehoge"
+		DESCRIPTION_VALUE = "
+    XML.com features a rich mix of information and services 
+    for the XML community.
+		"
+		RESOURCES = [
+			"http://xml.com/pub/2000/08/09/xslt/xslt.html",
+			"http://xml.com/pub/2000/08/09/rdfdb/index.html",
+		]
+
+		def default_test
+			# This class isn't tested
+		end
+
+		private
+		def make_xmldecl(v=XMLDECL_VERSION, e=XMLDECL_ENCODING, s=XMLDECL_STANDALONE)
+			rv = "<?xml version='#{v}'"
+			rv << " encoding='#{e}'" if e
+			rv << " standalone='#{s}'" if s
+			rv << "?>"
+			rv
+		end
+
+		def make_RDF(content=nil, xmlns=[])
+			<<-EORSS
+#{make_xmldecl}
+<rdf:RDF xmlns="#{URI}" xmlns:rdf="#{RDF::URI}"
+#{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}>
+#{block_given? ? yield : content}
+</rdf:RDF>
+EORSS
+		end
+
+		def make_channel(content=nil)
+			<<-EOC
+<channel rdf:about="#{RDF_ABOUT}">
+	<title>#{TITLE_VALUE}</title>
+	<link>#{LINK_VALUE}</link>
+	<description>#{DESCRIPTION_VALUE}</description>
+
+	<image rdf:resource="#{RDF_RESOURCE}" />
+
+	<items>
+		<rdf:Seq>
+#{RESOURCES.collect do |res| '<rdf:li resource="' + res + '" />' end.join("\n")}
+		</rdf:Seq>
+	</items>
+
+	<textinput rdf:resource="#{RDF_RESOURCE}" />
+
+#{block_given? ? yield : content}
+</channel>
+EOC
+		end
+
+		def make_image(content=nil)
+			<<-EOI
+<image rdf:about="#{RDF_ABOUT}">
+	<title>#{TITLE_VALUE}</title>
+	<url>#{URL_VALUE}</url>
+	<link>#{LINK_VALUE}</link>
+#{block_given? ? yield : content}
+</image>
+EOI
+		end
+
+		def make_item(content=nil)
+			<<-EOI
+<item rdf:about="#{RDF_ABOUT}">
+	<title>#{TITLE_VALUE}</title>
+	<link>#{LINK_VALUE}</link>
+	<description>#{DESCRIPTION_VALUE}</description>
+#{block_given? ? yield : content}
+</item>
+EOI
+		end
+
+		def make_textinput(content=nil)
+			<<-EOT
+<textinput rdf:about="#{RDF_ABOUT}">
+	<title>#{TITLE_VALUE}</title>
+	<description>#{DESCRIPTION_VALUE}</description>
+	<name>#{NAME_VALUE}</name>
+	<link>#{LINK_VALUE}</link>
+#{block_given? ? yield : content}
+</textinput>
+EOT
+		end
+
+		def make_sample_RDF
+			make_RDF(<<-EOR)
+#{make_channel}
+#{make_image}
+#{make_item}
+#{make_textinput}
+EOR
+		end
+
+		def make_Rss2(content=nil, xmlns=[])
+			<<-EORSS
+#{make_xmldecl}
+<rss version="2.0"
+#{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}>
+#{block_given? ? yield : content}
+</rss>
+EORSS
+		end
+
+		def make_channel2(content=nil)
+			<<-EOC
+<channel>
+	<title>#{TITLE_VALUE}</title>
+	<link>#{LINK_VALUE}</link>
+	<description>#{DESCRIPTION_VALUE}</description>
+
+	<image>
+		<url>#{RDF_RESOURCE}</url>
+		<title>#{TITLE_VALUE}</title>
+		<link>#{LINK_VALUE}</link>
+	</image>
+
+#{RESOURCES.collect do |res| '<item><link>' + res + '</link></item>' end.join("\n")}
+
+	<textInput>
+		<link>#{RDF_RESOURCE}</link>
+	</textInput>
+
+#{block_given? ? yield : content}
+</channel>
+EOC
+		end
+
+		def make_item2(content=nil)
+			<<-EOI
+<item>
+	<title>#{TITLE_VALUE}</title>
+	<link>#{LINK_VALUE}</link>
+	<description>#{DESCRIPTION_VALUE}</description>
+#{block_given? ? yield : content}
+</item>
+EOI
+		end
+	end
+end
diff --git a/test/rss/test_1.0.rb b/test/rss/test_1.0.rb
new file mode 100644
index 0000000000..6ed4d90b15
--- /dev/null
+++ b/test/rss/test_1.0.rb
@@ -0,0 +1,259 @@
+# -*- tab-width: 2 -*- vim: ts=2
+
+require "rexml/document"
+
+require "rss-testcase"
+
+require "rss/1.0"
+
+module RSS
+	class TestCore < TestCase
+		
+		def setup
+			
+			@rdf_prefix = "rdf"
+			@rdf_uri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+			@uri = "http://purl.org/rss/1.0/"
+			
+		end
+		
+		def test_RDF
+			
+			version = "1.0"
+			encoding = "UTF-8"
+			standalone = "no"
+			
+			rdf = RDF.new(version, encoding, standalone)
+			
+			doc = REXML::Document.new(rdf.to_s(false))
+			
+			xmldecl = doc.xml_decl
+			
+			%w(version encoding standalone).each do |x|
+				assert_equal(instance_eval(x), xmldecl.send(x))
+			end
+			
+			assert_equal(@rdf_uri, doc.root.namespace)
+			
+		end
+		
+		def test_not_displayed_xml_stylesheets
+			rdf = RDF.new()
+			plain_rdf = rdf.to_s
+			3.times do
+				rdf.xml_stylesheets.push(XMLStyleSheet.new)
+				assert_equal(plain_rdf, rdf.to_s)
+			end
+		end
+		
+		def test_xml_stylesheets
+			[
+				[{:href => "a.xsl", :type => "text/xsl"}],
+				[
+					{:href => "a.xsl", :type => "text/xsl"},
+					{:href => "a.css", :type => "text/css"},
+				],
+			].each do |attrs_ary|
+				assert_xml_stylesheet_pis(attrs_ary)
+			end
+		end
+		
+		def test_channel
+			about = "http://hoge.com"
+			title = "fugafuga"
+			link = "http://hoge.com"
+			description = "fugafugafugafuga"
+			resource = "http://hoge.com/hoge.png"
+			image = RDF::Channel::Image.new(resource)
+			items = RDF::Channel::Items.new
+			textinput = RDF::Channel::Textinput.new(resource)
+			
+			channel = RDF::Channel.new(about)
+			%w(title link description image items textinput).each do |x|
+				channel.send("#{x}=", instance_eval(x))
+			end
+			
+			doc = REXML::Document.new(make_RDF(channel.to_s))
+			c = doc.root.elements[1]
+			
+			assert_equal(about, c.attributes["about"])
+			%w(title link description image textinput).each do |x|
+				elem = c.elements[x]
+				assert_equal(x, elem.name)
+				assert_equal(@uri, elem.namespace)
+				if x == "image" or x == "textinput"
+					excepted = resource
+					res = elem.attributes.get_attribute("resource")
+					assert_equal(@rdf_uri, res.namespace)
+					value = res.value
+				else
+					excepted = instance_eval(x)
+					value = elem.text
+				end
+				assert_equal(excepted, value)
+			end
+			assert_equal(@uri, c.elements["items"].namespace)
+			assert_equal("items", c.elements["items"].name)
+			
+		end
+		
+		def test_channel_image
+			
+			resource = "http://hoge.com/hoge.png"
+			image = RDF::Channel::Image.new(resource)
+			
+			doc = REXML::Document.new(make_RDF(image.to_s))
+			i = doc.root.elements[1]
+			
+			assert_equal("image", i.name)
+			assert_equal(@uri, i.namespace)
+			
+			res = i.attributes.get_attribute("resource")
+			
+			assert_equal(@rdf_uri, res.namespace)
+			assert_equal(resource, res.value)
+			
+		end
+		
+		def test_channel_textinput
+			
+			resource = "http://hoge.com/hoge.png"
+			textinput = RDF::Channel::Textinput.new(resource)
+			
+			doc = REXML::Document.new(make_RDF(textinput.to_s))
+			t = doc.root.elements[1]
+			
+			assert_equal("textinput", t.name)
+			assert_equal(@uri, t.namespace)
+			
+			res = t.attributes.get_attribute("resource")
+			
+			assert_equal(@rdf_uri, res.namespace)
+			assert_equal(resource, res.value)
+			
+		end
+		
+		def test_items
+			
+			items = RDF::Channel::Items.new
+			
+			doc = REXML::Document.new(make_RDF(items.to_s))
+			i = doc.root.elements[1]
+			
+			assert_equal("items", i.name)
+			assert_equal(@uri, i.namespace)
+			
+			assert_equal(1, i.elements.size)
+			assert_equal("Seq", i.elements[1].name)
+			assert_equal(@rdf_uri, i.elements[1].namespace)
+			
+		end
+		
+		def test_seq
+			
+			seq = RDF::Seq.new
+			
+			doc = REXML::Document.new(make_RDF(seq.to_s))
+			s = doc.root.elements[1]
+			
+			assert_equal("Seq", s.name)
+			assert_equal(@rdf_uri, s.namespace)
+			
+		end
+		
+		def test_li
+			
+			resource = "http://hoge.com/"
+			li = RDF::Li.new(resource)
+			
+			doc = REXML::Document.new(make_RDF(li.to_s))
+			l = doc.root.elements[1]
+			
+			assert_equal("li", l.name)
+			assert_equal(@rdf_uri, l.namespace(l.prefix))
+			
+			res = l.attributes.get_attribute("resource")
+			
+			assert_equal('', res.instance_eval("@prefix"))
+			assert_equal(resource, res.value)
+			
+		end
+		
+		def test_image
+			
+			about = "http://hoge.com"
+			title = "fugafuga"
+			url = "http://hoge.com/hoge"
+			link = "http://hoge.com/fuga"
+			
+			image = RDF::Image.new(about)
+			%w(title url link).each do |x|
+				image.send("#{x}=", instance_eval(x))
+			end
+			
+			doc = REXML::Document.new(make_RDF(image.to_s))
+			i = doc.root.elements[1]
+			
+			assert_equal(about, i.attributes["about"])
+			%w(title url link).each do |x|
+				elem = i.elements[x]
+				assert_equal(x, elem.name)
+				assert_equal(@uri, elem.namespace)
+				assert_equal(instance_eval(x), elem.text)
+			end
+			
+		end
+		
+		def test_item
+			
+			about = "http://hoge.com"
+			title = "fugafuga"
+			link = "http://hoge.com/fuga"
+			description = "hogehogehoge"
+			
+			item = RDF::Item.new(about)
+			%w(title link description).each do |x|
+				item.send("#{x}=", instance_eval(x))
+			end
+			
+			doc = REXML::Document.new(make_RDF(item.to_s))
+			i = doc.root.elements[1]
+			
+			assert_equal(about, i.attributes["about"])
+			%w(title link description).each do |x|
+				elem = i.elements[x]
+				assert_equal(x, elem.name)
+				assert_equal(@uri, elem.namespace)
+				assert_equal(instance_eval(x), elem.text)
+			end
+			
+		end
+		
+		def test_textinput
+			
+			about = "http://hoge.com"
+			title = "fugafuga"
+			link = "http://hoge.com/fuga"
+			name = "foo"
+			description = "hogehogehoge"
+			
+			textinput = RDF::Textinput.new(about)
+			%w(title link name description).each do |x|
+				textinput.send("#{x}=", instance_eval(x))
+			end
+			
+			doc = REXML::Document.new(make_RDF(textinput.to_s))
+			t = doc.root.elements[1]
+			
+			assert_equal(about, t.attributes["about"])
+			%w(title link name description).each do |x|
+				elem = t.elements[x]
+				assert_equal(x, elem.name)
+				assert_equal(@uri, elem.namespace)
+				assert_equal(instance_eval(x), elem.text)
+			end
+			
+		end
+		
+	end
+end
diff --git a/test/rss/test_accessor.rb b/test/rss/test_accessor.rb
new file mode 100644
index 0000000000..08f565e596
--- /dev/null
+++ b/test/rss/test_accessor.rb
@@ -0,0 +1,26 @@
+# -*- tab-width: 2 -*- vim: ts=2
+
+require "rss-testcase"
+
+require "rss/1.0"
+require "rss/2.0"
+
+module RSS
+	class TestAccessor < TestCase
+		
+		def test_date
+			channel = Rss::Channel.new
+			channel.do_validate = false
+			channel.pubDate = nil
+			assert_nil(channel.pubDate)
+			
+			time = Time.now
+			channel.pubDate = time
+			assert_equal(time, channel.pubDate)
+			
+			channel.pubDate = nil
+			assert_nil(channel.pubDate)
+		end
+		
+	end
+end
diff --git a/test/rss/test_content.rb b/test/rss/test_content.rb
new file mode 100644
index 0000000000..24877d3ec9
--- /dev/null
+++ b/test/rss/test_content.rb
@@ -0,0 +1,97 @@
+# -*- tab-width: 2 -*- vim: ts=2
+
+require "cgi"
+require "rexml/document"
+
+require "rss-testcase"
+
+require "rss/1.0"
+require "rss/content"
+
+module RSS
+	class TestContent < TestCase
+		
+		def setup
+			@prefix = "content"
+			@uri = "http://purl.org/rss/1.0/modules/content/"
+			
+			@parents = %w(item)
+			
+			@elems = {
+				:encoded => "<em>ATTENTION</em>",
+			}
+			
+			@content_nodes = @elems.collect do |name, value|
+				"<#{@prefix}:#{name}>#{CGI.escapeHTML(value.to_s)}</#{@prefix}:#{name}>"
+			end.join("\n")
+			
+			@rss_source = make_RDF(<<-EOR, {@prefix =>  @uri})
+#{make_channel()}
+#{make_image()}
+#{make_item(@content_nodes)}
+#{make_textinput()}
+EOR
+
+			@rss = Parser.parse(@rss_source)
+		end
+	
+		def test_parser
+
+			assert_nothing_raised do
+				Parser.parse(@rss_source)
+			end
+		
+			@elems.each do |tag, value|
+				assert_too_much_tag(tag.to_s, "item") do
+					Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
+#{make_channel()}
+#{make_item(("<" + @prefix + ":" + tag.to_s + ">" +
+	CGI.escapeHTML(value.to_s) +
+	"</" + @prefix + ":" + tag.to_s + ">") * 2)}
+EOR
+				end
+			end
+
+		end
+	
+		def test_accessor
+		
+			new_value = {
+				:encoded => "<![CDATA[<it>hoge</it>]]>",
+			}
+
+			@elems.each do |name, value|
+				@parents.each do |parent|
+					meth = "#{RSS::CONTENT_PREFIX}_#{name}"
+					assert_equal(value, @rss.send(parent).send(meth))
+					@rss.send(parent).send("#{meth}=", new_value[name].to_s)
+					assert_equal(new_value[name], @rss.send(parent).send(meth))
+				end
+			end
+
+		end
+		
+		def test_to_s
+			
+			@elems.each do |name, value|
+				excepted = "<#{@prefix}:#{name}>#{CGI.escapeHTML(value)}</#{@prefix}:#{name}>"
+				@parents.each do |parent|
+					meth = "#{RSS::CONTENT_PREFIX}_#{name}_element"
+					assert_equal(excepted, @rss.send(parent).send(meth))
+				end
+			end
+
+			REXML::Document.new(@rss_source).root.each_element do |parent|
+				if @parents.include?(parent.name)
+					parent.each_element do |elem|
+						if elem.namespace == @uri
+							assert_equal(elem.text, @elems[elem.name.intern].to_s)
+						end
+					end
+				end
+			end
+			
+		end
+	
+	end
+end
diff --git a/test/rss/test_dublincore.rb b/test/rss/test_dublincore.rb
new file mode 100644
index 0000000000..bf5a672837
--- /dev/null
+++ b/test/rss/test_dublincore.rb
@@ -0,0 +1,126 @@
+# -*- tab-width: 2 -*- vim: ts=2
+
+require "cgi"
+require "rexml/document"
+
+require "rss-testcase"
+
+require "rss/1.0"
+require "rss/dublincore"
+
+module RSS
+	class TestDublinCore < TestCase
+
+		def setup
+			@prefix = "dc"
+			@uri = "http://purl.org/dc/elements/1.1/"
+			
+			@parents = %w(channel image item textinput)
+			
+			t = Time.iso8601("2000-01-01T12:00:05+00:00")
+			class << t
+				alias_method(:to_s, :iso8601)
+			end
+			
+			@elems = {
+				:title => "hoge",
+				:description =>
+					" XML is placing increasingly heavy loads on
+					the existing technical infrastructure of the Internet.",
+				:creator => "Rael Dornfest (mailto:rael@oreilly.com)",
+				:subject => "XML",
+				:publisher => "The O'Reilly Network",
+				:contributor => "hogehoge",
+				:type => "fugafuga",
+				:format => "hohoho",
+				:identifier => "fufufu",
+				:source => "barbar",
+				:language => "ja",
+				:relation => "cococo",
+				:rights => "Copyright (c) 2000 O'Reilly &amp; Associates, Inc.",
+				:date => t,
+			}
+
+			@dc_nodes = @elems.collect do |name, value|
+				"<#{@prefix}:#{name}>#{value}</#{@prefix}:#{name}>"
+			end.join("\n")
+
+			@rss_source = make_RDF(<<-EOR, {@prefix =>  @uri})
+#{make_channel(@dc_nodes)}
+#{make_image(@dc_nodes)}
+#{make_item(@dc_nodes)}
+#{make_textinput(@dc_nodes)}
+EOR
+
+			@rss = Parser.parse(@rss_source)
+		end
+	
+		def test_parser
+
+			assert_nothing_raised do
+				Parser.parse(@rss_source)
+			end
+		
+			@elems.each do |tag, value|
+				assert_too_much_tag(tag.to_s, "channel") do
+					Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
+#{make_channel(("<" + @prefix + ":" + tag.to_s + ">" +
+	value.to_s +
+	"</" + @prefix + ":" + tag.to_s + ">") * 2)}
+#{make_item}
+EOR
+				end
+			end
+
+		end
+	
+		def test_accessor
+		
+			new_value = "hoge"
+
+			@elems.each do |name, value|
+				@parents.each do |parent|
+					parsed_value = @rss.send(parent).send("dc_#{name}")
+					if parsed_value.kind_of?(String)
+						parsed_value = CGI.escapeHTML(parsed_value)
+					end
+					assert_equal(value, parsed_value)
+					if name == :date
+						t = Time.iso8601("2003-01-01T02:30:23+09:00")
+						class << t
+							alias_method(:to_s, :iso8601)
+						end
+						@rss.send(parent).send("dc_#{name}=", t.iso8601)
+						assert_equal(t, @rss.send(parent).send("dc_#{name}"))
+					else
+						@rss.send(parent).send("dc_#{name}=", new_value)
+						assert_equal(new_value, @rss.send(parent).send("dc_#{name}"))
+					end
+				end
+			end
+
+		end
+
+		def test_to_s
+			
+			@elems.each do |name, value|
+				excepted = "<#{@prefix}:#{name}>#{value}</#{@prefix}:#{name}>"
+				@parents.each do |parent|
+					assert_equal(excepted, @rss.send(parent).send("dc_#{name}_element"))
+				end
+			end
+			
+			REXML::Document.new(@rss_source).root.each_element do |parent|
+				if @parents.include?(parent.name)
+					parent.each_element do |elem|
+						if elem.namespace == @uri
+							assert_equal(CGI.escapeHTML(elem.text), @elems[elem.name.intern].to_s)
+						end
+					end
+				end
+			end
+			
+		end
+
+	end
+end
diff --git a/test/rss/test_syndication.rb b/test/rss/test_syndication.rb
new file mode 100644
index 0000000000..0eec3bacc6
--- /dev/null
+++ b/test/rss/test_syndication.rb
@@ -0,0 +1,125 @@
+# -*- tab-width: 2 -*- vim: ts=2
+
+require "cgi"
+require "rexml/document"
+
+require "rss-testcase"
+
+require "rss/1.0"
+require "rss/syndication"
+
+module RSS
+	class TestSyndication < TestCase
+		
+		def setup
+			@prefix = "sy"
+			@uri = "http://purl.org/rss/1.0/modules/syndication/"
+			
+			@parents = %w(channel)
+			
+			t = Time.iso8601("2000-01-01T12:00:05+00:00")
+			class << t
+				alias_method(:to_s, :iso8601)
+			end
+			
+			@elems = {
+				:updatePeriod => "hourly",
+				:updateFrequency => 2,
+				:updateBase => t,
+			}
+			
+			@sy_nodes = @elems.collect do |name, value|
+				"<#{@prefix}:#{name}>#{CGI.escapeHTML(value.to_s)}</#{@prefix}:#{name}>"
+			end.join("\n")
+			
+			@rss_source = make_RDF(<<-EOR, {@prefix =>  @uri})
+#{make_channel(@sy_nodes)}
+#{make_image()}
+#{make_item()}
+#{make_textinput()}
+EOR
+
+			@rss = Parser.parse(@rss_source)
+		end
+	
+		def test_parser
+			
+			assert_nothing_raised do
+				Parser.parse(@rss_source)
+			end
+			
+			@elems.each do |tag, value|
+				assert_too_much_tag(tag.to_s, "channel") do
+					Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
+#{make_channel(("<" + @prefix + ":" + tag.to_s + ">" +
+	CGI.escapeHTML(value.to_s) +
+	"</" + @prefix + ":" + tag.to_s + ">") * 2)}
+#{make_item}
+EOR
+				end
+			end
+
+		end
+	
+		def test_accessor
+			
+			t = Time.iso8601("2003-01-01T12:00:23+09:00")
+			class << t
+				alias_method(:to_s, :iso8601)
+			end
+			
+			new_value = {
+				:updatePeriod => "daily",
+				:updateFrequency => +11,
+				:updateBase => t,
+			}
+			
+			@elems.each do |name, value|
+				@parents.each do |parent|
+					assert_equal(value, @rss.send(parent).send("sy_#{name}"))
+					@rss.send(parent).send("sy_#{name}=", new_value[name].to_s)
+					assert_equal(new_value[name], @rss.send(parent).send("sy_#{name}"))
+				end
+			end
+			
+			%w(hourly daily weekly monthly yearly).each do |x|
+				@parents.each do |parent|
+					assert_nothing_raised do
+						@rss.send(parent).sy_updatePeriod = x
+					end
+				end
+			end
+			
+			%w(-2 0.3 -0.4).each do |x|
+				@parents.each do |parent|
+					assert_not_available_value("updateBase", x) do
+						@rss.send(parent).sy_updateBase = x
+					end
+				end
+			end
+			
+		end
+
+		def test_to_s
+			
+			@elems.each do |name, value|
+				excepted = "<#{@prefix}:#{name}>#{value}</#{@prefix}:#{name}>"
+				@parents.each do |parent|
+					assert_equal(excepted, @rss.send(parent).send("sy_#{name}_element"))
+				end
+			end
+			
+			REXML::Document.new(@rss_source).root.each_element do |parent|
+				if @parents.include?(parent.name)
+					parent.each_element do |elem|
+						if elem.namespace == @uri
+							assert_equal(elem.text, @elems[elem.name.intern].to_s)
+						end
+					end
+				end
+			end
+			
+		end
+	
+	end
+end
diff --git a/test/rss/test_trackback.rb b/test/rss/test_trackback.rb
new file mode 100644
index 0000000000..141ef50779
--- /dev/null
+++ b/test/rss/test_trackback.rb
@@ -0,0 +1,137 @@
+# -*- tab-width: 2 -*- vim: ts=2
+
+require "cgi"
+require "rexml/document"
+
+require "rss-testcase"
+
+require "rss/1.0"
+require "rss/2.0"
+require "rss/trackback"
+
+module RSS
+	class TestTrackBack < TestCase
+		
+		def setup
+			@prefix = "trackback"
+			@uri = "http://madskills.com/public/xml/rss/module/trackback/"
+			
+			@parents = %w(item)
+			
+			@elems = {
+				:ping => "http://bar.com/tb.cgi?tb_id=rssplustrackback",
+				:about => "http://foo.com/trackback/tb.cgi?tb_id=20020923",
+			}
+			
+			@content_nodes = @elems.collect do |name, value|
+				"<#{@prefix}:#{name} rdf:resource=\"#{CGI.escapeHTML(value.to_s)}\"/>"
+			end.join("\n")
+			
+			@content_nodes2 = @elems.collect do |name, value|
+				"<#{@prefix}:#{name}>#{CGI.escapeHTML(value.to_s)}</#{@prefix}:#{name}>"
+			end.join("\n")
+			
+			@rss_source = make_RDF(<<-EOR, {@prefix =>  @uri})
+#{make_channel()}
+#{make_image()}
+#{make_item(@content_nodes)}
+#{make_textinput()}
+EOR
+
+			@rss = Parser.parse(@rss_source)
+
+			@rss2_source = make_Rss2(nil, {@prefix =>  @uri}) do
+				make_channel2(nil) do
+					make_item2(@content_nodes2)
+				end
+			end
+
+			@rss2 = Parser.parse(@rss2_source, false)
+		end
+
+		def test_parser
+
+			assert_nothing_raised do
+				Parser.parse(@rss_source)
+			end
+
+			@elems.find_all{|k, v| k == :ping}.each do |tag, value|
+				assert_too_much_tag(tag.to_s, "item") do
+					Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
+#{make_channel()}
+#{make_item(("<" + @prefix + ":" + tag.to_s + " rdf:resource=\"" +
+	CGI.escapeHTML(value.to_s) +
+	"\"/>") * 2)}
+EOR
+				end
+			end
+
+			@elems.find_all{|k, v| k == :about}.each do |tag, value|
+				assert_missing_tag("trackback:ping", "item") do
+					Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
+#{make_channel()}
+#{make_item(("<" + @prefix + ":" + tag.to_s + " rdf:resource=\"" +
+	CGI.escapeHTML(value.to_s) +
+	"\"/>") * 2)}
+EOR
+				end
+
+			end
+
+		end
+	
+		def test_accessor
+			
+			new_value = {
+				:ping => "http://baz.com/trackback/tb.cgi?tb_id=20030808",
+				:about => "http://hoge.com/trackback/tb.cgi?tb_id=90030808",
+			}
+			
+			@elems.each do |name, value|
+				@parents.each do |parent|
+					accessor = "#{RSS::TRACKBACK_PREFIX}_#{name}"
+					target_accessor = "resource"
+					target = @rss.send(parent).send(accessor)
+					target2 = @rss2.channel.send(parent, -1)
+					assert_equal(value, target.send(target_accessor))
+					assert_equal(value, target2.send(accessor))
+					target.send("#{target_accessor}=", new_value[name].to_s)
+					if name == :about
+						# abount is zero or more
+						target2.send("#{accessor}=", 0, new_value[name].to_s)
+					else
+						target2.send("#{accessor}=", new_value[name].to_s)
+					end
+					assert_equal(new_value[name], target.send(target_accessor))
+					assert_equal(new_value[name], target2.send(accessor))
+				end
+			end
+			
+		end
+
+		def test_to_s
+			
+			@elems.each do |name, value|
+				excepted = %Q!<#{@prefix}:#{name} rdf:resource="#{CGI.escapeHTML(value)}"/>!
+				@parents.each do |parent|
+					meth = "#{RSS::TRACKBACK_PREFIX}_#{name}_element"
+					meth << "s" if name == :about
+					assert_equal(excepted, @rss.send(parent).send(meth))
+				end
+			end
+			
+			REXML::Document.new(@rss_source).root.each_element do |parent|
+				if @parents.include?(parent.name)
+					parent.each_element do |elem|
+						if elem.namespace == @uri
+							assert_equal(elem.attributes["resource"], @elems[elem.name.intern])
+						end
+					end
+				end
+			end
+			
+		end
+		
+	end
+end
+
diff --git a/test/rss/test_xml-stylesheet.rb b/test/rss/test_xml-stylesheet.rb
new file mode 100644
index 0000000000..ed056257d6
--- /dev/null
+++ b/test/rss/test_xml-stylesheet.rb
@@ -0,0 +1,110 @@
+# -*- tab-width: 2 -*- vim: ts=2
+
+require "rexml/document"
+
+require "rss-testcase"
+
+require "rss/1.0"
+require "rss/xml-stylesheet"
+
+module RSS
+	class TestXMLStyleSheet < TestCase
+		
+		def test_accessor
+			[
+				{:href => "a.xsl", :type => "text/xsl"},
+				{:media => "print", :title => "FOO"},
+				{:charset => "UTF-8", :alternate => "yes"},
+			].each do |attrs|
+				assert_xml_stylesheet_attrs(XMLStyleSheet.new(*attrs), attrs)
+			end
+		end
+		
+		def test_to_s
+			[
+				{:href => "a.xsl", :type => "text/xsl"},
+				{:type => "text/xsl"},
+				{:href => "a.xsl", :guess_type => "text/xsl"},
+				{:href => "a.css", :type => "text/css"},
+				{:href => "a.css", :type => "text/xsl",
+				 :guess_type => "text/css"},
+				{:href => "a.xsl", :type => "text/xsl",
+				 :title => "sample", :media => "printer",
+				 :charset => "UTF-8", :alternate => "yes"},
+				{:href => "a.css", :guess_type => "text/css",
+				 :alternate => "no"},
+				{:type => "text/xsl", :title => "sample",
+				 :media => "printer", :charset => "UTF-8",
+				 :alternate => "yes"},
+			].each do |attrs|
+				target, contents = parse_pi(XMLStyleSheet.new(*attrs).to_s)
+				assert_xml_stylesheet(target, XMLStyleSheet.new(*contents), attrs)
+			end
+		end
+		
+		def test_bad_alternate
+			%w(a ___ ??? BAD_ALTERNATE).each do |value|
+				xss = XMLStyleSheet.new
+				assert_raise(NotAvailableValueError) do
+					xss.alternate = value
+				end
+				xss.do_validate = false
+				assert_nothing_raised do
+					xss.alternate = value
+				end
+				assert_nil(xss.alternate)
+			end
+		end
+		
+		def test_parse
+			[
+				[{:href => "a.xsl", :type => "text/xsl"},],
+				[{:media => "print", :title => "FOO"},],
+				[{:charset => "UTF-8", :alternate => "yes"},],
+				[{:href => "a.xsl", :type => "text/xsl"},
+				 {:type => "text/xsl"},
+				 {:href => "a.xsl", :guess_type => "text/xsl"},
+				 {:href => "a.css", :type => "text/css"},
+				 {:href => "a.css", :type => "text/xsl",
+					:guess_type => "text/css"},
+				 {:href => "a.xsl", :type => "text/xsl",
+					:title => "sample", :media => "printer",
+					:charset => "UTF-8", :alternate => "yes"},
+				 {:href => "a.css", :guess_type => "text/css",
+					:alternate => "no"},
+				 {:type => "text/xsl", :title => "sample",
+					:media => "printer", :charset => "UTF-8",
+					:alternate => "yes"},],
+			].each do |xsss|
+				doc = REXML::Document.new(make_sample_RDF)
+				root = doc.root
+				xsss.each do |xss|
+					content = xss.collect do |key, name|
+						%Q[#{key}="#{name}"]
+					end.join(" ")
+					pi = REXML::Instruction.new("xml-stylesheet", content)
+					root.previous_sibling = pi
+				end
+				rss = Parser.parse(doc.to_s)
+				have_href_xsss = xsss.find_all {|xss| xss.has_key?(:href)}
+				assert_equal(have_href_xsss.size, rss.xml_stylesheets.size)
+				rss.xml_stylesheets.each_with_index do |stylesheet, i|
+					target, = parse_pi(stylesheet.to_s)
+					assert_xml_stylesheet(target, stylesheet, have_href_xsss[i])
+				end
+			end
+		end
+		
+		def parse_pi(pi)
+			/\A\s*<\?(\S+)([^(?:\?>)]+)\?>\s*\z/ =~ pi
+			target = $1
+			dummy = REXML::Document.new("<dummy #{$2}/>").root
+			contents = {}
+			dummy.attributes.each do |name, value|
+				contents[name] = value
+			end
+			[target, contents]
+		end
+		
+	end
+end
diff --git a/test/ruby/test_time.rb b/test/ruby/test_time.rb
new file mode 100644
index 0000000000..dc706653a1
--- /dev/null
+++ b/test/ruby/test_time.rb
@@ -0,0 +1,73 @@
+require 'test/unit'
+
+class TestTime < Test::Unit::TestCase
+  def test_time_add()
+    assert_equal(Time.utc(2000, 3, 21, 3, 30) + 3 * 3600,
+                 Time.utc(2000, 3, 21, 6, 30))
+    assert_equal(Time.utc(2000, 3, 21, 3, 30) + (-3 * 3600),
+                 Time.utc(2000, 3, 21, 0, 30))
+    assert_equal(0, (Time.at(1.1) + 0.9).usec)
+  end
+
+  def test_time_subt()
+    assert_equal(Time.utc(2000, 3, 21, 3, 30) - 3 * 3600,
+                 Time.utc(2000, 3, 21, 0, 30))
+    assert_equal(Time.utc(2000, 3, 21, 3, 30) - (-3 * 3600),
+                 Time.utc(2000, 3, 21, 6, 30))
+    assert_equal(900000, (Time.at(1.1) - 0.2).usec)
+  end
+
+  def test_time_time()
+    assert_equal(Time.utc(2000, 3, 21, 3, 30)  \
+                -Time.utc(2000, 3, 21, 0, 30), 3*3600)
+    assert_equal(Time.utc(2000, 3, 21, 0, 30)  \
+                -Time.utc(2000, 3, 21, 3, 30), -3*3600)
+  end
+
+  def negative_time_t?
+    begin
+      Time.at(-1)
+      true
+    rescue ArgumentError
+      false
+    end
+  end
+
+  def test_timegm
+    if negative_time_t?
+      assert_equal(-0x80000000, Time.utc(1901, 12, 13, 20, 45, 52).tv_sec)
+      assert_equal(-2, Time.utc(1969, 12, 31, 23, 59, 58).tv_sec)
+      assert_equal(-1, Time.utc(1969, 12, 31, 23, 59, 59).tv_sec)
+    end
+
+    assert_equal(0, Time.utc(1970, 1, 1, 0, 0, 0).tv_sec) # the Epoch
+    assert_equal(1, Time.utc(1970, 1, 1, 0, 0, 1).tv_sec)
+    assert_equal(31535999, Time.utc(1970, 12, 31, 23, 59, 59).tv_sec)
+    assert_equal(31536000, Time.utc(1971, 1, 1, 0, 0, 0).tv_sec)
+    assert_equal(78796799, Time.utc(1972, 6, 30, 23, 59, 59).tv_sec)
+
+    # 1972-06-30T23:59:60Z is the first leap second.
+    if Time.utc(1972, 7, 1, 0, 0, 0) - Time.utc(1972, 6, 30, 23, 59, 59) == 1
+      # no leap second.
+      assert_equal(78796800, Time.utc(1972, 7, 1, 0, 0, 0).tv_sec)
+      assert_equal(78796801, Time.utc(1972, 7, 1, 0, 0, 1).tv_sec)
+      assert_equal(946684800, Time.utc(2000, 1, 1, 0, 0, 0).tv_sec)
+      assert_equal(0x7fffffff, Time.utc(2038, 1, 19, 3, 14, 7).tv_sec)
+    else
+      # leap seconds supported.
+      assert_equal(78796800, Time.utc(1972, 6, 30, 23, 59, 60).tv_sec)
+      assert_equal(78796801, Time.utc(1972, 7, 1, 0, 0, 0).tv_sec)
+      assert_equal(78796802, Time.utc(1972, 7, 1, 0, 0, 1).tv_sec)
+      assert_equal(946684822, Time.utc(2000, 1, 1, 0, 0, 0).tv_sec)
+    end
+  end
+
+  def test_huge_difference # [ruby-dev:22619]
+    if negative_time_t?
+      assert_equal(Time.at(-0x80000000), Time.at(0x7fffffff) - 0xffffffff)
+      assert_equal(Time.at(-0x80000000), Time.at(0x7fffffff) + (-0xffffffff))
+      assert_equal(Time.at(0x7fffffff), Time.at(-0x80000000) + 0xffffffff)
+      assert_equal(Time.at(0x7fffffff), Time.at(-0x80000000) - (-0xffffffff))
+    end
+  end
+end