* lib/rss, test/rss:

  - supported Atom.
  - bumped version 0.1.6 to 0.1.7.
* sample/rss/convert.rb: added new sample.


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

33 files changed, 6095 insertions, 1044 deletions

diff --git a/test/rss/rss-assertions.rb b/test/rss/rss-assertions.rb
index c61f74b136..01f68678f0 100644
--- a/test/rss/rss-assertions.rb
+++ b/test/rss/rss-assertions.rb
@@ -1,6 +1,5 @@
 module RSS
   module Assertions
-    
     def assert_parse(rss, assert_method, *args)
       __send__("assert_#{assert_method}", *args) do
         ::RSS::Parser.parse(rss)
@@ -58,13 +57,14 @@ module RSS
       end
     end
     
-    def assert_not_excepted_tag(tag, parent)
+    def assert_not_expected_tag(tag, uri, parent)
       _wrap_assertion do
         begin
           yield
-          flunk("Not raise NotExceptedTagError")
-        rescue ::RSS::NotExceptedTagError => e
+          flunk("Not raise NotExpectedTagError")
+        rescue ::RSS::NotExpectedTagError => e
           assert_equal(tag, e.tag)
+          assert_equal(uri, e.uri)
           assert_equal(parent, e.parent)
         end
       end
@@ -129,10 +129,13 @@ module RSS
     
     def assert_xml_stylesheet_pis(attrs_ary, rss=nil)
       _wrap_assertion do
-        rss ||= ::RSS::RDF.new()
+        if rss.nil?
+          rss = ::RSS::RDF.new
+          setup_rss10(rss)
+        end
         xss_strs = []
         attrs_ary.each do |attrs|
-          xss = ::RSS::XMLStyleSheet.new(*attrs)
+          xss = ::RSS::XMLStyleSheet.new(attrs)
           xss_strs.push(xss.to_s)
           rss.xml_stylesheets.push(xss)
         end
@@ -381,6 +384,648 @@ module RSS
       end
     end
 
+    def assert_atom_person(tag_name, generator)
+      _wrap_assertion do
+        name = "Mark Pilgrim"
+        uri = "http://example.org/"
+        email = "f8dy@example.com"
+
+        assert_parse(generator.call(<<-EOA), :missing_tag, "name", tag_name)
+  <#{tag_name}/>
+EOA
+
+        assert_parse(generator.call(<<-EOA), :missing_tag, "name", tag_name)
+  <#{tag_name}>
+    <uri>#{uri}</uri>
+    <email>#{email}</email>
+  </#{tag_name}>
+EOA
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <#{tag_name}>
+    <name>#{name}</name>
+  </#{tag_name}>
+EOA
+
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <#{tag_name}>
+    <name>#{name}</name>
+    <uri>#{uri}</uri>
+    <email>#{email}</email>
+  </#{tag_name}>
+EOA
+
+        person = yield(feed)
+        assert_not_nil(person)
+        assert_equal(name, person.name.content)
+        assert_equal(uri, person.uri.content)
+        assert_equal(email, person.email.content)
+      end
+    end
+
+    def assert_atom_category(generator)
+      _wrap_assertion do
+        term = "Music"
+        scheme = "http://xmlns.com/wordnet/1.6/"
+        label = "music"
+
+        missing_args = [:missing_attribute, "category", "term"]
+        assert_parse(generator.call(<<-EOA), *missing_args)
+  <category/>
+EOA
+
+        assert_parse(generator.call(<<-EOA), *missing_args)
+  <category scheme="#{scheme}" label="#{label}"/>
+EOA
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <category term="#{term}"/>
+EOA
+
+      feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <category term="#{term}" scheme="#{scheme}" label="#{label}"/>
+EOA
+
+        category = yield(feed)
+        assert_not_nil(category)
+        assert_equal(term, category.term)
+        assert_equal(scheme, category.scheme)
+        assert_equal(label, category.label)
+      end
+    end
+
+    def assert_atom_link(generator)
+      _wrap_assertion do
+        href = "http://example.org/feed.atom"
+        rel = "self"
+        type = "application/atom+xml"
+        hreflang = "en"
+        title = "Atom"
+        length = "1024"
+
+        assert_parse(generator.call(<<-EOA), :missing_attribute, "link", "href")
+  <link/>
+EOA
+
+        assert_parse(generator.call(<<-EOA), :missing_attribute, "link", "href")
+  <link rel="#{rel}" type="#{type}" hreflang="#{hreflang}"
+        title="#{title}" length="#{length}"/>
+EOA
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <link href="#{href}"/>
+EOA
+
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <link href="#{href}" rel="#{rel}" type="#{type}" hreflang="#{hreflang}"
+        title="#{title}" length="#{length}"/>
+EOA
+
+        link = yield(feed)
+        assert_not_nil(link)
+        assert_equal(href, link.href)
+        assert_equal(rel, link.rel)
+        assert_equal(type, link.type)
+        assert_equal(hreflang, link.hreflang)
+        assert_equal(title, link.title)
+        assert_equal(length, link.length)
+
+
+        href = "http://example.org/index.html.ja"
+        parent = link.parent.tag_name
+        return if parent == "source"
+
+        optional_attributes = %w(hreflang="ja" type="text/html")
+        0.upto(optional_attributes.size) do |i|
+          combination(optional_attributes, i).each do |attributes|
+            attrs = attributes.join(" ")
+            assert_parse(generator.call(<<-EOA), :too_much_tag, "link", parent)
+  <link rel="alternate" #{attrs} href="#{href}"/>
+  <link rel="alternate" #{attrs} href="#{href}"/>
+EOA
+          end
+        end
+      end
+    end
+
+    def assert_atom_generator(generator)
+      _wrap_assertion do
+        uri = "http://www.example.com/"
+        version = "1.0"
+        content = "Example Toolkit"
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <generator/>
+EOA
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <generator uri="#{uri}" version="#{version}"/>
+EOA
+
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <generator uri="#{uri}" version="#{version}">#{content}</generator>
+EOA
+
+        gen = yield(feed)
+        assert_not_nil(gen)
+        assert_equal(uri, gen.uri)
+        assert_equal(version, gen.version)
+        assert_equal(content, gen.content)
+      end
+    end
+
+    def assert_atom_icon(generator)
+      _wrap_assertion do
+        content = "http://www.example.com/example.png"
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <icon/>
+EOA
+
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <icon>#{content}</icon>
+EOA
+
+        icon = yield(feed)
+        assert_not_nil(icon)
+        assert_equal(content, icon.content)
+      end
+    end
+
+    def assert_atom_text_construct(tag_name, generator)
+      _wrap_assertion do
+        [nil, "text", "html"].each do |type|
+          attr = ""
+          attr = " type=\"#{type}\""if type
+          assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <#{tag_name}#{attr}/>
+EOA
+        end
+
+        assert_parse(generator.call(<<-EOA), :missing_tag, "div", tag_name)
+  <#{tag_name} type="xhtml"/>
+EOA
+
+        args = ["x", Atom::URI, tag_name]
+        assert_parse(generator.call(<<-EOA), :not_expected_tag, *args)
+  <#{tag_name} type="xhtml"><x/></#{tag_name}>
+EOA
+
+        invalid_value = "invalid"
+        args = ["type", invalid_value]
+        assert_parse(generator.call(<<-EOA), :not_available_value, *args)
+  <#{tag_name} type="#{invalid_value}"/>
+EOA
+
+        [
+         [nil, "A lot of effort went into making this effortless"],
+         ["text", "A lot of effort went into making this effortless"],
+         ["html", "A <em>lot</em> of effort went into making this effortless"],
+        ].each do |type, content|
+          attr = ""
+          attr = " type=\"#{type}\"" if type
+          feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <#{tag_name}#{attr}>#{h content}</#{tag_name}>
+EOA
+
+          element = yield(feed)
+          assert_not_nil(element)
+          assert_equal(type, element.type)
+          assert_equal(content, element.content)
+        end
+
+        [false, true].each do |with_space|
+          xhtml_uri = "http://www.w3.org/1999/xhtml"
+          xhtml_content = "<div xmlns=\"#{xhtml_uri}\">abc</div>"
+          xhtml_element = RSS::XML::Element.new("div", nil, xhtml_uri,
+                                                {"xmlns" => xhtml_uri},
+                                                ["abc"])
+          content = xhtml_content
+          content = "  #{content}  " if with_space
+          feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <#{tag_name} type="xhtml">#{content}</#{tag_name}>
+EOA
+
+          element = yield(feed)
+          assert_not_nil(element)
+          assert_equal("xhtml", element.type)
+          assert_equal(xhtml_content, element.content)
+          assert_equal(xhtml_element, element.xhtml)
+        end
+      end
+    end
+
+    def assert_atom_date_construct(tag_name, generator)
+      _wrap_assertion do
+        args = [tag_name, ""]
+        assert_parse(generator.call(<<-EOR), :not_available_value, *args)
+  <#{tag_name}/>
+EOR
+
+        [
+         ["xxx", false],
+         ["2007", false],
+         ["2007/02/09", true],
+        ].each do |invalid_value, can_parse|
+          assert_not_available_value(tag_name, invalid_value) do
+            RSS::Parser.parse(generator.call(<<-EOR))
+  <#{tag_name}>#{invalid_value}</#{tag_name}>
+EOR
+          end
+
+          feed = RSS::Parser.parse(generator.call(<<-EOR), false)
+  <#{tag_name}>#{invalid_value}</#{tag_name}>
+EOR
+          value = yield(feed).content
+          if can_parse
+            assert_equal(Time.parse(invalid_value), value)
+          else
+            assert_nil(value)
+          end
+        end
+
+        [
+         "2003-12-13T18:30:02Z",
+         "2003-12-13T18:30:02.25Z",
+         "2003-12-13T18:30:02+01:00",
+         "2003-12-13T18:30:02.25+01:00",
+        ].each do |valid_value|
+          assert_parse(generator.call(<<-EOR), :nothing_raised)
+  <#{tag_name}>#{valid_value}</#{tag_name}>
+EOR
+
+          feed = RSS::Parser.parse(generator.call(<<-EOR))
+  <#{tag_name}>#{valid_value}</#{tag_name}>
+EOR
+          assert_equal(Time.parse(valid_value), yield(feed).content)
+        end
+      end
+    end
+
+    def assert_atom_logo(generator)
+      _wrap_assertion do
+        content = "http://www.example.com/example.png"
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <logo/>
+EOA
+
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <logo>#{content}</logo>
+EOA
+
+        logo = yield(feed)
+        assert_not_nil(logo)
+        assert_equal(content, logo.content)
+      end
+    end
+
+    def assert_atom_content(generator, &getter)
+      _wrap_assertion do
+        assert_atom_content_inline_text(generator, &getter)
+        assert_atom_content_inline_xhtml(generator, &getter)
+        assert_atom_content_inline_other(generator, &getter)
+        assert_atom_content_out_of_line(generator, &getter)
+      end
+    end
+
+    def assert_atom_content_inline_text(generator)
+      _wrap_assertion do
+        [nil, "text", "html"].each do |type|
+          content = "<content"
+          content << " type='#{type}'" if type
+
+          suffix = "/>"
+          assert_parse(generator.call(content + suffix), :nothing_raised)
+          suffix = ">xxx</content>"
+          assert_parse(generator.call(content + suffix), :nothing_raised)
+        end
+
+        [
+         ["text", "sample content"],
+         ["text/plain", "sample content"],
+         ["html", "<em>sample</em> content"]
+        ].each do |type, content_content|
+          feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <content type="#{type}">#{h content_content}</content>
+EOA
+          content = yield(feed)
+          assert_equal(type, content.type)
+          if %w(text html).include?(type)
+            assert(content.inline_text?)
+          else
+            assert(!content.inline_text?)
+          end
+          if type == "html"
+            assert(content.inline_html?)
+          else
+            assert(!content.inline_html?)
+          end
+          assert(!content.inline_xhtml?)
+          if type == "text/plain"
+            assert(content.inline_other?)
+            assert(content.inline_other_text?)
+          else
+            assert(!content.inline_other?)
+            assert(!content.inline_other_text?)
+          end
+          assert(!content.inline_other_xml?)
+          assert(!content.inline_other_base64?)
+          assert(!content.out_of_line?)
+          assert(!content.have_xml_content?)
+          assert_equal(content_content, content.content)
+        end
+      end
+    end
+
+    def assert_atom_content_inline_xhtml(generator)
+      _wrap_assertion do
+        args = ["div", "content"]
+        assert_parse(generator.call(<<-EOA), :missing_tag, *args)
+  <content type="xhtml"/>
+EOA
+
+        args = ["x", Atom::URI, "content"]
+        assert_parse(generator.call(<<-EOA), :not_expected_tag, *args)
+  <content type="xhtml"><x/></content>
+EOA
+
+        xhtml_uri = "http://www.w3.org/1999/xhtml"
+        xhtml_content = "<div xmlns=\"#{xhtml_uri}\">abc</div>"
+        xhtml_element = RSS::XML::Element.new("div", nil, xhtml_uri,
+                                              {"xmlns" => xhtml_uri},
+                                              ["abc"])
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <content type="xhtml">#{xhtml_content}</content>
+EOA
+
+        content = yield(feed)
+        assert_not_nil(content)
+        assert_equal("xhtml", content.type)
+        assert(!content.inline_text?)
+        assert(!content.inline_html?)
+        assert(content.inline_xhtml?)
+        assert(!content.inline_other?)
+        assert(!content.inline_other_text?)
+        assert(!content.inline_other_xml?)
+        assert(!content.inline_other_base64?)
+        assert(!content.out_of_line?)
+        assert(content.have_xml_content?)
+        assert_equal(xhtml_content, content.content)
+        assert_equal(xhtml_element, content.xhtml)
+      end
+    end
+
+    def assert_atom_content_inline_other(generator, &getter)
+      _wrap_assertion do
+        assert_atom_content_inline_other_text(generator, &getter)
+        assert_atom_content_inline_other_xml(generator, &getter)
+      end
+    end
+
+    def assert_atom_content_inline_other_text(generator)
+      _wrap_assertion do
+        require "zlib"
+
+        type = "application/zip"
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <content type="#{type}"/>
+EOA
+
+        text = ""
+        char = "a"
+        100.times do |i|
+          text << char
+          char.succ!
+        end
+        base64_content = Base64.encode64(Zlib::Deflate.deflate(text))
+
+        [false, true].each do |with_space|
+          xml_content = base64_content
+          xml_content = "  #{base64_content}" if with_space
+          feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <content type="#{type}">#{xml_content}</content>
+EOA
+
+          content = yield(feed)
+          assert_not_nil(content)
+          assert_equal(type, content.type)
+          assert(!content.inline_text?)
+          assert(!content.inline_html?)
+          assert(!content.inline_xhtml?)
+          assert(content.inline_other?)
+          assert(!content.inline_other_text?)
+          assert(!content.inline_other_xml?)
+          assert(content.inline_other_base64?)
+          assert(!content.out_of_line?)
+          assert(!content.have_xml_content?)
+          assert_equal(text, Zlib::Inflate.inflate(content.content))
+
+          xml = REXML::Document.new(content.to_s).root
+          assert_rexml_element([], {"type" => type}, base64_content, xml)
+        end
+      end
+    end
+
+    def assert_atom_content_inline_other_xml(generator)
+      _wrap_assertion do
+        type = "image/svg+xml"
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <content type="#{type}"/>
+EOA
+
+        svg_uri = "http://www.w3.org/2000/svg"
+        svg_width = "50pt"
+        svg_height = "20pt"
+        svg_version = "1.0"
+        text_x = "15"
+        text_y = "15"
+        text = "text"
+        svg_content = <<-EOS
+<svg
+   xmlns="#{svg_uri}"
+   width="#{svg_width}"
+   height="#{svg_height}"
+   version="#{svg_version}"
+><text x="#{text_x}" y="#{text_y}">#{text}</text
+></svg>
+EOS
+
+        text_element = RSS::XML::Element.new("text", nil, svg_uri,
+                                             {
+                                               "x" => text_x,
+                                               "y" => text_y,
+                                             },
+                                             [text])
+        svg_element = RSS::XML::Element.new("svg", nil, svg_uri,
+                                            {
+                                              "xmlns" => svg_uri,
+                                              "width" => svg_width,
+                                              "height" => svg_height,
+                                              "version" => svg_version,
+                                            },
+                                            [text_element])
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <content type="#{type}">#{svg_content}</content>
+EOA
+
+        content = yield(feed)
+        assert_not_nil(content)
+        assert_equal(type, content.type)
+        assert(!content.inline_text?)
+        assert(!content.inline_html?)
+        assert(!content.inline_xhtml?)
+        assert(content.inline_other?)
+        assert(!content.inline_other_text?)
+        assert(content.inline_other_xml?)
+        assert(!content.inline_other_base64?)
+        assert(!content.out_of_line?)
+        assert(content.have_xml_content?)
+        assert_equal(REXML::Document.new(svg_content).to_s.chomp,
+                     REXML::Document.new(content.content).to_s.chomp)
+        assert_equal(svg_element, content.xml)
+        assert_nil(content.xhtml)
+      end
+    end
+
+    def assert_atom_content_out_of_line(generator)
+      _wrap_assertion do
+        text_type = "text/plain"
+        text_src = "http://example.com/README.txt"
+
+        missing_args = [:missing_attribute, "content", "type"]
+        # RSS Parser raises error even if this is "should" not "must".
+        assert_parse(generator.call(<<-EOA), *missing_args)
+  <content src="#{text_src}"/>
+EOA
+
+        content_content = "xxx"
+        not_available_value_args = [:not_available_value,
+                                    "content", content_content]
+        assert_parse(generator.call(<<-EOA), *not_available_value_args)
+  <content type="#{text_type}" src="#{text_src}">#{content_content}</content>
+EOA
+
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <content type="#{text_type}" src="#{text_src}"/>
+EOA
+        content = yield(feed)
+        assert_not_nil(content)
+        assert_equal(text_type, content.type)
+        assert_equal(text_src, content.src)
+        assert(!content.inline_text?)
+        assert(!content.inline_html?)
+        assert(!content.inline_xhtml?)
+        assert(!content.inline_other?)
+        assert(!content.inline_other_text?)
+        assert(!content.inline_other_xml?)
+        assert(!content.inline_other_base64?)
+        assert(content.out_of_line?)
+        assert(!content.have_xml_content?)
+        assert_nil(content.xml)
+        assert_nil(content.xhtml)
+        assert_equal("", content.content)
+      end
+    end
+
+    def assert_atom_source(generator, &getter)
+      _wrap_assertion do
+        assert_atom_source_author(generator, &getter)
+        assert_atom_source_category(generator, &getter)
+        assert_atom_source_contributor(generator, &getter)
+        assert_atom_source_generator(generator, &getter)
+        assert_atom_source_icon(generator, &getter)
+        assert_atom_source_id(generator, &getter)
+        assert_atom_source_link(generator, &getter)
+        assert_atom_source_logo(generator, &getter)
+        assert_atom_source_rights(generator, &getter)
+        assert_atom_source_subtitle(generator, &getter)
+        assert_atom_source_title(generator, &getter)
+        assert_atom_source_updated(generator, &getter)
+      end
+    end
+
+    def assert_atom_source_author(generator)
+      assert_atom_person("author", generator) do |feed|
+        source = yield(feed)
+        assert_equal(1, source.authors.size)
+        source.author
+      end
+    end
+
+    def assert_atom_source_category(generator)
+      assert_atom_category(generator) do |feed|
+        source = yield(feed)
+        assert_equal(1, source.categories.size)
+        source.category
+      end
+    end
+
+    def assert_atom_source_contributor(generator)
+      assert_atom_person("contributor", generator) do |feed|
+        source = yield(feed)
+        assert_equal(1, source.contributors.size)
+        source.contributor
+      end
+    end
+
+    def assert_atom_source_generator(generator)
+      assert_atom_generator(generator) do |feed|
+        yield(feed).generator
+      end
+    end
+
+    def assert_atom_source_icon(generator)
+      assert_atom_icon(generator) do |feed|
+        yield(feed).icon
+      end
+    end
+
+    def assert_atom_source_id(generator)
+      id_content = "urn:uuid:a2fb588b-5674-4898-b420-265a734fea69"
+      id = "<id>#{id_content}</id>"
+      feed = RSS::Parser.parse(generator.call(id))
+      assert_equal(id_content, yield(feed).id.content)
+    end
+
+    def assert_atom_source_link(generator)
+      assert_atom_link(generator) do |feed|
+        source = yield(feed)
+        assert_equal(1, source.links.size)
+        source.link
+      end
+    end
+
+    def assert_atom_source_logo(generator)
+      assert_atom_logo(generator) do |feed|
+        yield(feed).logo
+      end
+    end
+
+    def assert_atom_source_rights(generator)
+      assert_atom_text_construct("rights", generator) do |feed|
+        yield(feed).rights
+      end
+    end
+
+    def assert_atom_source_subtitle(generator)
+      assert_atom_text_construct("subtitle", generator) do |feed|
+        yield(feed).subtitle
+      end
+    end
+
+    def assert_atom_source_title(generator)
+      assert_atom_text_construct("title", generator) do |feed|
+        yield(feed).title
+      end
+    end
+
+    def assert_atom_source_updated(generator)
+      assert_atom_date_construct("updated", generator) do |feed|
+        yield(feed).updated
+      end
+    end
 
     def assert_dublin_core(elems, target)
       _wrap_assertion do
@@ -479,7 +1124,1531 @@ module RSS
         end
       end
     end
-    
+
+    def assert_rexml_element(children, attrs, text, element, text_type=nil)
+      _wrap_assertion do
+        if children
+          children_info = element.elements.collect {|e| [e.namespace, e.name]}
+          assert_equal(children.collect {|uri, name| [uri, name]}.sort,
+                       children_info.sort)
+        end
+        if attrs
+          assert_equal(attrs.collect {|k, v| [k, v]}.sort,
+                       element.attributes.collect {|k, v| [k, v]}.sort)
+        end
+        case text_type
+        when :time
+          assert_not_nil(element.text)
+          assert_equal(Time.parse(text).to_s, Time.parse(element.text).to_s)
+        else
+          assert_equal(text, element.text)
+        end
+      end
+    end
+
+
+    def assert_atom_person_to_s(target_class)
+      _wrap_assertion do
+        name = "A person"
+        uri = "http://example.com/person/"
+        email = "person@example.com"
+
+        target = target_class.new
+        assert_equal("", target.to_s)
+
+        target = target_class.new
+        person_name = target_class::Name.new
+        person_name.content = name
+        target.name = person_name
+        xml_target = REXML::Document.new(target.to_s).root
+        assert_equal(["name"], xml_target.elements.collect {|e| e.name})
+        assert_equal([name], xml_target.elements.collect {|e| e.text})
+
+        person_uri = target_class::Uri.new
+        person_uri.content = uri
+        target.uri = person_uri
+        xml_target = REXML::Document.new(target.to_s).root
+        assert_equal(["name", "uri"], xml_target.elements.collect {|e| e.name})
+        assert_equal([name, uri], xml_target.elements.collect {|e| e.text})
+
+        person_email = target_class::Email.new
+        person_email.content = email
+        target.email = person_email
+        xml_target = REXML::Document.new(target.to_s).root
+        assert_equal(["name", "uri", "email"],
+                     xml_target.elements.collect {|e| e.name})
+        assert_equal([name, uri, email],
+                     xml_target.elements.collect {|e| e.text})
+      end
+    end
+
+    def assert_atom_category_to_s(target_class)
+      _wrap_assertion do
+        term = "music"
+        scheme = "http://example.com/music"
+        label = "Music"
+
+        category = target_class.new
+        assert_equal("", category.to_s)
+
+        category = target_class.new
+        category.scheme = scheme
+        assert_equal("", category.to_s)
+
+        category = target_class.new
+        category.label = label
+        assert_equal("", category.to_s)
+
+        category = target_class.new
+        category.scheme = scheme
+        category.label = label
+        assert_equal("", category.to_s)
+
+        category = target_class.new
+        category.term = term
+        xml = REXML::Document.new(category.to_s).root
+        assert_rexml_element([], {"term" => term}, nil, xml)
+
+        category = target_class.new
+        category.term = term
+        category.scheme = scheme
+        xml = REXML::Document.new(category.to_s).root
+        assert_rexml_element([], {"term" => term, "scheme" => scheme}, nil, xml)
+
+        category = target_class.new
+        category.term = term
+        category.label = label
+        xml = REXML::Document.new(category.to_s).root
+        assert_rexml_element([], {"term" => term, "label" => label}, nil, xml)
+
+        category = target_class.new
+        category.term = term
+        category.scheme = scheme
+        category.label = label
+        xml = REXML::Document.new(category.to_s).root
+        attrs = {"term" => term, "scheme" => scheme, "label" => label}
+        assert_rexml_element([], attrs, nil, xml)
+      end
+    end
+
+    def assert_atom_generator_to_s(target_class)
+      _wrap_assertion do
+        content = "Feed generator"
+        uri = "http://example.com/generator"
+        version = "0.0.1"
+
+        generator = target_class.new
+        assert_equal("", generator.to_s)
+
+        generator = target_class.new
+        generator.uri = uri
+        assert_equal("", generator.to_s)
+
+        generator = target_class.new
+        generator.version = version
+        assert_equal("", generator.to_s)
+
+        generator = target_class.new
+        generator.uri = uri
+        generator.version = version
+        assert_equal("", generator.to_s)
+
+        generator = target_class.new
+        generator.content = content
+        xml = REXML::Document.new(generator.to_s).root
+        assert_rexml_element([], {}, content, xml)
+
+        generator = target_class.new
+        generator.content = content
+        generator.uri = uri
+        xml = REXML::Document.new(generator.to_s).root
+        assert_rexml_element([], {"uri" => uri}, content, xml)
+
+        generator = target_class.new
+        generator.content = content
+        generator.version = version
+        xml = REXML::Document.new(generator.to_s).root
+        assert_rexml_element([], {"version" => version}, content, xml)
+
+        generator = target_class.new
+        generator.content = content
+        generator.uri = uri
+        generator.version = version
+        xml = REXML::Document.new(generator.to_s).root
+        assert_rexml_element([], {"uri" => uri, "version" => version},
+                             content, xml)
+      end
+    end
+
+    def assert_atom_icon_to_s(target_class)
+      _wrap_assertion do
+        content = "http://example.com/icon.png"
+
+        icon = target_class.new
+        assert_equal("", icon.to_s)
+
+        icon = target_class.new
+        icon.content = content
+        xml = REXML::Document.new(icon.to_s).root
+        assert_rexml_element([], {}, content, xml)
+      end
+    end
+
+    def assert_atom_id_to_s(target_class)
+      _wrap_assertion do
+        content = "http://example.com/1"
+
+        id = target_class.new
+        assert_equal("", id.to_s)
+
+        id = target_class.new
+        id.content = content
+        xml = REXML::Document.new(id.to_s).root
+        assert_rexml_element([], {}, content, xml)
+      end
+    end
+
+    def assert_atom_link_to_s(target_class)
+      _wrap_assertion do
+        href = "http://example.com/atom.xml"
+        rel = "self"
+        type = "application/atom+xml"
+        hreflang = "ja"
+        title = "Atom Feed"
+        length = "801"
+
+        link = target_class.new
+        assert_equal("", link.to_s)
+
+        link = target_class.new
+        link.href = href
+        xml = REXML::Document.new(link.to_s).root
+        assert_rexml_element([], {"href" => href}, nil, xml)
+
+        optional_arguments = %w(rel type hreflang title length)
+        optional_arguments.each do |name|
+          rest = optional_arguments.reject {|x| x == name}
+
+          link = target_class.new
+          link.__send__("#{name}=", eval(name))
+          assert_equal("", link.to_s)
+
+          rest.each do |n|
+            link.__send__("#{n}=", eval(n))
+            assert_equal("", link.to_s)
+          end
+
+          link = target_class.new
+          link.href = href
+          link.__send__("#{name}=", eval(name))
+          attrs = [["href", href], [name, eval(name)]]
+          xml = REXML::Document.new(link.to_s).root
+          assert_rexml_element([], attrs, nil, xml)
+
+          rest.each do |n|
+            link.__send__("#{n}=", eval(n))
+            attrs << [n, eval(n)]
+            xml = REXML::Document.new(link.to_s).root
+            assert_rexml_element([], attrs, nil, xml)
+          end
+        end
+      end
+    end
+
+    def assert_atom_logo_to_s(target_class)
+      _wrap_assertion do
+        content = "http://example.com/logo.png"
+
+        logo = target_class.new
+        assert_equal("", logo.to_s)
+
+        logo = target_class.new
+        logo.content = content
+        xml = REXML::Document.new(logo.to_s).root
+        assert_rexml_element([], {}, content, xml)
+      end
+    end
+
+    def assert_atom_text_construct_to_s(target_class)
+      _wrap_assertion do
+        text_content = "plain text"
+        html_content = "<em>#{text_content}</em>"
+        xhtml_uri = "http://www.w3.org/1999/xhtml"
+        xhtml_em = RSS::XML::Element.new("em", nil, xhtml_uri, {}, text_content)
+        xhtml_content = RSS::XML::Element.new("div", nil, xhtml_uri,
+                                              {"xmlns" => xhtml_uri},
+                                              [xhtml_em])
+
+        text = target_class.new
+        assert_equal("", text.to_s)
+
+        text = target_class.new
+        text.type = "text"
+        assert_equal("", text.to_s)
+
+        text = target_class.new
+        text.content = text_content
+        xml = REXML::Document.new(text.to_s).root
+        assert_rexml_element([], {}, text_content, xml)
+
+        text = target_class.new
+        text.type = "text"
+        text.content = text_content
+        xml = REXML::Document.new(text.to_s).root
+        assert_rexml_element([], {"type" => "text"}, text_content, xml)
+
+        text = target_class.new
+        text.type = "html"
+        text.content = html_content
+        xml = REXML::Document.new(text.to_s).root
+        assert_rexml_element([], {"type" => "html"}, html_content, xml)
+
+        text = target_class.new
+        text.type = "xhtml"
+        text.content = xhtml_content
+        assert_equal("", text.to_s)
+
+        text = target_class.new
+        text.type = "xhtml"
+        text.__send__(target_class.xml_setter, xhtml_content)
+        xml = REXML::Document.new(text.to_s).root
+        assert_rexml_element([[xhtml_uri, "div"]], {"type" => "xhtml"},
+                             nil, xml)
+        assert_rexml_element([[xhtml_uri, "em"]], nil, nil, xml.elements[1])
+        assert_rexml_element([], {}, text_content, xml.elements[1].elements[1])
+
+        text = target_class.new
+        text.type = "xhtml"
+        text.__send__(target_class.xml_setter, xhtml_em)
+        xml = REXML::Document.new(text.to_s).root
+        assert_rexml_element([[xhtml_uri, "div"]], {"type" => "xhtml"},
+                             nil, xml)
+        assert_rexml_element([[xhtml_uri, "em"]], nil, nil, xml.elements[1])
+        assert_rexml_element([], {}, text_content, xml.elements[1].elements[1])
+      end
+    end
+
+    def assert_atom_date_construct_to_s(target_class)
+      _wrap_assertion do
+        date = target_class.new
+        assert_equal("", date.to_s)
+
+        [
+         "2003-12-13T18:30:02Z",
+         "2003-12-13T18:30:02.25Z",
+         "2003-12-13T18:30:02+01:00",
+         "2003-12-13T18:30:02.25+01:00",
+        ].each do |content|
+          date = target_class.new
+          date.content = content
+          xml = REXML::Document.new(date.to_s).root
+          assert_rexml_element([], {}, content, xml, :time)
+
+          date = target_class.new
+          date.content = Time.parse(content)
+          xml = REXML::Document.new(date.to_s).root
+          assert_rexml_element([], {}, content, xml, :time)
+        end
+      end
+    end
+
+    def assert_atom_content_to_s(target_class)
+      _wrap_assertion do
+        assert_atom_text_construct_to_s(target_class)
+        assert_atom_content_inline_other_xml_to_s(target_class)
+        assert_atom_content_inline_other_text_to_s(target_class)
+        assert_atom_content_inline_other_base64_to_s(target_class)
+        assert_atom_content_out_of_line_to_s(target_class)
+      end
+    end
+
+    def assert_atom_content_inline_other_xml_to_s(target_class)
+      _wrap_assertion do
+        content = target_class.new
+        content.type = "text/xml"
+        assert_equal("", content.to_s)
+
+        content = target_class.new
+        content.type = "text/xml"
+        content.xml = RSS::XML::Element.new("em")
+        xml = REXML::Document.new(content.to_s).root
+        assert_rexml_element([["", "em"]], {"type" => "text/xml"}, nil, xml)
+      end
+    end
+
+    def assert_atom_content_inline_other_text_to_s(target_class)
+      _wrap_assertion do
+        content = target_class.new
+        content.type = "text/plain"
+        assert_equal("", content.to_s)
+
+        content = target_class.new
+        content.type = "text/plain"
+        content.xml = RSS::XML::Element.new("em")
+        assert_equal("", content.to_s)
+
+        content = target_class.new
+        content.type = "text/plain"
+        content.content = "content"
+        xml = REXML::Document.new(content.to_s).root
+        assert_rexml_element([], {"type" => "text/plain"}, "content", xml)
+      end
+    end
+
+    def assert_atom_content_inline_other_base64_to_s(target_class)
+      _wrap_assertion do
+        require "zlib"
+
+        text = ""
+        char = "a"
+        100.times do |i|
+          text << char
+          char.succ!
+        end
+
+        type = "application/zip"
+        original_content = Zlib::Deflate.deflate(text)
+
+        content = target_class.new
+        content.type = type
+        content.content = original_content
+        xml = REXML::Document.new(content.to_s).root
+        assert_rexml_element([], {"type" => type},
+                             Base64.encode64(original_content), xml)
+      end
+    end
+
+    def assert_atom_content_out_of_line_to_s(target_class)
+      _wrap_assertion do
+        type = "application/zip"
+        src = "http://example.com/xxx.zip"
+
+        content = target_class.new
+        assert(!content.out_of_line?)
+        content.src = src
+        assert(content.out_of_line?)
+        xml = REXML::Document.new(content.to_s).root
+        assert_rexml_element([], {"src" => src}, nil, xml)
+
+        content = target_class.new
+        assert(!content.out_of_line?)
+        content.type = type
+        assert(!content.out_of_line?)
+        content.src = src
+        assert(content.out_of_line?)
+        xml = REXML::Document.new(content.to_s).root
+        assert_rexml_element([], {"type" => type, "src" => src}, nil, xml)
+      end
+    end
+
+    def _assert_maker_atom_persons(feed_type, maker_readers, feed_readers)
+      _wrap_assertion do
+        persons = []
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+          targets.each do |target|
+            person = {
+              :name => target.name,
+              :uri => target.uri,
+              :email => target.email,
+            }
+            persons << person if person[:name]
+          end
+        end
+
+        actual_persons = chain_reader(feed, feed_readers) || []
+        actual_persons = actual_persons.collect do |person|
+          {
+            :name => person.name ? person.name.content : nil,
+            :uri => person.uri ? person.uri.content : nil,
+            :email => person.email ? person.email.content : nil,
+          }
+        end
+        p [feed_readers, feed.source.authors] unless persons == actual_persons
+        assert_equal(persons, actual_persons)
+      end
+    end
+
+    def assert_maker_atom_persons(feed_type, maker_readers, feed_readers,
+                                  not_set_error_name=nil,
+                                  parent_not_set_error_name=nil,
+                                  parent_not_set_variable=nil)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        args = [feed_type, maker_readers, feed_readers]
+        if parent_not_set_error_name or parent_not_set_variable
+          assert_not_set_error(parent_not_set_error_name,
+                               parent_not_set_variable) do
+            _assert_maker_atom_persons(*args) do |maker|
+              yield maker
+            end
+          end
+        else
+          _assert_maker_atom_persons(*args) do |maker|
+            yield maker
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(name)) do
+          _assert_maker_atom_persons(feed_type, maker_readers,
+                                     feed_readers) do |maker|
+            yield maker
+            targets = chain_reader(maker, maker_readers)
+            target = targets.new_child
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(name)) do
+          _assert_maker_atom_persons(feed_type, maker_readers,
+                                     feed_readers) do |maker|
+            yield maker
+            targets = chain_reader(maker, maker_readers)
+            target = targets.new_child
+            target.uri = "http://example.com/~me/"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(name)) do
+          _assert_maker_atom_persons(feed_type, maker_readers,
+                                     feed_readers) do |maker|
+            yield maker
+            targets = chain_reader(maker, maker_readers)
+            target = targets.new_child
+            target.email = "me@example.com"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(name)) do
+          _assert_maker_atom_persons(feed_type, maker_readers,
+                                     feed_readers) do |maker|
+            yield maker
+            targets = chain_reader(maker, maker_readers)
+            target = targets.new_child
+            target.uri = "http://example.com/~me/"
+            target.email = "me@example.com"
+          end
+        end
+
+        _assert_maker_atom_persons(feed_type, maker_readers,
+                                   feed_readers) do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+          target = targets.new_child
+          target.name = "me"
+        end
+
+        _assert_maker_atom_persons(feed_type, maker_readers,
+                                   feed_readers) do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+          target = targets.new_child
+          target.name = "me"
+          target.uri = "http://example.com/~me/"
+        end
+
+        _assert_maker_atom_persons(feed_type, maker_readers,
+                                   feed_readers) do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+          target = targets.new_child
+          target.name = "me"
+          target.email = "me@example.com"
+        end
+
+        _assert_maker_atom_persons(feed_type, maker_readers,
+                                   feed_readers) do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+          target = targets.new_child
+          target.name = "me"
+          target.uri = "http://example.com/~me/"
+          target.email = "me@example.com"
+        end
+
+        _assert_maker_atom_persons(feed_type, maker_readers,
+                                   feed_readers) do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+
+          target = targets.new_child
+          target.name = "me"
+          target.uri = "http://example.com/~me/"
+          target.email = "me@example.com"
+
+          target = targets.new_child
+          target.name = "you"
+          target.uri = "http://example.com/~you/"
+          target.email = "you@example.com"
+        end
+
+        assert_not_set_error(not_set_error_name, %w(name)) do
+          _assert_maker_atom_persons(feed_type, maker_readers,
+                                     feed_readers) do |maker|
+            yield maker
+            targets = chain_reader(maker, maker_readers)
+
+            target = targets.new_child
+            target.name = "me"
+            target.uri = "http://example.com/~me/"
+            target.email = "me@example.com"
+
+            target = targets.new_child
+          end
+        end
+      end
+    end
+
+    def _assert_maker_atom_text_construct(feed_type, maker_readers,
+                                          feed_readers, &block)
+      maker_extractor = Proc.new do |target|
+        text = {
+          :type => target.type,
+          :content => target.content,
+          :xml_content => target.xml_content,
+        }
+        if text[:type] == "xhtml"
+          if text[:xml_content]
+            xml_content = text[:xml_content]
+            xhtml_uri = "http://www.w3.org/1999/xhtml"
+            unless xml_content.is_a?(RSS::XML::Element) and
+                ["div", xhtml_uri] == [xml_content.name, xml_content.uri]
+              children = xml_content
+              children = [children] unless children.is_a?(Array)
+              xml_content = RSS::XML::Element.new("div", nil, xhtml_uri,
+                                                  {"xmlns" => xhtml_uri},
+                                                  children)
+              text[:xml_content] = xml_content
+            end
+            text
+          else
+            nil
+          end
+        else
+          text[:content] ? text : nil
+        end
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :type => target.type,
+          :content => target.content,
+          :xml_content => target.xhtml,
+        }
+      end
+      _assert_maker_atom_element(feed_type, maker_readers, feed_readers,
+                                 maker_extractor, feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_text_construct(feed_type, maker_readers, feed_readers,
+                                         parent_not_set_error_name=nil,
+                                         parent_not_set_variable=nil,
+                                         not_set_error_name=nil)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        args = [feed_type, maker_readers, feed_readers]
+        if parent_not_set_error_name or parent_not_set_variable
+          assert_not_set_error(parent_not_set_error_name,
+                               parent_not_set_variable) do
+            _assert_maker_atom_text_construct(*args) do |maker|
+              yield maker
+            end
+          end
+        else
+          _assert_maker_atom_text_construct(*args) do |maker|
+            yield maker
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(content)) do
+          _assert_maker_atom_text_construct(*args) do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "text"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(content)) do
+          _assert_maker_atom_text_construct(*args) do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "html"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(xml_content)) do
+          _assert_maker_atom_text_construct(*args) do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "xhtml"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(xml_content)) do
+          _assert_maker_atom_text_construct(*args) do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "xhtml"
+            target.content = "Content"
+          end
+        end
+
+        _assert_maker_atom_text_construct(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "text"
+          target.content = "Content"
+        end
+
+        _assert_maker_atom_text_construct(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "html"
+          target.content = "<em>Content</em>"
+        end
+
+        _assert_maker_atom_text_construct(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml_content = "text only"
+        end
+
+        _assert_maker_atom_text_construct(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml_content = RSS::XML::Element.new("unknown")
+        end
+      end
+    end
+
+    def _assert_maker_atom_date_construct(feed_type, maker_readers,
+                                          feed_readers, &block)
+      maker_extractor = Proc.new do |target|
+        date = {
+          :content => target,
+        }
+        date[:content] ? date : nil
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :content => target.content,
+        }
+      end
+      _assert_maker_atom_element(feed_type, maker_readers, feed_readers,
+                                 maker_extractor, feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_date_construct(feed_type, maker_readers, feed_readers,
+                                         parent_not_set_error_name=nil,
+                                         parent_not_set_variable=nil)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        if parent_not_set_error_name or parent_not_set_variable
+          assert_not_set_error(parent_not_set_error_name,
+                               parent_not_set_variable) do
+            _assert_maker_atom_date_construct(*args) do |maker|
+              yield maker
+            end
+          end
+        else
+          _assert_maker_atom_date_construct(*args) do |maker|
+            yield maker
+          end
+        end
+
+        maker_readers = maker_readers.dup
+        writer = "#{maker_readers.pop}="
+        _assert_maker_atom_date_construct(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.__send__(writer, Time.now)
+        end
+      end
+    end
+
+    def _assert_maker_atom_element(feed_type, maker_readers, feed_readers,
+                                   maker_extractor, feed_extractor)
+      _wrap_assertion do
+        element = nil
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          element = maker_extractor.call(target)
+        end
+
+        target = chain_reader(feed, feed_readers)
+        if target
+          actual_element = feed_extractor.call(target)
+        else
+          actual_element = nil
+        end
+        assert_equal(element, actual_element)
+      end
+    end
+
+    def _assert_maker_atom_elements(feed_type, maker_readers, feed_readers,
+                                    maker_extractor, feed_extractor,
+                                    invalid_feed_checker=nil)
+      _wrap_assertion do
+        elements = []
+        invalid_feed = false
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+          targets.each do |target|
+            element = maker_extractor.call(target)
+            elements << element if element
+          end
+          if invalid_feed_checker
+            invalid_feed = invalid_feed_checker.call(targets)
+          end
+        end
+
+        if invalid_feed
+          assert_nil(feed)
+        else
+          actual_elements = chain_reader(feed, feed_readers) || []
+          actual_elements = actual_elements.collect do |target|
+            feed_extractor.call(target)
+          end
+          assert_equal(elements, actual_elements)
+        end
+      end
+    end
+
+    def assert_maker_atom_element(feed_type, maker_readers, feed_readers,
+                                  setup_target, optional_variables,
+                                  required_variable, assert_method_name,
+                                  not_set_error_name=nil,
+                                  *additional_args)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        0.upto(optional_variables.size) do |i|
+          combination(optional_variables, i).each do |names|
+            have = {}
+            names.each do |name|
+              have[name.intern] = true
+            end
+            have_required_variable_too =
+              have.merge({required_variable.intern => true})
+
+            assert_not_set_error(not_set_error_name, [required_variable]) do
+              __send__(assert_method_name, feed_type, maker_readers,
+                       feed_readers, *additional_args) do |maker|
+                yield maker
+                target = chain_reader(maker, maker_readers)
+                setup_target.call(target, have)
+              end
+            end
+
+            __send__(assert_method_name, feed_type, maker_readers, feed_readers,
+                     *additional_args) do |maker|
+              yield maker
+              target = chain_reader(maker, maker_readers)
+              setup_target.call(target, have_required_variable_too)
+            end
+          end
+        end
+      end
+    end
+
+    def assert_maker_atom_elements(feed_type, maker_readers, feed_readers,
+                                   setup_target, optional_variables,
+                                   required_variable, assert_method_name,
+                                   not_set_error_name=nil,
+                                   *additional_args)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        0.upto(optional_variables.size) do |i|
+          combination(optional_variables, i).each do |names|
+            have = {}
+            names.each do |name|
+              have[name.intern] = true
+            end
+            have_required_variable_too =
+              have.merge({required_variable.intern => true})
+
+            assert_not_set_error(not_set_error_name, [required_variable]) do
+              __send__(assert_method_name, feed_type, maker_readers,
+                       feed_readers, *additional_args) do |maker|
+                yield maker
+                targets = chain_reader(maker, maker_readers)
+                setup_target.call(targets, have)
+              end
+            end
+
+            __send__(assert_method_name, feed_type, maker_readers, feed_readers,
+                     *additional_args) do |maker|
+              yield maker
+              targets = chain_reader(maker, maker_readers)
+              setup_target.call(targets, have_required_variable_too)
+            end
+
+            __send__(assert_method_name, feed_type, maker_readers, feed_readers,
+                     *additional_args) do |maker|
+              yield maker
+              targets = chain_reader(maker, maker_readers)
+              setup_target.call(targets, have_required_variable_too)
+              setup_target.call(targets, have_required_variable_too)
+            end
+
+            assert_not_set_error(not_set_error_name, [required_variable]) do
+            __send__(assert_method_name, feed_type, maker_readers, feed_readers,
+                     *additional_args) do |maker|
+                yield maker
+                targets = chain_reader(maker, maker_readers)
+                setup_target.call(targets, have_required_variable_too)
+                setup_target.call(targets, have)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def _assert_maker_atom_categories(feed_type, maker_readers,
+                                      feed_readers, &block)
+      maker_extractor = Proc.new do |target|
+        category = {
+          :term => target.term,
+          :scheme => target.scheme,
+          :label => target.label,
+        }
+        category[:term] ? category : nil
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :term => target.term,
+          :scheme => target.scheme,
+          :label => target.label,
+        }
+      end
+      _assert_maker_atom_elements(feed_type, maker_readers, feed_readers,
+                                  maker_extractor, feed_extractor, &block)
+    end
+
+    def assert_maker_atom_categories(feed_type, maker_readers, feed_readers,
+                                     not_set_error_name=nil, &block)
+      _wrap_assertion do
+        _assert_maker_atom_categories(feed_type, maker_readers,
+                                      feed_readers) do |maker|
+          yield maker
+        end
+
+        setup_target = Proc.new do |targets, have|
+          target = targets.new_child
+          target.term = "music" if have[:term]
+          target.scheme = "http://example.com/category/music" if have[:scheme]
+          target.label = "Music" if have[:label]
+        end
+
+        optional_variables = %w(scheme label)
+
+        assert_maker_atom_elements(feed_type, maker_readers, feed_readers,
+                                   setup_target, optional_variables,
+                                   "term", :_assert_maker_atom_categories,
+                                   not_set_error_name, &block)
+      end
+    end
+
+    def _assert_maker_atom_generator(feed_type, maker_readers,
+                                     feed_readers, &block)
+      maker_extractor = Proc.new do |target|
+        generator = {
+          :uri => target.uri,
+          :version => target.version,
+          :content => target.content,
+        }
+        generator[:content] ? generator : nil
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :uri => target.uri,
+          :version => target.version,
+          :content => target.content,
+        }
+      end
+      _assert_maker_atom_element(feed_type, maker_readers, feed_readers,
+                                 maker_extractor, feed_extractor,
+                                 &block)
+     end
+
+    def assert_maker_atom_generator(feed_type, maker_readers, feed_readers,
+                                    not_set_error_name=nil, &block)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        _assert_maker_atom_generator(feed_type, maker_readers,
+                                     feed_readers) do |maker|
+          yield maker
+        end
+
+        setup_target = Proc.new do |target, have|
+          target.content = "RSS Maker" if have[:content]
+          target.uri = "http://example.com/rss/maker" if have[:uri]
+          target.version = "0.0.1" if have[:version]
+        end
+
+        optional_variables = %w(uri version)
+
+        assert_maker_atom_element(feed_type, maker_readers, feed_readers,
+                                  setup_target, optional_variables,
+                                  "content", :_assert_maker_atom_generator,
+                                  not_set_error_name, &block)
+      end
+    end
+
+    def _assert_maker_atom_icon(feed_type, maker_readers, feed_readers,
+                                accessor_base, &block)
+      maker_extractor = Proc.new do |target|
+        icon = {
+          :content => target.__send__(accessor_base),
+        }
+        icon[:content] ? icon : nil
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :content => target.content,
+        }
+      end
+      _assert_maker_atom_element(feed_type, maker_readers, feed_readers,
+                                 maker_extractor, feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_icon(feed_type, maker_readers, feed_readers,
+                               accessor_base=nil, not_set_error_name=nil)
+      _wrap_assertion do
+        accessor_base ||= "url"
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        _assert_maker_atom_icon(feed_type, maker_readers, feed_readers,
+                                accessor_base) do |maker|
+          yield maker
+        end
+
+        _assert_maker_atom_icon(feed_type, maker_readers, feed_readers,
+                                accessor_base) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.__send__("#{accessor_base}=", "http://example.com/icon.png")
+        end
+      end
+    end
+
+    def _assert_maker_atom_links(feed_type, maker_readers, feed_readers,
+                                 allow_duplication=false, &block)
+      maker_extractor = Proc.new do |target|
+        link = {
+          :href => target.href,
+          :rel => target.rel,
+          :type => target.type,
+          :hreflang => target.hreflang,
+          :title => target.title,
+          :length => target.length,
+        }
+        link[:href] ? link : nil
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :href => target.href,
+          :rel => target.rel,
+          :type => target.type,
+          :hreflang => target.hreflang,
+          :title => target.title,
+          :length => target.length,
+        }
+      end
+      invalid_feed_checker = Proc.new do |targets|
+        infos = {}
+        invalid = false
+        targets.each do |target|
+          key = [target.hreflang, target.type]
+          if infos.has_key?(key)
+            invalid = true
+            break
+          end
+          infos[key] = true if target.rel.nil? or target.rel == "alternate"
+        end
+        invalid
+      end
+      invalid_feed_checker = nil if allow_duplication
+      _assert_maker_atom_elements(feed_type, maker_readers, feed_readers,
+                                  maker_extractor, feed_extractor,
+                                  invalid_feed_checker,
+                                  &block)
+    end
+
+    def assert_maker_atom_links(feed_type, maker_readers, feed_readers,
+                                not_set_error_name=nil, allow_duplication=false,
+                                &block)
+      _wrap_assertion do
+        _assert_maker_atom_links(feed_type, maker_readers,
+                                 feed_readers) do |maker|
+          yield maker
+        end
+
+        langs = %(ja en fr zh po)
+        setup_target = Proc.new do |targets, have|
+          target = targets.new_child
+          lang = langs[targets.size % langs.size]
+          target.href = "http://example.com/index.html.#{lang}" if have[:href]
+          target.rel = "alternate" if have[:rel]
+          target.type = "text/xhtml" if have[:type]
+          target.hreflang = lang if have[:hreflang]
+          target.title = "FrontPage(#{lang})" if have[:title]
+          target.length = 1024 if have[:length]
+        end
+
+        optional_variables = %w(rel type hreflang title length)
+
+        assert_maker_atom_elements(feed_type, maker_readers, feed_readers,
+                                   setup_target, optional_variables,
+                                   "href", :_assert_maker_atom_links,
+                                   not_set_error_name, allow_duplication,
+                                   &block)
+      end
+    end
+
+    def _assert_maker_atom_logo(feed_type, maker_readers, feed_readers,
+                                accessor_base, &block)
+      maker_extractor = Proc.new do |target|
+        logo = {
+          :uri => target.__send__(accessor_base),
+        }
+        logo[:uri] ? logo : nil
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :uri => target.content,
+        }
+      end
+      _assert_maker_atom_element(feed_type, maker_readers, feed_readers,
+                                 maker_extractor, feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_logo(feed_type, maker_readers, feed_readers,
+                               accessor_base=nil, not_set_error_name=nil)
+      _wrap_assertion do
+        accessor_base ||= "uri"
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        _assert_maker_atom_logo(feed_type, maker_readers, feed_readers,
+                                accessor_base) do |maker|
+          yield maker
+        end
+
+        _assert_maker_atom_logo(feed_type, maker_readers, feed_readers,
+                                accessor_base) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.__send__("#{accessor_base}=", "http://example.com/logo.png")
+        end
+      end
+    end
+
+    def _assert_maker_atom_id(feed_type, maker_readers, feed_readers, &block)
+      maker_extractor = Proc.new do |target|
+        id = {
+          :uri => target.id,
+        }
+        id[:uri] ? id : nil
+      end
+      feed_extractor = Proc.new do |target|
+        if target.id
+          {
+            :uri => target.id.content,
+          }
+        else
+          nil
+        end
+      end
+      _assert_maker_atom_element(feed_type, maker_readers, feed_readers,
+                                 maker_extractor, feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_id(feed_type, maker_readers, feed_readers,
+                             not_set_error_name=nil)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        args = [feed_type, maker_readers, feed_readers]
+        _assert_maker_atom_id(*args) do |maker|
+          yield maker
+        end
+
+        _assert_maker_atom_id(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.id = "http://example.com/id/1"
+        end
+      end
+    end
+
+    def _assert_maker_atom_content(feed_type, maker_readers,
+                                   feed_readers, &block)
+      maker_extractor = Proc.new do |target|
+        content = {
+          :type => target.type,
+          :src => target.src,
+          :content => target.content,
+          :xml => target.xml,
+          :inline_text => target.__send!(:inline_text?),
+          :inline_html => target.__send!(:inline_html?),
+          :inline_xhtml => target.__send!(:inline_xhtml?),
+          :inline_other => target.__send!(:inline_other?),
+          :inline_other_text => target.__send!(:inline_other_text?),
+          :inline_other_xml => target.__send!(:inline_other_xml?),
+          :inline_other_base64 => target.__send!(:inline_other_base64?),
+          :out_of_line => target.__send!(:out_of_line?),
+        }
+        content[:src] = nil if content[:src] and content[:content]
+        if content[:type] or content[:content]
+          content
+        else
+          nil
+        end
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :type => target.type,
+          :src => target.src,
+          :content => target.content,
+          :xml => target.xml,
+          :inline_text => target.inline_text?,
+          :inline_html => target.inline_html?,
+          :inline_xhtml => target.inline_xhtml?,
+          :inline_other => target.inline_other?,
+          :inline_other_text => target.inline_other_text?,
+          :inline_other_xml => target.inline_other_xml?,
+          :inline_other_base64 => target.inline_other_base64?,
+          :out_of_line => target.out_of_line?,
+        }
+      end
+      _assert_maker_atom_element(feed_type, maker_readers, feed_readers,
+                                 maker_extractor, feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_content(feed_type, maker_readers, feed_readers,
+                                  not_set_error_name=nil, &block)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+        args = [feed_type, maker_readers, feed_readers, not_set_error_name]
+        assert_maker_atom_content_inline_text(*args, &block)
+        assert_maker_atom_content_inline_xhtml(*args, &block)
+        assert_maker_atom_content_inline_other(*args, &block)
+        assert_maker_atom_content_out_of_line(*args, &block)
+      end
+    end
+
+    def assert_maker_atom_content_inline_text(feed_type, maker_readers,
+                                              feed_readers, not_set_error_name)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+        end
+
+        assert_not_set_error(not_set_error_name, %w(content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "text"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "html"
+          end
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.content = ""
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "text"
+          target.content = "example content"
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "html"
+          target.content = "<em>text</em>"
+        end
+      end
+    end
+
+    def assert_maker_atom_content_inline_xhtml(feed_type, maker_readers,
+                                               feed_readers, not_set_error_name)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        assert_not_set_error(not_set_error_name, %w(xml_content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "xhtml"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(xml_content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "xhtml"
+            target.content = "dummy"
+          end
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml_content = "text"
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml = "text"
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml_content =
+            RSS::XML::Element.new("em", nil, nil, {}, ["text"])
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml = RSS::XML::Element.new("em", nil, nil, {}, ["text"])
+        end
+
+
+        xhtml_uri = "http://www.w3.org/1999/xhtml"
+        em = RSS::XML::Element.new("em", nil, nil, {}, ["text"])
+        em_with_xhtml_uri =
+          RSS::XML::Element.new("em", nil, xhtml_uri, {}, ["text"])
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml = em
+        end
+        assert_equal(RSS::XML::Element.new("div", nil, xhtml_uri,
+                                           {"xmlns" => xhtml_uri},
+                                           [em_with_xhtml_uri]),
+                     chain_reader(feed, feed_readers).xml)
+
+        div = RSS::XML::Element.new("div", nil, xhtml_uri,
+                                    {"xmlns" => xhtml_uri,
+                                     "class" => "sample"},
+                                    ["text"])
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml = div
+        end
+        assert_equal(div, chain_reader(feed, feed_readers).xml)
+      end
+    end
+
+    def assert_maker_atom_content_inline_other(*args, &block)
+      _wrap_assertion do
+        assert_maker_atom_content_inline_other_xml(*args, &block)
+        assert_maker_atom_content_inline_other_text(*args, &block)
+        assert_maker_atom_content_inline_other_base64(*args, &block)
+      end
+    end
+
+    def assert_maker_atom_content_inline_other_xml(feed_type, maker_readers,
+                                                   feed_readers,
+                                                   not_set_error_name)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        assert_not_set_error(not_set_error_name, %w(xml_content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "application/xml"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(xml_content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "svg/image+xml"
+          end
+        end
+
+        svg_uri = "http://www.w3.org/2000/svg"
+        rect = RSS::XML::Element.new("rect", nil, svg_uri,
+                                     {"x" => "0.5cm",
+                                      "y" => "0.5cm",
+                                      "width" => "2cm",
+                                      "height" => "1cm"})
+        svg = RSS::XML::Element.new("svg", nil, svg_uri,
+                                    {"xmlns" => svg_uri,
+                                     "version" => "1.1",
+                                     "width" => "5cm",
+                                     "height" => "4cm"},
+                                    [rect])
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/svg+xml"
+          target.xml = svg
+        end
+
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/svg+xml"
+          target.xml = svg
+        end
+        assert_equal(svg, chain_reader(feed, feed_readers).xml)
+      end
+    end
+
+    def assert_maker_atom_content_inline_other_text(feed_type, maker_readers,
+                                                    feed_readers,
+                                                    not_set_error_name)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        assert_not_set_error(not_set_error_name, %w(content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "text/plain"
+          end
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "text/plain"
+          target.content = "text"
+        end
+      end
+    end
+
+    def assert_maker_atom_content_inline_other_base64(feed_type, maker_readers,
+                                                      feed_readers,
+                                                      not_set_error_name)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        content = "\211PNG\r\n\032\n"
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/png"
+          target.content = content
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/png"
+          target.src = "http://example.com/logo.png"
+          target.content = content
+        end
+
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/png"
+          target.src = "http://example.com/logo.png"
+          target.content = content
+        end
+        target = chain_reader(feed, feed_readers)
+        assert_nil(target.src)
+        assert_equal(content, target.content)
+      end
+    end
+
+    def assert_maker_atom_content_out_of_line(feed_type, maker_readers,
+                                              feed_readers, not_set_error_name)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        assert_not_set_error(not_set_error_name, %w(content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "image/png"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(type)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.src = "http://example.com/logo.png"
+          end
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/png"
+          target.src = "http://example.com/logo.png"
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/png"
+          target.content = "\211PNG\r\n\032\n"
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "application/xml"
+          target.src = "http://example.com/sample.xml"
+        end
+
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "text/plain"
+          target.src = "http://example.com/README.txt"
+        end
+      end
+    end
+
+    def chain_reader(target, readers)
+      readers.inject(target) do |result, reader|
+        return nil if result.nil?
+        result.__send__(reader)
+      end
+    end
+
     def normalized_attrs(attrs)
       n_attrs = {}
       attrs.each do |name, value|
@@ -487,6 +2656,18 @@ module RSS
       end
       n_attrs
     end
-    
+
+    def combination(elements, n)
+      if n <= 0 or elements.size < n
+        []
+      elsif n == 1
+        elements.collect {|element| [element]}
+      else
+        first, *rest = elements
+        combination(rest, n - 1).collect do |sub_elements|
+          [first, *sub_elements]
+        end + combination(rest, n)
+      end
+    end
   end
 end
diff --git a/test/rss/rss-testcase.rb b/test/rss/rss-testcase.rb
index 0612abcccd..baac597c00 100644
--- a/test/rss/rss-testcase.rb
+++ b/test/rss/rss-testcase.rb
@@ -3,6 +3,8 @@ require "erb"
 require "test/unit"
 require 'rss-assertions'
 
+require "rss"
+
 module RSS
   class TestCase < Test::Unit::TestCase
     include ERB::Util
@@ -22,7 +24,7 @@ module RSS
     NAME_VALUE = "hogehoge"
     LANGUAGE_VALUE = "ja"
     DESCRIPTION_VALUE = "
-    XML.com features a rich mix of information and services 
+    XML.com features a rich mix of information and services
     for the XML community.
     "
     RESOURCES = [
@@ -42,6 +44,45 @@ module RSS
     
     CATEGORY_DOMAIN = "http://www.superopendirectory.com/"
 
+    FEED_TITLE = "dive into mark"
+    FEED_UPDATED = "2003-12-13T18:30:02Z"
+    FEED_AUTHOR_NAME = "John Doe"
+    FEED_ID = "urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6"
+
+    ENTRY_TITLE = "Atom-Powered Robots Run Amok"
+    ENTRY_LINK = "http://example.org/2003/12/13/atom03"
+    ENTRY_ID = "urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a"
+    ENTRY_UPDATED = "2003-12-13T18:30:02Z"
+    ENTRY_SUMMARY = "Some text."
+
+    t = Time.iso8601("2000-01-01T12:00:05+00:00")
+    class << t
+      alias_method(:to_s, :iso8601)
+    end
+
+    DC_ELEMENTS = {
+      :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 = DC_ELEMENTS.collect do |name, value|
+      "<#{DC_PREFIX}:#{name}>#{value}</#{DC_PREFIX}:#{name}>"
+    end.join("\n")
+
     def default_test
       # This class isn't tested
     end
@@ -140,6 +181,15 @@ EOR
 EORSS
     end
 
+    def make_sample_items20
+      RESOURCES.collect do |res|
+        elems = ["<link>#{res}</link>"]
+        elems << "<title>title of #{res}</title>"
+        elems = elems.join("\n")
+        item = "<item>\n#{elems}\n</item>"
+      end.join("\n")
+    end
+
     def make_channel20(content=nil)
       <<-EOC
 <channel>
@@ -154,7 +204,7 @@ EORSS
     <link>#{LINK_VALUE}</link>
   </image>
 
-#{RESOURCES.collect do |res| '<item><link>' + res + '</link></item>' end.join("\n")}
+#{make_sample_items20}
 
   <textInput>
     <title>#{TITLE_VALUE}</title>
@@ -190,6 +240,88 @@ EOI
 EOC
     end
 
+    def make_sample_rss20
+      make_rss20(<<-EOR)
+#{make_channel20}
+EOR
+    end
+
+    def make_feed_without_entry(content=nil, xmlns=[])
+      <<-EOA
+<feed xmlns="#{Atom::URI}"
+#{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}>
+  <id>#{FEED_ID}</id>
+  <title>#{FEED_TITLE}</title>
+  <updated>#{FEED_UPDATED}</updated>
+  <author>
+    <name>#{FEED_AUTHOR_NAME}</name>
+  </author>
+#{block_given? ? yield : content}
+</feed>
+EOA
+    end
+
+    def make_entry(content=nil)
+      <<-EOA
+  <entry>
+    <title>#{ENTRY_TITLE}</title>
+    <id>#{ENTRY_ID}</id>
+    <updated>#{ENTRY_UPDATED}</updated>
+#{block_given? ? yield : content}
+  </entry>
+EOA
+    end
+
+    def make_feed_with_open_entry(content=nil, xmlns=[], &block)
+      make_feed_without_entry(<<-EOA, xmlns)
+#{make_entry(content, &block)}
+EOA
+    end
+
+    def make_feed_with_open_entry_source(content=nil, xmlns=[])
+      make_feed_with_open_entry(<<-EOA, xmlns)
+  <source>
+#{block_given? ? yield : content}
+  </source>
+EOA
+    end
+
+    def make_feed(content=nil, xmlns=[])
+      make_feed_without_entry(<<-EOA, xmlns)
+  <entry>
+    <title>#{ENTRY_TITLE}</title>
+    <link href="#{ENTRY_LINK}"/>
+    <id>#{ENTRY_ID}</id>
+    <updated>#{ENTRY_UPDATED}</updated>
+    <summary>#{ENTRY_SUMMARY}</summary>
+  </entry>
+#{block_given? ? yield : content}
+EOA
+    end
+
+    def make_entry_document(content=nil, xmlns=[])
+      <<-EOA
+<entry xmlns="#{Atom::URI}"
+#{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}>
+  <id>#{ENTRY_ID}</id>
+  <title>#{ENTRY_TITLE}</title>
+  <updated>#{ENTRY_UPDATED}</updated>
+  <author>
+    <name>#{FEED_AUTHOR_NAME}</name>
+  </author>
+#{block_given? ? yield : content}
+</entry>
+EOA
+    end
+
+    def make_entry_document_with_open_source(content=nil, xmlns=[])
+      make_entry_document(<<-EOA, xmlns)
+  <source>
+#{block_given? ? yield : content}
+  </source>
+EOA
+    end
+
     def make_element(elem_name, attrs, contents)
       attrs_str = attrs.collect do |name, value|
         "#{h name}='#{h value}'"
@@ -202,10 +334,52 @@ EOC
     end
     
     private
+    def setup_rss10(rdf)
+      assert_equal("", rdf.to_s)
+
+      channel = RDF::Channel.new
+      assert_equal("", channel.to_s)
+      channel.about = "http://example.com/index.rdf"
+      channel.title = "title"
+      channel.link = "http://example.com/"
+      channel.description = "description"
+      assert_equal("", channel.to_s)
+
+      item_title = "item title"
+      item_link = "http://example.com/item"
+      channel.items = RDF::Channel::Items.new
+      channel.items.Seq.lis << RDF::Channel::Items::Seq::Li.new(item_link)
+      assert_not_equal("", channel.to_s)
+
+      rdf.channel = channel
+      assert_equal("", rdf.to_s)
+
+      item = RDF::Item.new
+      item.title = item_title
+      item.link = item_link
+      item.about = item_link
+      rdf.items << item
+      assert_not_equal("", rdf.to_s)
+    end
+    
+    def setup_rss20(rss)
+      assert_equal("", rss.to_s)
+
+      channel = Rss::Channel.new
+      assert_equal("", channel.to_s)
+      channel.title = "title"
+      channel.link = "http://example.com/"
+      channel.description = "description"
+      assert_not_equal("", channel.to_s)
+
+      rss.channel = channel
+      assert_not_equal("", rss.to_s)
+    end
+    
     def setup_dummy_channel(maker)
       about = "http://hoge.com"
       title = "fugafuga"
-      link = "http://hoge.com"
+      link = "http://hoge.com/feed.xml"
       description = "fugafugafugafuga"
       language = "ja"
 
@@ -216,6 +390,17 @@ EOC
       maker.channel.language = language
     end
 
+    def setup_dummy_channel_atom(maker)
+      updated = Time.now
+      author = "Foo"
+
+      setup_dummy_channel(maker)
+      maker.channel.links.first.rel = "self"
+      maker.channel.links.first.type = "application/atom+xml"
+      maker.channel.updated = updated
+      maker.channel.author = author
+    end
+
     def setup_dummy_image(maker)
       title = "fugafuga"
       link = "http://hoge.com"
@@ -247,7 +432,15 @@ EOC
       item.title = title
       item.link = link
     end
-    
+
+    def setup_dummy_item_atom(maker)
+      setup_dummy_item(maker)
+
+      item = maker.items.first
+      item.id = "http://example.net/xxx"
+      item.updated = Time.now
+    end
+
     def setup_taxo_topic(target, topics)
       topics.each do |topic|
         taxo_topic = target.taxo_topics.new_taxo_topic
diff --git a/test/rss/test_1.0.rb b/test/rss/test_1.0.rb
index b905ba6e94..9cb7607590 100644
--- a/test/rss/test_1.0.rb
+++ b/test/rss/test_1.0.rb
@@ -19,8 +19,8 @@ module RSS
       standalone = false
       
       rdf = RDF.new(version, encoding, standalone)
-      
-      doc = REXML::Document.new(rdf.to_s(false))
+      setup_rss10(rdf)
+      doc = REXML::Document.new(rdf.to_s)
       
       xmldecl = doc.xml_decl
       
@@ -59,16 +59,31 @@ module RSS
       link = "http://hoge.com"
       description = "fugafugafugafuga"
       resource = "http://hoge.com/hoge.png"
+
+      item_title = "item title"
+      item_link = "http://hoge.com/item"
+
       image = RDF::Channel::Image.new(resource)
       items = RDF::Channel::Items.new
+      items.Seq.lis << items.class::Seq::Li.new(item_link)
       textinput = RDF::Channel::Textinput.new(resource)
-      
+
+      rss_item = RDF::Item.new
+      rss_item.title = item_title
+      rss_item.link = item_link
+      rss_item.about = item_link
+
       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))
+      doc = REXML::Document.new(make_RDF(<<-EOR))
+#{channel}
+<items>
+#{rss_item}
+</items>
+EOR
       c = doc.root.elements[1]
       
       assert_equal(about, c.attributes["about"])
@@ -123,8 +138,12 @@ module RSS
       assert_equal(resource, res.value)
     end
     
-    def test_items
+    def test_channel_items
+      item_link = "http://example.com/item"
+
       items = RDF::Channel::Items.new
+      li = items.Seq.class::Li.new(item_link)
+      items.Seq.lis << li
       
       doc = REXML::Document.new(make_RDF(items.to_s))
       i = doc.root.elements[1]
@@ -133,18 +152,34 @@ module RSS
       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)
+      seq = i.elements[1]
+      assert_equal("Seq", seq.name)
+      assert_equal(@rdf_uri, seq.namespace)
+
+      assert_equal(1, seq.elements.size)
+      l = seq.elements[1]
+      assert_equal("li", l.name)
+      assert_equal(@rdf_uri, l.namespace)
+      assert_equal(item_link, l.attributes["resource"])
     end
     
     def test_seq
+      item_link = "http://example.com/item"
       seq = RDF::Seq.new
+      li = seq.class::Li.new(item_link)
+      seq.lis << li
       
       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)
+
+      assert_equal(1, s.elements.size)
+      l = s.elements[1]
+      assert_equal("li", l.name)
+      assert_equal(@rdf_uri, l.namespace)
+      assert_equal(item_link, l.attributes["resource"])
     end
     
     def test_li
@@ -233,15 +268,29 @@ module RSS
       end
     end
 
-    def test_indent_size
-      assert_equal(0, RDF.indent_size)
-      assert_equal(1, RDF::Channel.indent_size)
-      assert_equal(2, RDF::Channel::Image.indent_size)
-      assert_equal(2, RDF::Channel::Textinput.indent_size)
-      assert_equal(2, RDF::Channel::Items.indent_size)
-      assert_equal(1, RDF::Image.indent_size)
-      assert_equal(1, RDF::Item.indent_size)
-      assert_equal(1, RDF::Textinput.indent_size)
+    def test_to_xml
+      rss = RSS::Parser.parse(make_sample_RDF)
+      assert_equal(rss.to_s, rss.to_xml)
+      assert_equal(rss.to_s, rss.to_xml("1.0"))
+      rss09 = rss.to_xml("0.91") do |maker|
+        maker.channel.language = "en-us"
+      end
+      rss09 = RSS::Parser.parse(rss09)
+      assert_equal("0.91", rss09.rss_version)
+      assert_equal(["rss", "0.91", nil], rss09.feed_info)
+      rss20 = RSS::Parser.parse(rss.to_xml("2.0"))
+      assert_equal("2.0", rss20.rss_version)
+      assert_equal(["rss", "2.0", nil], rss20.feed_info)
+
+      atom_xml = rss.to_xml("atom") do |maker|
+        maker.channel.author = "Alice"
+        maker.channel.updated ||= Time.now
+        maker.items.each do |item|
+          item.updated ||= Time.now
+        end
+      end
+      atom = RSS::Parser.parse(atom_xml)
+      assert_equal(["atom", "1.0", "feed"], atom.feed_info)
     end
   end
 end
diff --git a/test/rss/test_2.0.rb b/test/rss/test_2.0.rb
index 2027e5344a..5a63efbcb9 100644
--- a/test/rss/test_2.0.rb
+++ b/test/rss/test_2.0.rb
@@ -2,8 +2,6 @@ require "rexml/document"
 
 require "rss-testcase"
 
-require "rss/2.0"
-
 module RSS
   class TestRSS20Core < TestCase
 
@@ -17,6 +15,7 @@ module RSS
       standalone = false
       
       rss = Rss.new(@rss_version, version, encoding, standalone)
+      setup_rss20(rss)
       
       doc = REXML::Document.new(rss.to_s(false))
       
@@ -48,7 +47,9 @@ module RSS
           {:href => "a.css", :type => "text/css"},
         ],
       ].each do |attrs_ary|
-        assert_xml_stylesheet_pis(attrs_ary, Rss.new(@rss_version))
+        rss = Rss.new(@rss_version)
+        setup_rss20(rss)
+        assert_xml_stylesheet_pis(attrs_ary, rss)
       end
     end
 
@@ -253,6 +254,10 @@ module RSS
       pubDate = Time.parse("Sat, 07 Sep 2002 00:00:01 GMT")
 
       channel = Rss::Channel.new
+      channel.title = "title"
+      channel.link = "http://example.com/"
+      channel.description = "description"
+
       item = Rss::Channel::Item.new
       channel.items << item
       
@@ -373,22 +378,33 @@ module RSS
       end
       assert_equal(source_params, actual)
     end
-    
-    def test_indent_size
-      assert_equal(0, Rss.indent_size)
-      assert_equal(1, Rss::Channel.indent_size)
-      assert_equal(2, Rss::Channel::SkipDays.indent_size)
-      assert_equal(3, Rss::Channel::SkipDays::Day.indent_size)
-      assert_equal(2, Rss::Channel::SkipHours.indent_size)
-      assert_equal(3, Rss::Channel::SkipHours::Hour.indent_size)
-      assert_equal(2, Rss::Channel::Image.indent_size)
-      assert_equal(2, Rss::Channel::Cloud.indent_size)
-      assert_equal(2, Rss::Channel::Item.indent_size)
-      assert_equal(3, Rss::Channel::Item::Source.indent_size)
-      assert_equal(3, Rss::Channel::Item::Enclosure.indent_size)
-      assert_equal(3, Rss::Channel::Item::Category.indent_size)
-      assert_equal(3, Rss::Channel::Item::Guid.indent_size)
-      assert_equal(2, Rss::Channel::TextInput.indent_size)
+
+    def test_to_xml
+      rss = RSS::Parser.parse(make_sample_rss20)
+      assert_equal(rss.to_s, rss.to_xml)
+      assert_equal(rss.to_s, rss.to_xml("2.0"))
+      rss09_xml = rss.to_xml("0.91") do |maker|
+        setup_dummy_image(maker)
+      end
+      rss09 = RSS::Parser.parse(rss09_xml)
+      assert_equal("0.91", rss09.rss_version)
+      rss10 = rss.to_xml("1.0") do |maker|
+        maker.channel.about = "http://www.example.com/index.rdf"
+      end
+      rss10 = RSS::Parser.parse(rss10)
+      assert_equal("1.0", rss10.rss_version)
+
+      atom_xml = rss.to_xml("atom1.0") do |maker|
+        maker.channel.id = "http://www.example.com/atom.xml"
+        maker.channel.author = "Alice"
+        maker.channel.updated = Time.now
+        maker.items.each do |item|
+          item.author = "Bob"
+          item.updated = Time.now
+        end
+      end
+      atom = RSS::Parser.parse(atom_xml)
+      assert_equal(["atom", "1.0", "feed"], atom.feed_info)
     end
   end
 end
diff --git a/test/rss/test_atom.rb b/test/rss/test_atom.rb
new file mode 100644
index 0000000000..aea05bebbe
--- /dev/null
+++ b/test/rss/test_atom.rb
@@ -0,0 +1,281 @@
+require "rexml/document"
+
+require "rss-testcase"
+
+require "rss/atom"
+
+module RSS
+  class TestAtomCore < TestCase
+    def setup
+      @uri = "http://www.w3.org/2005/Atom"
+      @xhtml_uri = "http://www.w3.org/1999/xhtml"
+    end
+
+    def test_feed
+      version = "1.0"
+      encoding = "UTF-8"
+      standalone = false
+
+      feed = Atom::Feed.new(version, encoding, standalone)
+      assert_equal("", feed.to_s)
+
+      author = feed.class::Author.new
+      name = feed.class::Author::Name.new
+      name.content = "an author"
+      author.name = name
+      assert_not_equal("", author.to_s)
+      feed.authors << author
+      assert_equal("", feed.to_s)
+
+      id = feed.class::Id.new
+      id.content = "http://example.com/atom.xml"
+      assert_not_equal("", id.to_s)
+      feed.id = id
+      assert_equal("", feed.to_s)
+
+      title = feed.class::Title.new
+      title.content = "a title"
+      assert_not_equal("", title.to_s)
+      feed.title = title
+      assert_equal("", feed.to_s)
+
+      updated = feed.class::Updated.new
+      updated.content = Time.now
+      assert_not_equal("", updated.to_s)
+      feed.updated = updated
+      assert_not_equal("", feed.to_s)
+
+
+      feed.authors.clear
+      assert_equal("", feed.to_s)
+      entry = Atom::Feed::Entry.new
+      setup_entry(entry)
+      assert_not_equal("", entry.to_s)
+
+      author = entry.authors.first
+      entry.authors.clear
+      assert_equal("", entry.to_s)
+      entry.parent = feed
+      assert_equal("", entry.to_s)
+      feed.authors << author
+      assert_not_equal("", entry.to_s)
+      feed.authors.clear
+      feed.entries << entry
+      assert_equal("", feed.to_s)
+      entry.authors << author
+      assert_not_equal("", entry.to_s)
+      assert_not_equal("", feed.to_s)
+
+      doc = REXML::Document.new(feed.to_s)
+      xmldecl = doc.xml_decl
+
+      %w(version encoding).each do |x|
+        assert_equal(instance_eval(x), xmldecl.__send__(x))
+      end
+      assert_equal(standalone, !xmldecl.standalone.nil?)
+
+      assert_equal(@uri, doc.root.namespace)
+    end
+
+    def test_entry
+      version = "1.0"
+      encoding = "UTF-8"
+      standalone = false
+
+      entry = Atom::Entry.new(version, encoding, standalone)
+      setup_entry(entry)
+
+      author = entry.authors.first
+      entry.authors.clear
+      assert_equal("", entry.to_s)
+      source = Atom::Entry::Source.new
+      source.authors << author
+      entry.source = source
+      assert_not_equal("", entry.to_s)
+
+      doc = REXML::Document.new(entry.to_s)
+      xmldecl = doc.xml_decl
+
+      %w(version encoding).each do |x|
+        assert_equal(instance_eval(x), xmldecl.__send__(x))
+      end
+      assert_equal(standalone, !xmldecl.standalone.nil?)
+
+      assert_equal(@uri, doc.root.namespace)
+    end
+
+    def test_not_displayed_xml_stylesheets
+      feed = Atom::Feed.new
+      plain_feed = feed.to_s
+      3.times do
+        feed.xml_stylesheets.push(XMLStyleSheet.new)
+        assert_equal(plain_feed, feed.to_s)
+      end
+    end
+
+    def test_atom_author
+      assert_atom_person_to_s(Atom::Feed::Author)
+      assert_atom_person_to_s(Atom::Feed::Entry::Author)
+      assert_atom_person_to_s(Atom::Entry::Author)
+      assert_atom_person_to_s(Atom::Feed::Entry::Source::Author)
+      assert_atom_person_to_s(Atom::Entry::Source::Author)
+    end
+
+    def test_atom_category
+      assert_atom_category_to_s(Atom::Feed::Category)
+      assert_atom_category_to_s(Atom::Feed::Entry::Category)
+      assert_atom_category_to_s(Atom::Entry::Category)
+      assert_atom_category_to_s(Atom::Feed::Entry::Source::Category)
+      assert_atom_category_to_s(Atom::Entry::Source::Category)
+    end
+
+    def test_atom_contributor
+      assert_atom_person_to_s(Atom::Feed::Contributor)
+      assert_atom_person_to_s(Atom::Feed::Entry::Contributor)
+      assert_atom_person_to_s(Atom::Entry::Contributor)
+      assert_atom_person_to_s(Atom::Feed::Entry::Source::Contributor)
+      assert_atom_person_to_s(Atom::Entry::Source::Contributor)
+    end
+
+    def test_atom_generator
+      assert_atom_generator_to_s(Atom::Feed::Generator)
+      assert_atom_generator_to_s(Atom::Feed::Entry::Source::Generator)
+      assert_atom_generator_to_s(Atom::Entry::Source::Generator)
+    end
+
+    def test_atom_icon
+      assert_atom_icon_to_s(Atom::Feed::Icon)
+      assert_atom_icon_to_s(Atom::Feed::Entry::Source::Icon)
+      assert_atom_icon_to_s(Atom::Entry::Source::Icon)
+    end
+
+    def test_atom_id
+      assert_atom_id_to_s(Atom::Feed::Id)
+      assert_atom_id_to_s(Atom::Feed::Entry::Id)
+      assert_atom_id_to_s(Atom::Entry::Id)
+      assert_atom_id_to_s(Atom::Feed::Entry::Source::Id)
+      assert_atom_id_to_s(Atom::Entry::Source::Id)
+    end
+
+    def test_atom_link
+      assert_atom_link_to_s(Atom::Feed::Link)
+      assert_atom_link_to_s(Atom::Feed::Entry::Link)
+      assert_atom_link_to_s(Atom::Entry::Link)
+      assert_atom_link_to_s(Atom::Feed::Entry::Source::Link)
+      assert_atom_link_to_s(Atom::Entry::Source::Link)
+    end
+
+    def test_atom_logo
+      assert_atom_logo_to_s(Atom::Feed::Logo)
+      assert_atom_logo_to_s(Atom::Feed::Entry::Source::Logo)
+      assert_atom_logo_to_s(Atom::Entry::Source::Logo)
+    end
+
+    def test_atom_rights
+      assert_atom_text_construct_to_s(Atom::Feed::Rights)
+      assert_atom_text_construct_to_s(Atom::Feed::Entry::Rights)
+      assert_atom_text_construct_to_s(Atom::Entry::Rights)
+      assert_atom_text_construct_to_s(Atom::Feed::Entry::Source::Rights)
+      assert_atom_text_construct_to_s(Atom::Entry::Source::Rights)
+    end
+
+    def test_atom_subtitle
+      assert_atom_text_construct_to_s(Atom::Feed::Subtitle)
+      assert_atom_text_construct_to_s(Atom::Feed::Entry::Source::Subtitle)
+      assert_atom_text_construct_to_s(Atom::Entry::Source::Subtitle)
+    end
+
+    def test_atom_title
+      assert_atom_text_construct_to_s(Atom::Feed::Title)
+      assert_atom_text_construct_to_s(Atom::Feed::Entry::Title)
+      assert_atom_text_construct_to_s(Atom::Entry::Title)
+      assert_atom_text_construct_to_s(Atom::Feed::Entry::Source::Title)
+      assert_atom_text_construct_to_s(Atom::Entry::Source::Title)
+    end
+
+    def test_atom_updated
+      assert_atom_date_construct_to_s(Atom::Feed::Updated)
+      assert_atom_date_construct_to_s(Atom::Feed::Entry::Updated)
+      assert_atom_date_construct_to_s(Atom::Entry::Updated)
+      assert_atom_date_construct_to_s(Atom::Feed::Entry::Source::Updated)
+      assert_atom_date_construct_to_s(Atom::Entry::Source::Updated)
+    end
+
+    def test_atom_content
+      assert_atom_content_to_s(Atom::Feed::Entry::Content)
+      assert_atom_content_to_s(Atom::Entry::Content)
+    end
+
+    def test_atom_published
+      assert_atom_date_construct_to_s(Atom::Feed::Entry::Published)
+      assert_atom_date_construct_to_s(Atom::Entry::Published)
+    end
+
+    def test_atom_summary
+      assert_atom_text_construct_to_s(Atom::Feed::Entry::Summary)
+      assert_atom_text_construct_to_s(Atom::Entry::Summary)
+    end
+
+
+    def test_to_xml
+      atom = RSS::Parser.parse(make_feed)
+      assert_equal(atom.to_s, atom.to_xml)
+      assert_equal(atom.to_s, atom.to_xml("atom"))
+      assert_equal(atom.to_s, atom.to_xml("atom1.0"))
+      assert_equal(atom.to_s, atom.to_xml("atom1.0:feed"))
+      assert_equal(atom.to_s, atom.to_xml("atom:feed"))
+
+      rss09_xml = atom.to_xml("0.91") do |maker|
+        maker.channel.language = "en-us"
+        maker.channel.link = "http://example.com/"
+        maker.channel.description.content = atom.title.content
+
+        maker.image.url = "http://example.com/logo.png"
+        maker.image.title = "Logo"
+      end
+      rss09 = RSS::Parser.parse(rss09_xml)
+      assert_equal(["rss", "0.91", nil], rss09.feed_info)
+
+      rss20_xml = atom.to_xml("2.0") do |maker|
+        maker.channel.link = "http://example.com/"
+        maker.channel.description.content = atom.title.content
+      end
+      rss20 = RSS::Parser.parse(rss20_xml)
+      assert_equal("2.0", rss20.rss_version)
+      assert_equal(["rss", "2.0", nil], rss20.feed_info)
+    end
+
+    private
+    def setup_entry(entry)
+      _wrap_assertion do
+        assert_equal("", entry.to_s)
+
+        author = entry.class::Author.new
+        name = entry.class::Author::Name.new
+        name.content = "an author"
+        author.name = name
+        assert_not_equal("", author.to_s)
+        entry.authors << author
+        assert_equal("", entry.to_s)
+
+        id = entry.class::Id.new
+        id.content = "http://example.com/atom.xml"
+        assert_not_equal("", id.to_s)
+        entry.id = id
+        assert_equal("", entry.to_s)
+
+        title = entry.class::Title.new
+        title.content = "a title"
+        assert_not_equal("", title.to_s)
+        entry.title = title
+        assert_equal("", entry.to_s)
+
+        updated = entry.class::Updated.new
+        updated.content = Time.now
+        assert_not_equal("", updated.to_s)
+        entry.updated = updated
+        assert_not_equal("", entry.to_s)
+      end
+    end
+  end
+end
diff --git a/test/rss/test_content.rb b/test/rss/test_content.rb
index 0622625e26..aef930caa1 100644
--- a/test/rss/test_content.rb
+++ b/test/rss/test_content.rb
@@ -74,7 +74,7 @@ EOR
         excepted = "<#{@prefix}:#{name}>#{CGI.escapeHTML(value)}</#{@prefix}:#{name}>"
         @parents.each do |parent|
           meth = "#{RSS::CONTENT_PREFIX}_#{name}_element"
-          assert_equal(excepted, @rss.__send__(parent).funcall(meth))
+          assert_equal(excepted, @rss.__send__(parent).__send!(meth))
         end
       end
 
diff --git a/test/rss/test_dublincore.rb b/test/rss/test_dublincore.rb
index 36c7f14ec9..0e049e7910 100644
--- a/test/rss/test_dublincore.rb
+++ b/test/rss/test_dublincore.rb
@@ -8,86 +8,168 @@ 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)}
+      @rss10_parents = [%w(channel), %w(image), %w(item), %w(textinput)]
+
+      @rss10_source = make_RDF(<<-EOR, {DC_PREFIX =>  DC_URI})
+#{make_channel(DC_NODES)}
+#{make_image(DC_NODES)}
+#{make_item(DC_NODES)}
+#{make_textinput(DC_NODES)}
+EOR
+
+      @rss20_parents = [%w(channel), %w(items last)]
+
+      @rss20_source = make_rss20(<<-EOR, {DC_PREFIX =>  DC_URI})
+#{make_channel20(DC_NODES + make_item20(DC_NODES))}
+EOR
+
+      @atom_feed_parents = [[], %w(entries last)]
+
+      @atom_feed_source = make_feed(<<-EOR, {DC_PREFIX =>  DC_URI})
+#{DC_NODES}
+#{make_entry(DC_NODES)}
 EOR
 
-      @rss = Parser.parse(@rss_source)
+      @atom_entry_parents = [[]]
+
+      @atom_entry_source = make_entry_document(<<-EOR, {DC_PREFIX =>  DC_URI})
+#{DC_NODES}
+EOR
     end
-  
+
     def test_parser
-      assert_nothing_raised do
-        Parser.parse(@rss_source)
+      rss10_maker = Proc.new do |content, xmlns|
+        make_RDF(<<-EOR, xmlns)
+#{make_channel(content)}
+#{make_image(content)}
+#{make_item(content)}
+#{make_textinput(content)}
+EOR
+      end
+      assert_dc_parse(@rss10_source, @rss10_parents, false, &rss10_maker)
+      assert_dc_parse(@rss10_source, @rss10_parents, true, &rss10_maker)
+
+      rss20_maker = Proc.new do |content, xmlns|
+        make_rss20(<<-EOR, xmlns)
+#{make_channel20(content + make_item20(content))}
+EOR
+      end
+      assert_dc_parse(@rss20_source, @rss20_parents, false, &rss20_maker)
+      assert_dc_parse(@rss20_source, @rss20_parents, true, &rss20_maker)
+
+      atom_feed_maker = Proc.new do |content, xmlns|
+        make_feed(<<-EOR, xmlns)
+#{content}
+#{make_entry(content)}
+EOR
       end
-    
-      @elems.each do |tag, value|
-        rss = nil
-        assert_nothing_raised do
-          rss = Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
-#{make_channel(("<" + @prefix + ":" + tag.to_s + ">" +
-  value.to_s +
-  "</" + @prefix + ":" + tag.to_s + ">") * 2)}
-#{make_item}
+      assert_dc_parse(@atom_feed_source, @atom_feed_parents, false,
+                      &atom_feed_maker)
+      assert_dc_parse(@atom_feed_source, @atom_feed_parents, true,
+                      &atom_feed_maker)
+
+      atom_entry_maker = Proc.new do |content, xmlns|
+        make_entry_document(<<-EOR, xmlns)
+#{content}
 EOR
+      end
+      assert_dc_parse(@atom_entry_source, @atom_entry_parents, false,
+                      &atom_entry_maker)
+      assert_dc_parse(@atom_entry_source, @atom_entry_parents, true,
+                      &atom_entry_maker)
+    end
+
+    def test_singular_accessor
+      assert_dc_singular_accessor(@rss10_source, @rss10_parents)
+      assert_dc_singular_accessor(@rss20_source, @rss20_parents)
+      assert_dc_singular_accessor(@atom_feed_source, @atom_feed_parents)
+      assert_dc_singular_accessor(@atom_entry_source, @atom_entry_parents)
+    end
+
+    def test_plural_accessor
+      assert_dc_plural_accessor(@rss10_source, @rss10_parents, false)
+      assert_dc_plural_accessor(@rss10_source, @rss10_parents, true)
+
+      assert_dc_plural_accessor(@rss20_source, @rss20_parents, false)
+      assert_dc_plural_accessor(@rss20_source, @rss20_parents, true)
+
+      assert_dc_plural_accessor(@atom_feed_source, @atom_feed_parents, false)
+      assert_dc_plural_accessor(@atom_feed_source, @atom_feed_parents, true)
+
+      assert_dc_plural_accessor(@atom_entry_source, @atom_entry_parents, false)
+      assert_dc_plural_accessor(@atom_entry_source, @atom_entry_parents, true)
+    end
+
+    def test_to_s
+      assert_dc_to_s(@rss10_source, @rss10_parents, false)
+      assert_dc_to_s(@rss10_source, @rss10_parents, true)
+
+      targets = ["channel", "channel/item[3]"]
+      assert_dc_to_s(@rss20_source, @rss20_parents, false, targets)
+      assert_dc_to_s(@rss20_source, @rss20_parents, true, targets)
+
+      targets = [".", "entry"]
+      assert_dc_to_s(@atom_feed_source, @atom_feed_parents, false, targets)
+      assert_dc_to_s(@atom_feed_source, @atom_feed_parents, true, targets)
+
+      targets = ["."]
+      assert_dc_to_s(@atom_entry_source, @atom_entry_parents, false, targets)
+      assert_dc_to_s(@atom_entry_source, @atom_entry_parents, true, targets)
+    end
+
+    private
+    def dc_plural_suffix(name, check_backward_compatibility)
+      if name == :rights
+        if check_backward_compatibility
+          "es"
+        else
+          "_list"
         end
-        plural_reader = "dc_#{tag}" + (tag == :rights ? "es" : "s")
-        values = rss.channel.__send__(plural_reader).collect do |x|
-          val = x.value
-          if val.kind_of?(String)
-            CGI.escapeHTML(val)
-          else
-            val
+      else
+        "s"
+      end
+    end
+
+    def assert_dc_parse(source, parents, check_backward_compatibility, &maker)
+      assert_nothing_raised do
+        Parser.parse(source)
+      end
+
+      DC_ELEMENTS.each do |name, value|
+        parents.each do |parent_readers|
+          feed = nil
+          assert_nothing_raised do
+            tag = "#{DC_PREFIX}:#{name}"
+            dc_content = "<#{tag}>#{value}</#{tag}>\n"
+            dc_content *= 2
+            feed = Parser.parse(maker.call(dc_content, {DC_PREFIX => DC_URI}))
           end
+          parent = chain_reader(feed, parent_readers)
+
+          plural_suffix = dc_plural_suffix(name, check_backward_compatibility)
+          plural_reader = "dc_#{name}#{plural_suffix}"
+          values = parent.__send__(plural_reader).collect do |x|
+            val = x.value
+            if val.kind_of?(String)
+              CGI.escapeHTML(val)
+            else
+              val
+            end
+          end
+          assert_equal([value, value], values)
         end
-        assert_equal([value, value], values)
       end
-
     end
 
-    def test_singular_accessor
+    def assert_dc_singular_accessor(source, parents)
+      feed = Parser.parse(source)
       new_value = "hoge"
 
-      @elems.each do |name, value|
-        @parents.each do |parent|
-          parsed_value = @rss.__send__(parent).__send__("dc_#{name}")
+      parents.each do |parent_readers|
+        parent = chain_reader(feed, parent_readers)
+        DC_ELEMENTS.each do |name, value|
+          parsed_value = parent.__send__("dc_#{name}")
           if parsed_value.kind_of?(String)
             parsed_value = CGI.escapeHTML(parsed_value)
           end
@@ -97,34 +179,40 @@ EOR
             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}"))
-            assert_equal(t, @rss.__send__(parent).date)
-            
-            @rss.__send__(parent).date = value
-            assert_equal(value, @rss.__send__(parent).date)
-            assert_equal(value, @rss.__send__(parent).__send__("dc_#{name}"))
+            parent.__send__("dc_#{name}=", t.iso8601)
+            assert_equal(t, parent.__send__("dc_#{name}"))
+            if parent.class.method_defined?(:date_without_dc_date=)
+              assert_nil(parent.date)
+            else
+              assert_equal(t, parent.date)
+            end
+
+            parent.date = value
+            assert_equal(value, parent.date)
+            assert_equal(value, parent.__send__("dc_#{name}"))
           else
-            @rss.__send__(parent).__send__("dc_#{name}=", new_value)
-            assert_equal(new_value,
-                         @rss.__send__(parent).__send__("dc_#{name}"))
+            parent.__send__("dc_#{name}=", new_value)
+            assert_equal(new_value, parent.__send__("dc_#{name}"))
           end
         end
       end
     end
 
-    def test_plural_accessor
+    def assert_dc_plural_accessor(source, parents, check_backward_compatibility)
+      feed = Parser.parse(source)
       new_value = "hoge"
-      
-      @elems.each do |name, value|
-        @parents.each do |parent|
-          parsed_value = @rss.__send__(parent).__send__("dc_#{name}")
+
+      DC_ELEMENTS.each do |name, value|
+        parents.each do |parent_readers|
+          parent = chain_reader(feed, parent_readers)
+          parsed_value = parent.__send__("dc_#{name}")
           if parsed_value.kind_of?(String)
             parsed_value = CGI.escapeHTML(parsed_value)
           end
           assert_equal(value, parsed_value)
 
-          plural_reader = "dc_#{name}" + (name == :rights ? "es" : "s")
+          plural_suffix = dc_plural_suffix(name, check_backward_compatibility)
+          plural_reader = "dc_#{name}#{plural_suffix}"
           klass_name = "DublinCore#{Utils.to_class_name(name.to_s)}"
           klass = DublinCoreModel.const_get(klass_name)
           if name == :date
@@ -132,58 +220,60 @@ EOR
             class << t
               alias_method(:to_s, :iso8601)
             end
-            elems = @rss.__send__(parent).__send__(plural_reader)
+            elems = parent.__send__(plural_reader)
             elems << klass.new(t.iso8601)
-            new_elems = @rss.__send__(parent).__send__(plural_reader)
+            new_elems = parent.__send__(plural_reader)
             values = new_elems.collect{|x| x.value}
-            assert_equal([@rss.__send__(parent).__send__("dc_#{name}"), t],
-                         values)
+            assert_equal([parent.__send__("dc_#{name}"), t], values)
           else
-            elems = @rss.__send__(parent).__send__(plural_reader)
+            elems = parent.__send__(plural_reader)
             elems << klass.new(new_value)
-            new_elems = @rss.__send__(parent).__send__(plural_reader)
+            new_elems = parent.__send__(plural_reader)
             values = new_elems.collect{|x| x.value}
-            assert_equal([
-                          @rss.__send__(parent).__send__("dc_#{name}"),
-                          new_value
-                         ],
+            assert_equal([parent.__send__("dc_#{name}"), new_value],
                          values)
           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).funcall("dc_#{name}_elements"))
+    def assert_dc_to_s(source, parents, check_backward_compatibility,
+                       targets=nil)
+      feed = Parser.parse(source)
+
+      DC_ELEMENTS.each do |name, value|
+        excepted = "<#{DC_PREFIX}:#{name}>#{value}</#{DC_PREFIX}:#{name}>"
+        parents.each do |parent_readers|
+          parent = chain_reader(feed, parent_readers)
+          assert_equal(excepted, parent.__send!("dc_#{name}_elements"))
         end
-        
+
+        plural_suffix = dc_plural_suffix(name, check_backward_compatibility)
+        reader = "dc_#{name}#{plural_suffix}"
         excepted = Array.new(2, excepted).join("\n")
-        @parents.each do |parent|
-          reader = "dc_#{name}" + (name == :rights ? "es" : "s")
-          elems = @rss.__send__(parent).__send__(reader)
+        parents.each do |parent_readers|
+          parent = chain_reader(feed, parent_readers)
+          elems = parent.__send__(reader)
           klass_name = "DublinCore#{Utils.to_class_name(name.to_s)}"
           klass = DublinCoreModel.const_get(klass_name)
-          elems << klass.new(@rss.__send__(parent).__send__("dc_#{name}"))
-          assert_equal(excepted,
-                       @rss.__send__(parent).funcall("dc_#{name}_elements"))
+          elems << klass.new(parent.__send__("dc_#{name}"))
+          assert_equal(excepted, parent.__send!("dc_#{name}_elements"))
         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
+
+      targets ||= parents.collect do |parent_readers|
+        parent_readers.first
+      end
+      feed_root = REXML::Document.new(source).root
+      targets.each do |target_xpath|
+        parent = feed_root.elements[target_xpath]
+        parent.each_element do |elem|
+          if elem.namespace == DC_URI
+            assert_equal(CGI.escapeHTML(elem.text),
+                         DC_ELEMENTS[elem.name.intern].to_s)
           end
         end
       end
     end
-
   end
 end
diff --git a/test/rss/test_image.rb b/test/rss/test_image.rb
index 0fb9fce276..8bb7323206 100644
--- a/test/rss/test_image.rb
+++ b/test/rss/test_image.rb
@@ -52,11 +52,11 @@ module RSS
         items << make_item(image_item)
       end
 
-      ns = {
+      @ns = {
         @prefix => @uri,
         DC_PREFIX => DC_URI,
       }
-      @rss_source = make_RDF(<<-EOR, ns)
+      @rss_source = make_RDF(<<-EOR, @ns)
 #{make_channel(@channel_nodes)}
 #{make_image}
 #{items}
@@ -70,13 +70,23 @@ EOR
       assert_nothing_raised do
         Parser.parse(@rss_source)
       end
-    
+      
       assert_too_much_tag("favicon", "channel") do
-        Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
+        Parser.parse(make_RDF(<<-EOR, @ns))
 #{make_channel(@channel_nodes * 2)}
 #{make_item}
 EOR
       end
+
+      attrs = {"rdf:about" => "http://www.example.org/item.png"}
+      contents = [["#{@prefix}:width", "80"]] * 5
+      image_item = make_element("#{@prefix}:item", attrs, contents)
+      assert_too_much_tag("width", "item") do
+        Parser.parse(make_RDF(<<-EOR, @ns))
+#{make_channel}
+#{make_item(image_item)}
+EOR
+      end
     end
   
     def test_favicon_accessor
diff --git a/test/rss/test_maker_0.9.rb b/test/rss/test_maker_0.9.rb
index d8556887e1..0551dc2800 100644
--- a/test/rss/test_maker_0.9.rb
+++ b/test/rss/test_maker_0.9.rb
@@ -11,18 +11,21 @@ module RSS
       
       rss = RSS::Maker.make("0.9") do |maker|
         setup_dummy_channel(maker)
+        setup_dummy_image(maker)
       end
       assert_equal("0.91", rss.rss_version)
       
       rss = RSS::Maker.make("0.91") do |maker|
         setup_dummy_channel(maker)
+        setup_dummy_image(maker)
       end
       assert_equal("0.91", rss.rss_version)
 
       
       rss = RSS::Maker.make("0.91") do |maker|
         setup_dummy_channel(maker)
-        
+        setup_dummy_image(maker)
+
         maker.encoding = "EUC-JP"
       end
       assert_equal("0.91", rss.rss_version)
@@ -30,7 +33,8 @@ module RSS
 
       rss = RSS::Maker.make("0.91") do |maker|
         setup_dummy_channel(maker)
-        
+        setup_dummy_image(maker)
+
         maker.standalone = "yes"
       end
       assert_equal("0.91", rss.rss_version)
@@ -38,7 +42,8 @@ module RSS
 
       rss = RSS::Maker.make("0.91") do |maker|
         setup_dummy_channel(maker)
-        
+        setup_dummy_image(maker)
+
         maker.encoding = "EUC-JP"
         maker.standalone = "yes"
       end
@@ -67,7 +72,10 @@ module RSS
       ]
       pubDate = Time.now
       lastBuildDate = Time.now
-      
+
+      image_url = "http://example.com/logo.png"
+      image_title = "Logo"
+
       rss = RSS::Maker.make("0.91") do |maker|
         maker.channel.title = title
         maker.channel.link = link
@@ -82,13 +90,18 @@ module RSS
         maker.channel.lastBuildDate = lastBuildDate
 
         skipDays.each do |day|
-          new_day = maker.channel.skipDays.new_day
-          new_day.content = day
+          maker.channel.skipDays.new_day do |new_day|
+            new_day.content = day
+          end
         end
         skipHours.each do |hour|
-          new_hour = maker.channel.skipHours.new_hour
-          new_hour.content = hour
+          maker.channel.skipHours.new_hour do |new_hour|
+            new_hour.content = hour
+          end
         end
+
+        maker.image.url = image_url
+        maker.image.title = image_title
       end
       channel = rss.channel
       
@@ -113,7 +126,11 @@ module RSS
       end
       
       assert(channel.items.empty?)
-      assert_nil(channel.image)
+
+      assert_equal(image_url, channel.image.url)
+      assert_equal(image_title, channel.image.title)
+      assert_equal(link, channel.image.link)
+
       assert_nil(channel.textInput)
     end
 
@@ -209,17 +226,18 @@ module RSS
       height = "400"
       description = "an image"
 
-      rss = RSS::Maker.make("0.91") do |maker|
-        setup_dummy_channel(maker)
-        maker.channel.link = link
-        
-        # maker.image.title = title
-        maker.image.url = url
-        maker.image.width = width
-        maker.image.height = height
-        maker.image.description = description
+      assert_not_set_error("maker.image", %w(title)) do
+        RSS::Maker.make("0.91") do |maker|
+          setup_dummy_channel(maker)
+          maker.channel.link = link
+
+          # maker.image.title = title
+          maker.image.url = url
+          maker.image.width = width
+          maker.image.height = height
+          maker.image.description = description
+        end
       end
-      assert_nil(rss.channel.image)
 
       assert_not_set_error("maker.channel", %w(link)) do
         RSS::Maker.make("0.91") do |maker|
@@ -235,17 +253,18 @@ module RSS
         end
       end
 
-      rss = RSS::Maker.make("0.91") do |maker|
-        setup_dummy_channel(maker)
-        maker.channel.link = link
-        
-        maker.image.title = title
-        # maker.image.url = url
-        maker.image.width = width
-        maker.image.height = height
-        maker.image.description = description
+      assert_not_set_error("maker.image", %w(url)) do
+        RSS::Maker.make("0.91") do |maker|
+          setup_dummy_channel(maker)
+          maker.channel.link = link
+
+          maker.image.title = title
+          # maker.image.url = url
+          maker.image.width = width
+          maker.image.height = height
+          maker.image.description = description
+        end
       end
-      assert_nil(rss.channel.image)
     end
     
     def test_items
@@ -255,16 +274,20 @@ module RSS
 
       rss = RSS::Maker.make("0.91") do |maker|
         setup_dummy_channel(maker)
+        setup_dummy_image(maker)
       end
       assert(rss.channel.items.empty?)
 
       rss = RSS::Maker.make("0.91") do |maker|
         setup_dummy_channel(maker)
         
-        item = maker.items.new_item
-        item.title = title
-        item.link = link
-        # item.description = description
+        maker.items.new_item do |item|
+          item.title = title
+          item.link = link
+          # item.description = description
+        end
+
+        setup_dummy_image(maker)
       end
       assert_equal(1, rss.channel.items.size)
       item = rss.channel.items.first
@@ -278,12 +301,15 @@ module RSS
         setup_dummy_channel(maker)
         
         item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{title}#{i}"
-          item.link = "#{link}#{i}"
-          item.description = "#{description}#{i}"
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+          end
         end
         maker.items.do_sort = true
+
+        setup_dummy_image(maker)
       end
       assert_equal(item_size, rss.items.size)
       rss.channel.items.each_with_index do |item, i|
@@ -296,14 +322,17 @@ module RSS
         setup_dummy_channel(maker)
         
         item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{title}#{i}"
-          item.link = "#{link}#{i}"
-          item.description = "#{description}#{i}"
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+          end
         end
         maker.items.do_sort = Proc.new do |x, y|
-          y.title[-1] <=> x.title[-1]
+          y.title.content[-1] <=> x.title.content[-1]
         end
+
+        setup_dummy_image(maker)
       end
       assert_equal(item_size, rss.items.size)
       rss.channel.items.reverse.each_with_index do |item, i|
@@ -321,6 +350,7 @@ module RSS
 
       rss = RSS::Maker.make("0.91") do |maker|
         setup_dummy_channel(maker)
+        setup_dummy_image(maker)
 
         maker.textinput.title = title
         maker.textinput.description = description
@@ -333,15 +363,17 @@ module RSS
       assert_equal(name, textInput.name)
       assert_equal(link, textInput.link)
 
-      rss = RSS::Maker.make("0.91") do |maker|
-        # setup_dummy_channel(maker)
+      assert_not_set_error("maker.channel",
+                           %w(link language description title)) do
+        RSS::Maker.make("0.91") do |maker|
+          # setup_dummy_channel(maker)
 
-        maker.textinput.title = title
-        maker.textinput.description = description
-        maker.textinput.name = name
-        maker.textinput.link = link
+          maker.textinput.title = title
+          maker.textinput.description = description
+          maker.textinput.name = name
+          maker.textinput.link = link
+        end
       end
-      assert_nil(rss)
     end
     
     def test_not_valid_textInput
@@ -352,6 +384,7 @@ module RSS
 
       rss = RSS::Maker.make("0.91") do |maker|
         setup_dummy_channel(maker)
+        setup_dummy_image(maker)
 
         # maker.textinput.title = title
         maker.textinput.description = description
@@ -362,7 +395,8 @@ module RSS
 
       rss = RSS::Maker.make("0.91") do |maker|
         setup_dummy_channel(maker)
-        
+        setup_dummy_image(maker)
+
         maker.textinput.title = title
         # maker.textinput.description = description
         maker.textinput.name = name
@@ -372,7 +406,8 @@ module RSS
 
       rss = RSS::Maker.make("0.91") do |maker|
         setup_dummy_channel(maker)
-        
+        setup_dummy_image(maker)
+
         maker.textinput.title = title
         maker.textinput.description = description
         # maker.textinput.name = name
@@ -382,7 +417,8 @@ module RSS
 
       rss = RSS::Maker.make("0.91") do |maker|
         setup_dummy_channel(maker)
-        
+        setup_dummy_image(maker)
+
         maker.textinput.title = title
         maker.textinput.description = description
         maker.textinput.name = name
diff --git a/test/rss/test_maker_1.0.rb b/test/rss/test_maker_1.0.rb
index 9d90f3bedd..cc1e58c1a2 100644
--- a/test/rss/test_maker_1.0.rb
+++ b/test/rss/test_maker_1.0.rb
@@ -8,12 +8,15 @@ module RSS
     def test_rdf
       rss = RSS::Maker.make("1.0") do |maker|
         setup_dummy_channel(maker)
+        setup_dummy_item(maker)
       end
       assert_equal("1.0", rss.rss_version)
       
       rss = RSS::Maker.make("1.0") do |maker|
         setup_dummy_channel(maker)
         maker.encoding = "EUC-JP"
+
+        setup_dummy_item(maker)
       end
       assert_equal("1.0", rss.rss_version)
       assert_equal("EUC-JP", rss.encoding)
@@ -21,6 +24,8 @@ module RSS
       rss = RSS::Maker.make("1.0") do |maker|
         setup_dummy_channel(maker)
         maker.standalone = "yes"
+
+        setup_dummy_item(maker)
       end
       assert_equal("1.0", rss.rss_version)
       assert_equal("yes", rss.standalone)
@@ -29,6 +34,8 @@ module RSS
         setup_dummy_channel(maker)
         maker.encoding = "EUC-JP"
         maker.standalone = "yes"
+
+        setup_dummy_item(maker)
       end
       assert_equal("1.0", rss.rss_version)
       assert_equal("EUC-JP", rss.encoding)
@@ -49,13 +56,15 @@ module RSS
         maker.channel.title = title
         maker.channel.link = link
         maker.channel.description = description
+
+        setup_dummy_item(maker)
       end
       channel = rss.channel
       assert_equal(about, channel.about)
       assert_equal(title, channel.title)
       assert_equal(link, channel.link)
       assert_equal(description, channel.description)
-      assert(channel.items.Seq.lis.empty?)
+      assert_equal(1, channel.items.Seq.lis.size)
       assert_nil(channel.image)
       assert_nil(channel.textinput)
 
@@ -68,13 +77,15 @@ module RSS
         setup_dummy_image(maker)
 
         setup_dummy_textinput(maker)
+
+        setup_dummy_item(maker)
       end
       channel = rss.channel
       assert_equal(about, channel.about)
       assert_equal(title, channel.title)
       assert_equal(link, channel.link)
       assert_equal(description, channel.description)
-      assert(channel.items.Seq.lis.empty?)
+      assert_equal(1, channel.items.Seq.lis.size)
       assert_equal(rss.image.about, channel.image.resource)
       assert_equal(rss.textinput.about, channel.textinput.resource)
     end
@@ -134,6 +145,8 @@ module RSS
         
         maker.image.title = title
         maker.image.url = url
+
+        setup_dummy_item(maker)
       end
       image = rss.image
       assert_equal(url, image.about)
@@ -164,6 +177,8 @@ module RSS
         
         # maker.image.url = url
         maker.image.title = title
+
+        setup_dummy_item(maker)
       end
       assert_nil(rss.channel.image)
       assert_nil(rss.image)
@@ -174,6 +189,8 @@ module RSS
         
         maker.image.url = url
         # maker.image.title = title
+
+        setup_dummy_item(maker)
       end
       assert_nil(rss.channel.image)
       assert_nil(rss.image)
@@ -186,27 +203,31 @@ module RSS
           
           maker.image.url = url
           maker.image.title = title
+
+          setup_dummy_item(maker)
         end
       end
     end
-    
+
     def test_items
       title = "TITLE"
       link = "http://hoge.com/"
       description = "text hoge fuga"
 
-      rss = RSS::Maker.make("1.0") do |maker|
-        setup_dummy_channel(maker)
+      assert_not_set_error("maker", %w(items)) do
+        RSS::Maker.make("1.0") do |maker|
+          setup_dummy_channel(maker)
+        end
       end
-      assert(rss.items.empty?)
 
       rss = RSS::Maker.make("1.0") do |maker|
         setup_dummy_channel(maker)
         
-        item = maker.items.new_item
-        item.title = title
-        item.link = link
-        # item.description = description
+        maker.items.new_item do |item|
+          item.title = title
+          item.link = link
+          # item.description = description
+        end
       end
       assert_equal(1, rss.items.size)
       item = rss.items.first
@@ -221,10 +242,11 @@ module RSS
         setup_dummy_channel(maker)
         
         item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{title}#{i}"
-          item.link = "#{link}#{i}"
-          item.description = "#{description}#{i}"
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+          end
         end
         maker.items.do_sort = true
       end
@@ -240,13 +262,14 @@ module RSS
         setup_dummy_channel(maker)
         
         item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{title}#{i}"
-          item.link = "#{link}#{i}"
-          item.description = "#{description}#{i}"
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+          end
         end
         maker.items.do_sort = Proc.new do |x, y|
-          y.title[-1] <=> x.title[-1]
+          y.title.content[-1] <=> x.title.content[-1]
         end
       end
       assert_equal(item_size, rss.items.size)
@@ -262,10 +285,11 @@ module RSS
         setup_dummy_channel(maker)
         
         item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{title}#{i}"
-          item.link = "#{link}#{i}"
-          item.description = "#{description}#{i}"
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+          end
         end
         maker.items.max_size = max_size
       end
@@ -278,28 +302,31 @@ module RSS
       end
 
       max_size = 0
-      rss = RSS::Maker.make("1.0") do |maker|
-        setup_dummy_channel(maker)
-        
-        item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{title}#{i}"
-          item.link = "#{link}#{i}"
-          item.description = "#{description}#{i}"
+      assert_not_set_error("maker", %w(items)) do
+        RSS::Maker.make("1.0") do |maker|
+          setup_dummy_channel(maker)
+
+          item_size.times do |i|
+            maker.items.new_item do |item|
+              item.title = "#{title}#{i}"
+              item.link = "#{link}#{i}"
+              item.description = "#{description}#{i}"
+            end
+          end
+          maker.items.max_size = max_size
         end
-        maker.items.max_size = max_size
       end
-      assert_equal(max_size, rss.items.size)
 
       max_size = -2
       rss = RSS::Maker.make("1.0") do |maker|
         setup_dummy_channel(maker)
         
         item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{title}#{i}"
-          item.link = "#{link}#{i}"
-          item.description = "#{description}#{i}"
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+          end
         end
         maker.items.max_size = max_size
       end
@@ -316,25 +343,40 @@ module RSS
       title = "TITLE"
       link = "http://hoge.com/"
 
-      rss = RSS::Maker.make("1.0") do |maker|
-        setup_dummy_channel(maker)
-        
-        item = maker.items.new_item
-        # item.title = title
-        item.link = link
+      assert_not_set_error("maker.item", %w(title)) do
+        RSS::Maker.make("1.0") do |maker|
+          setup_dummy_channel(maker)
+
+          maker.items.new_item do |item|
+            # item.title = title
+            item.link = link
+          end
+        end
       end
-      assert(rss.items.empty?)
 
-      rss = RSS::Maker.make("1.0") do |maker|
-        setup_dummy_channel(maker)
-        
-        item = maker.items.new_item
-        item.title = title
-        # item.link = link
+      assert_not_set_error("maker.item", %w(link)) do
+        RSS::Maker.make("1.0") do |maker|
+          setup_dummy_channel(maker)
+
+          maker.items.new_item do |item|
+            item.title = title
+            # item.link = link
+          end
+        end
+      end
+
+      assert_not_set_error("maker.item", %w(title link)) do
+        RSS::Maker.make("1.0") do |maker|
+          setup_dummy_channel(maker)
+
+          maker.items.new_item do |item|
+            # item.title = title
+            # item.link = link
+          end
+        end
       end
-      assert(rss.items.empty?)
     end
-    
+
     def test_textinput
       title = "fugafuga"
       description = "text hoge fuga"
@@ -348,6 +390,8 @@ module RSS
         maker.textinput.title = title
         maker.textinput.description = description
         maker.textinput.name = name
+
+        setup_dummy_item(maker)
       end
       textinput = rss.textinput
       assert_equal(link, textinput.about)
@@ -357,15 +401,16 @@ module RSS
       assert_equal(description, textinput.description)
       assert_equal(link, textinput.link)
 
-      rss = RSS::Maker.make("1.0") do |maker|
-        # setup_dummy_channel(maker)
+      assert_not_set_error("maker.channel", %w(about link description title)) do
+        RSS::Maker.make("1.0") do |maker|
+          # setup_dummy_channel(maker)
 
-        maker.textinput.link = link
-        maker.textinput.title = title
-        maker.textinput.description = description
-        maker.textinput.name = name
+          maker.textinput.link = link
+          maker.textinput.title = title
+          maker.textinput.description = description
+          maker.textinput.name = name
+        end
       end
-      assert_nil(rss)
     end
     
     def test_not_valid_textinput
@@ -381,6 +426,8 @@ module RSS
         maker.textinput.title = title
         maker.textinput.description = description
         maker.textinput.name = name
+
+        setup_dummy_item(maker)
       end
       assert_nil(rss.channel.textinput)
       assert_nil(rss.textinput)
@@ -392,6 +439,8 @@ module RSS
         # maker.textinput.title = title
         maker.textinput.description = description
         maker.textinput.name = name
+
+        setup_dummy_item(maker)
       end
       assert_nil(rss.channel.textinput)
       assert_nil(rss.textinput)
@@ -403,6 +452,8 @@ module RSS
         maker.textinput.title = title
         # maker.textinput.description = description
         maker.textinput.name = name
+
+        setup_dummy_item(maker)
       end
       assert_nil(rss.channel.textinput)
       assert_nil(rss.textinput)
@@ -414,6 +465,8 @@ module RSS
         maker.textinput.title = title
         maker.textinput.description = description
         # maker.textinput.name = name
+
+        setup_dummy_item(maker)
       end
       assert_nil(rss.channel.textinput)
       assert_nil(rss.textinput)
diff --git a/test/rss/test_maker_2.0.rb b/test/rss/test_maker_2.0.rb
index 2c581f75ea..605d439a68 100644
--- a/test/rss/test_maker_2.0.rb
+++ b/test/rss/test_maker_2.0.rb
@@ -82,17 +82,20 @@ module RSS
         maker.channel.lastBuildDate = lastBuildDate
 
         skipDays.each do |day|
-          new_day = maker.channel.skipDays.new_day
-          new_day.content = day
+          maker.channel.skipDays.new_day do |new_day|
+            new_day.content = day
+          end
         end
         skipHours.each do |hour|
-          new_hour = maker.channel.skipHours.new_hour
-          new_hour.content = hour
+          maker.channel.skipHours.new_hour do |new_hour|
+            new_hour.content = hour
+          end
         end
         
         categories.each do |category|
-          new_category = maker.channel.categories.new_category
-          new_category.content = category
+          maker.channel.categories.new_category do |new_category|
+            new_category.content = category
+          end
         end
         
         maker.channel.generator = generator
@@ -368,13 +371,14 @@ module RSS
         setup_dummy_channel(maker)
         
         item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{title}#{i}"
-          item.link = "#{link}#{i}"
-          item.description = "#{description}#{i}"
-          item.author = "#{author}#{i}"
-          item.comments = "#{comments}#{i}"
-          item.date = pubDate
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+            item.author = "#{author}#{i}"
+            item.comments = "#{comments}#{i}"
+            item.date = pubDate
+          end
         end
         maker.items.do_sort = true
       end
@@ -393,16 +397,17 @@ module RSS
         setup_dummy_channel(maker)
         
         item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{title}#{i}"
-          item.link = "#{link}#{i}"
-          item.description = "#{description}#{i}"
-          item.author = "#{author}#{i}"
-          item.comments = "#{comments}#{i}"
-          item.date = pubDate
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+            item.author = "#{author}#{i}"
+            item.comments = "#{comments}#{i}"
+            item.date = pubDate
+          end
         end
         maker.items.do_sort = Proc.new do |x, y|
-          y.title[-1] <=> x.title[-1]
+          y.title.content[-1] <=> x.title.content[-1]
         end
       end
       assert_equal(item_size, rss.items.size)
@@ -557,9 +562,10 @@ module RSS
         setup_dummy_channel(maker)
         setup_dummy_item(maker)
 
-        category = maker.items.last.categories.new_category
-        category.domain = domain
-        category.content = content
+        maker.items.last.categories.new_category do |category|
+          category.domain = domain
+          category.content = content
+        end
       end
       category = rss.channel.items.last.categories.last
       assert_equal(domain, category.domain)
@@ -573,8 +579,9 @@ module RSS
         setup_dummy_channel(maker)
         setup_dummy_item(maker)
 
-        category = maker.items.last.categories.new_category
-        # category.content = content
+        maker.items.last.categories.new_category do |category|
+          # category.content = content
+        end
       end
       assert(rss.channel.items.last.categories.empty?)
     end
@@ -599,15 +606,16 @@ module RSS
       assert_equal(name, textInput.name)
       assert_equal(link, textInput.link)
 
-      rss = RSS::Maker.make("2.0") do |maker|
-        # setup_dummy_channel(maker)
+      assert_not_set_error("maker.channel", %w(link description title)) do
+        RSS::Maker.make("2.0") do |maker|
+          # setup_dummy_channel(maker)
 
-        maker.textinput.title = title
-        maker.textinput.description = description
-        maker.textinput.name = name
-        maker.textinput.link = link
+          maker.textinput.title = title
+          maker.textinput.description = description
+          maker.textinput.name = name
+          maker.textinput.link = link
+        end
       end
-      assert_nil(rss)
     end
     
     def test_not_valid_textInput
diff --git a/test/rss/test_maker_atom_entry.rb b/test/rss/test_maker_atom_entry.rb
new file mode 100644
index 0000000000..ae0ab2d09f
--- /dev/null
+++ b/test/rss/test_maker_atom_entry.rb
@@ -0,0 +1,367 @@
+require "rss-testcase"
+
+require "rss/maker"
+
+module RSS
+  class TestMakerAtomEntry < TestCase
+    def test_root_element
+      entry = Maker.make("atom:entry") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+      assert_equal(["atom", "1.0", "entry"], entry.feed_info)
+
+      entry = Maker.make("atom:entry") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+        maker.encoding = "EUC-JP"
+      end
+      assert_equal(["atom", "1.0", "entry"], entry.feed_info)
+      assert_equal("EUC-JP", entry.encoding)
+
+      entry = Maker.make("atom:entry") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+        maker.standalone = "yes"
+      end
+      assert_equal(["atom", "1.0", "entry"], entry.feed_info)
+      assert_equal("yes", entry.standalone)
+
+      entry = Maker.make("atom:entry") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+        maker.encoding = "EUC-JP"
+        maker.standalone = "yes"
+      end
+      assert_equal(["atom", "1.0", "entry"], entry.feed_info)
+      assert_equal("EUC-JP", entry.encoding)
+      assert_equal("yes", entry.standalone)
+    end
+
+    def test_invalid_feed
+      assert_not_set_error("maker.item", %w(id title author updated)) do
+        Maker.make("atom:entry") do |maker|
+        end
+      end
+
+      assert_not_set_error("maker.item", %w(id title updated)) do
+        Maker.make("atom:entry") do |maker|
+          maker.channel.author = "foo"
+        end
+      end
+
+      assert_not_set_error("maker.item", %w(title updated)) do
+        Maker.make("atom:entry") do |maker|
+          maker.channel.author = "foo"
+          maker.channel.id = "http://example.com"
+        end
+      end
+
+      assert_not_set_error("maker.item", %w(updated)) do
+        Maker.make("atom:entry") do |maker|
+          maker.channel.author = "foo"
+          maker.channel.id = "http://example.com"
+          maker.channel.title = "Atom Feed"
+        end
+      end
+
+      assert_not_set_error("maker.item", %w(author)) do
+        Maker.make("atom:entry") do |maker|
+          maker.channel.id = "http://example.com"
+          maker.channel.title = "Atom Feed"
+          maker.channel.updated = Time.now
+        end
+      end
+
+      entry = Maker.make("atom:entry") do |maker|
+        maker.channel.author = "Foo"
+        maker.channel.id = "http://example.com"
+        maker.channel.title = "Atom Feed"
+        maker.channel.updated = Time.now
+      end
+      assert_not_nil(entry)
+    end
+
+    def test_author
+      assert_maker_atom_persons("entry",
+                                ["channel", "authors"],
+                                ["authors"],
+                                "maker.channel.author") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_persons("entry",
+                                ["items", "first", "authors"],
+                                ["authors"],
+                                "maker.item.author",
+                                "maker.item", ["author"]) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+        maker.channel.authors.clear
+        maker.items.first.authors.clear
+      end
+
+      assert_maker_atom_persons("entry",
+                                ["items", "first", "source", "authors"],
+                                ["source", "authors"],
+                                "maker.item.source.author") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_category
+      assert_maker_atom_categories("entry",
+                                   ["channel", "categories"],
+                                   ["categories"],
+                                   "maker.channel.category") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_categories("entry",
+                                   ["items", "first", "categories"],
+                                   ["categories"],
+                                   "maker.item.category") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_categories("entry",
+                                   ["items", "first", "source", "categories"],
+                                   ["source", "categories"],
+                                   "maker.item.source.category") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_content
+      assert_maker_atom_content("entry",
+                                ["items", "first", "content"],
+                                ["content"],
+                                "maker.item.content") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_contributor
+      assert_maker_atom_persons("entry",
+                                ["channel", "contributors"],
+                                ["contributors"],
+                                "maker.channel.contributor") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_persons("entry",
+                                ["items", "first", "contributors"],
+                                ["contributors"],
+                                "maker.item.contributor") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_persons("entry",
+                                ["items", "first", "source", "contributors"],
+                                ["source", "contributors"],
+                                "maker.item.source.contributor") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_link
+      assert_maker_atom_links("entry",
+                              ["channel", "links"],
+                              ["links"],
+                              "maker.channel.link") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+        maker.channel.links.clear
+        maker.items.first.links.clear
+      end
+
+      assert_maker_atom_links("entry",
+                              ["items", "first", "links"],
+                              ["links"],
+                              "maker.item.link") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+        maker.channel.links.clear
+        maker.items.first.links.clear
+      end
+
+      assert_maker_atom_links("entry",
+                              ["items", "first", "source", "links"],
+                              ["source", "links"],
+                              "maker.item.source.link", true) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_published
+      assert_maker_atom_date_construct("entry",
+                                       ["items", "first", "published"],
+                                       ["published"]
+                                       ) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_rights
+      assert_maker_atom_text_construct("entry",
+                                       ["channel", "copyright"],
+                                       ["rights"]) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_text_construct("entry",
+                                       ["items", "first", "rights"],
+                                       ["rights"],
+                                       nil, nil, "maker.item.rights"
+                                       ) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_text_construct("entry",
+                                       ["items", "first", "source", "rights"],
+                                       ["source", "rights"],
+                                       nil, nil, "maker.item.source.rights"
+                                       ) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+
+    def test_source_generator
+      assert_maker_atom_generator("entry",
+                                  ["items", "first", "source", "generator"],
+                                  ["source", "generator"],
+                                  "maker.item.source.generator") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_source_icon
+      assert_maker_atom_icon("entry",
+                             ["items", "first", "source", "icon"],
+                             ["source", "icon"],
+                             nil, "maker.item.source.icon") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_source_id
+      assert_maker_atom_id("entry",
+                           ["items", "first", "source"],
+                           ["source"],
+                           "maker.item.source") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_source_logo
+      assert_maker_atom_logo("entry",
+                             ["items", "first", "source", "logo"],
+                             ["source", "logo"],
+                             nil,
+                             "maker.item.source.logo") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_source_subtitle
+      assert_maker_atom_text_construct("entry",
+                                       ["items", "first", "source", "subtitle"],
+                                       ["source", "subtitle"],
+                                       nil, nil,
+                                       "maker.item.source.subtitle") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_summary
+      assert_maker_atom_text_construct("entry",
+                                       ["items", "first", "description"],
+                                       ["summary"],
+                                       nil, nil, "maker.item.description"
+                                       ) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_title
+      assert_maker_atom_text_construct("entry",
+                                       ["channel", "title"], ["title"],
+                                       "maker.item", ["title"],
+                                       "maker.channel.title") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+        maker.channel.title = nil
+        maker.items.first.title = nil
+      end
+
+      assert_maker_atom_text_construct("entry",
+                                       ["items", "first", "title"],
+                                       ["title"],
+                                       "maker.item", ["title"],
+                                       "maker.item.title") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+        maker.channel.title = nil
+        maker.items.first.title = nil
+      end
+
+      assert_maker_atom_text_construct("entry",
+                                       ["items", "first", "source", "title"],
+                                       ["source", "title"],
+                                       nil, nil, "maker.item.source.title"
+                                       ) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_updated
+      assert_maker_atom_date_construct("entry",
+                                       ["channel", "updated"], ["updated"],
+                                       "maker.item", ["updated"]) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+        maker.channel.updated = nil
+        maker.items.first.updated = nil
+      end
+
+      assert_maker_atom_date_construct("entry",
+                                       ["items", "first", "updated"],
+                                       ["updated"],
+                                       "maker.item", ["updated"]) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+        maker.channel.updated = nil
+        maker.items.first.updated = nil
+      end
+
+      assert_maker_atom_date_construct("entry",
+                                       ["items", "first", "source", "updated"],
+                                       ["source", "updated"]) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+  end
+end
diff --git a/test/rss/test_maker_atom_feed.rb b/test/rss/test_maker_atom_feed.rb
new file mode 100644
index 0000000000..f4c5cc2a3d
--- /dev/null
+++ b/test/rss/test_maker_atom_feed.rb
@@ -0,0 +1,380 @@
+require "rss-testcase"
+
+require "rss/maker"
+
+module RSS
+  class TestMakerAtomFeed < TestCase
+    def test_root_element
+      feed = Maker.make("atom") do |maker|
+        setup_dummy_channel_atom(maker)
+      end
+      assert_equal(["atom", "1.0", "feed"], feed.feed_info)
+
+      feed = Maker.make("atom") do |maker|
+        setup_dummy_channel_atom(maker)
+        maker.encoding = "EUC-JP"
+      end
+      assert_equal(["atom", "1.0", "feed"], feed.feed_info)
+      assert_equal("EUC-JP", feed.encoding)
+
+      feed = Maker.make("atom") do |maker|
+        setup_dummy_channel_atom(maker)
+        maker.standalone = "yes"
+      end
+      assert_equal(["atom", "1.0", "feed"], feed.feed_info)
+      assert_equal("yes", feed.standalone)
+
+      feed = Maker.make("atom") do |maker|
+        setup_dummy_channel_atom(maker)
+        maker.encoding = "EUC-JP"
+        maker.standalone = "yes"
+      end
+      assert_equal(["atom", "1.0", "feed"], feed.feed_info)
+      assert_equal("EUC-JP", feed.encoding)
+      assert_equal("yes", feed.standalone)
+    end
+
+    def test_invalid_feed
+      assert_not_set_error("maker.channel", %w(id title author updated)) do
+        Maker.make("atom") do |maker|
+        end
+      end
+
+      assert_not_set_error("maker.channel", %w(id title updated)) do
+        Maker.make("atom") do |maker|
+          maker.channel.author = "foo"
+        end
+      end
+
+      assert_not_set_error("maker.channel", %w(title updated)) do
+        Maker.make("atom") do |maker|
+          maker.channel.author = "foo"
+          maker.channel.id = "http://example.com"
+        end
+      end
+
+      assert_not_set_error("maker.channel", %w(updated)) do
+        Maker.make("atom") do |maker|
+          maker.channel.author = "foo"
+          maker.channel.id = "http://example.com"
+          maker.channel.title = "Atom Feed"
+        end
+      end
+
+      assert_not_set_error("maker.channel", %w(author)) do
+        Maker.make("atom") do |maker|
+          maker.channel.id = "http://example.com"
+          maker.channel.title = "Atom Feed"
+          maker.channel.updated = Time.now
+        end
+      end
+
+      feed = Maker.make("atom") do |maker|
+        maker.channel.author = "Foo"
+        maker.channel.id = "http://example.com"
+        maker.channel.title = "Atom Feed"
+        maker.channel.updated = Time.now
+      end
+      assert_not_nil(feed)
+    end
+
+    def test_author
+      assert_maker_atom_persons("feed",
+                                ["channel", "authors"],
+                                ["authors"],
+                                "maker.channel.author") do |maker|
+        setup_dummy_channel_atom(maker)
+      end
+
+      assert_not_set_error("maker.channel", %w(author)) do
+        RSS::Maker.make("atom") do |maker|
+          setup_dummy_channel_atom(maker)
+          setup_dummy_item_atom(maker)
+          maker.channel.authors.clear
+        end
+      end
+
+      assert_maker_atom_persons("feed",
+                                ["items", "first", "authors"],
+                                ["entries", "first", "authors"],
+                                "maker.item.author") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_persons("feed",
+                                ["items", "first", "source", "authors"],
+                                ["entries", "first", "source", "authors"],
+                                "maker.item.source.author") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_category
+      assert_maker_atom_categories("feed",
+                                   ["channel", "categories"],
+                                   ["categories"],
+                                   "maker.channel.category") do |maker|
+        setup_dummy_channel_atom(maker)
+      end
+
+      assert_maker_atom_categories("feed",
+                                   ["items", "first", "categories"],
+                                   ["entries", "first", "categories"],
+                                   "maker.item.category") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_categories("feed",
+                                   ["items", "first", "source", "categories"],
+                                   ["entries", "first", "source", "categories"],
+                                   "maker.item.source.category") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_contributor
+      assert_maker_atom_persons("feed",
+                                ["channel", "contributors"],
+                                ["contributors"],
+                                "maker.channel.contributor") do |maker|
+        setup_dummy_channel_atom(maker)
+      end
+
+      assert_maker_atom_persons("feed",
+                                ["items", "first", "contributors"],
+                                ["entries", "first", "contributors"],
+                                "maker.item.contributor") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_persons("feed",
+                                ["items", "first", "source", "contributors"],
+                                ["entries", "first", "source", "contributors"],
+                                "maker.item.source.contributor") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_generator
+      assert_maker_atom_generator("feed",
+                                  ["channel", "generator"],
+                                  ["generator"]) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_generator("feed",
+                                  ["items", "first", "source", "generator"],
+                                  ["entries", "first", "source", "generator"],
+                                  "maker.item.source.generator") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_icon
+      assert_maker_atom_icon("feed", ["channel"], ["icon"], "icon") do |maker|
+        setup_dummy_channel_atom(maker)
+      end
+
+      assert_maker_atom_icon("feed",
+                             ["items", "first", "source", "icon"],
+                             ["entries", "first", "source", "icon"],
+                             nil, "maker.item.source.icon") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_link
+      assert_maker_atom_links("feed",
+                              ["channel", "links"],
+                              ["links"],
+                              "maker.channel.link") do |maker|
+        setup_dummy_channel_atom(maker)
+      end
+
+      assert_maker_atom_links("feed",
+                              ["items", "first", "links"],
+                              ["entries", "first", "links"],
+                              "maker.item.link") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_links("feed",
+                              ["items", "first", "source", "links"],
+                              ["entries", "first", "source", "links"],
+                              "maker.item.source.link", true) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_logo
+      assert_maker_atom_logo("feed", ["channel"], ["logo"], "logo") do |maker|
+        setup_dummy_channel_atom(maker)
+      end
+
+      assert_maker_atom_logo("feed", ["image"], ["logo"], "url") do |maker|
+        setup_dummy_channel_atom(maker)
+      end
+
+      assert_maker_atom_logo("feed",
+                             ["items", "first", "source", "logo"],
+                             ["entries", "first", "source", "logo"],
+                             nil, "maker.item.source.logo") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_rights
+      assert_maker_atom_text_construct("feed",
+                                       ["channel", "copyright"],
+                                       ["rights"]) do |maker|
+        setup_dummy_channel_atom(maker)
+      end
+
+      assert_maker_atom_text_construct("feed",
+                                       ["items", "first", "rights"],
+                                       ["entries", "first", "rights"],
+                                       nil, nil, "maker.item.rights"
+                                       ) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+
+      assert_maker_atom_text_construct("feed",
+                                       ["items", "first", "source", "rights"],
+                                       ["entries", "first", "source", "rights"],
+                                       nil, nil, "maker.item.source.rights"
+                                       ) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_subtitle
+      assert_maker_atom_text_construct("feed",
+                                       ["channel", "subtitle"],
+                                       ["subtitle"],
+                                       nil, nil,
+                                       "maker.channel.description") do |maker|
+        setup_dummy_channel_atom(maker)
+        maker.channel.description.content = nil
+      end
+
+      assert_maker_atom_text_construct("feed",
+                                       ["items", "first", "source", "subtitle"],
+                                       ["entries", "first",
+                                        "source", "subtitle"],
+                                       nil, nil,
+                                       "maker.item.source.subtitle") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_title
+      assert_maker_atom_text_construct("feed",
+                                       ["channel", "title"], ["title"],
+                                       "maker.channel", ["title"]) do |maker|
+        setup_dummy_channel_atom(maker)
+        maker.channel.title = nil
+      end
+
+      assert_maker_atom_text_construct("feed",
+                                       ["items", "first", "title"],
+                                       ["entries", "first", "title"],
+                                       "maker.item", ["title"],
+                                       "maker.item.title") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+        maker.items.first.title = nil
+      end
+
+      assert_maker_atom_text_construct("feed",
+                                       ["items", "first", "source", "title"],
+                                       ["entries", "first", "source", "title"],
+                                       nil, nil, "maker.item.source.title"
+                                       ) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_updated
+      assert_maker_atom_date_construct("feed",
+                                       ["channel", "updated"], ["updated"],
+                                       "maker.channel", ["updated"]) do |maker|
+        setup_dummy_channel_atom(maker)
+        maker.channel.updated = nil
+      end
+
+      assert_maker_atom_date_construct("feed",
+                                       ["items", "first", "updated"],
+                                       ["entries", "first", "updated"],
+                                       "maker.item", ["updated"]) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+        maker.items.first.updated = nil
+      end
+
+      assert_maker_atom_date_construct("feed",
+                                       ["items", "first", "source", "updated"],
+                                       ["entries", "first", "source", "updated"]
+                                       ) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_published
+      assert_maker_atom_date_construct("feed",
+                                       ["items", "first", "published"],
+                                       ["entries", "first", "published"]
+                                       ) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_summary
+      assert_maker_atom_text_construct("feed",
+                                       ["items", "first", "description"],
+                                       ["entries", "first", "summary"],
+                                       nil, nil, "maker.item.description"
+                                       ) do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_content
+      assert_maker_atom_content("feed",
+                                ["items", "first", "content"],
+                                ["entries", "first", "content"],
+                                "maker.item.content") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+
+    def test_id
+      assert_maker_atom_id("feed",
+                           ["items", "first", "source"],
+                           ["entries", "first", "source"],
+                           "maker.item.source") do |maker|
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+    end
+  end
+end
diff --git a/test/rss/test_maker_dc.rb b/test/rss/test_maker_dc.rb
index 37a7f2bb1d..72a967231a 100644
--- a/test/rss/test_maker_dc.rb
+++ b/test/rss/test_maker_dc.rb
@@ -107,14 +107,16 @@ module RSS
       rss = RSS::Maker.make("1.0") do |maker|
         setup_dummy_channel(maker)
         maker.channel.date = t1
-        date = maker.channel.dc_dates.new_date
-        date.value = t2
+        maker.channel.dc_dates.new_date do |date|
+          date.value = t2
+        end
 
         setup_dummy_item(maker)
         item = maker.items.last
         item.date = t2
-        date = item.dc_dates.new_date
-        date.value = t1
+        item.dc_dates.new_date do |date|
+          date.value = t1
+        end
       end
       assert_equal([t1, t2], rss.channel.dc_dates.collect{|x| x.value})
       assert_equal([t2, t1], rss.items.last.dc_dates.collect{|x| x.value})
@@ -136,8 +138,9 @@ module RSS
         plural ||= "#{name}s"
         dc_elems = target.__send__("dc_#{plural}")
         values.each do |value|
-          new_dc_elem = dc_elems.__send__("new_#{name}")
-          new_dc_elem.value = value
+          dc_elems.__send__("new_#{name}") do |new_dc_elem|
+            new_dc_elem.value = value
+          end
         end
       end
     end
diff --git a/test/rss/test_maker_sy.rb b/test/rss/test_maker_sy.rb
index fd6df9a0eb..309a3b70fd 100644
--- a/test/rss/test_maker_sy.rb
+++ b/test/rss/test_maker_sy.rb
@@ -24,6 +24,7 @@ module RSS
       rss = RSS::Maker.make("1.0") do |maker|
         setup_dummy_channel(maker)
         set_elements(maker.channel)
+        setup_dummy_item(maker)
       end
       assert_syndication(@elements, rss.channel)
     end
diff --git a/test/rss/test_maker_taxo.rb b/test/rss/test_maker_taxo.rb
index 1c7d2844ce..8feb4e1d33 100644
--- a/test/rss/test_maker_taxo.rb
+++ b/test/rss/test_maker_taxo.rb
@@ -56,14 +56,16 @@ module RSS
       rss = RSS::Maker.make("1.0") do |maker|
         setup_dummy_channel(maker)
         maker.channel.date = t1
-        date = maker.channel.dc_dates.new_date
-        date.value = t2
+        maker.channel.dc_dates.new_date do |date|
+          date.value = t2
+        end
 
         setup_dummy_item(maker)
         item = maker.items.last
         item.date = t2
-        date = item.dc_dates.new_date
-        date.value = t1
+        item.dc_dates.new_date do |date|
+          date.value = t1
+        end
       end
       assert_equal([t1, t2], rss.channel.dc_dates.collect{|x| x.value})
       assert_equal([t2, t1], rss.items.last.dc_dates.collect{|x| x.value})
diff --git a/test/rss/test_maker_trackback.rb b/test/rss/test_maker_trackback.rb
index e90bb600a3..58705c6f80 100644
--- a/test/rss/test_maker_trackback.rb
+++ b/test/rss/test_maker_trackback.rb
@@ -25,8 +25,9 @@ module RSS
         item = maker.items.last
         item.trackback_ping = @elements[:ping]
         @elements[:abouts].each do |about|
-          new_about = item.trackback_abouts.new_about
-          new_about.value = about
+          item.trackback_abouts.new_about do |new_about|
+            new_about.value = about
+          end
         end
       end
       assert_trackback(@elements, rss.items.last)
diff --git a/test/rss/test_maker_xml-stylesheet.rb b/test/rss/test_maker_xml-stylesheet.rb
index bbdfdc682b..9d45e52038 100644
--- a/test/rss/test_maker_xml-stylesheet.rb
+++ b/test/rss/test_maker_xml-stylesheet.rb
@@ -14,15 +14,17 @@ module RSS
       alternate = 'yes'
 
       rss = RSS::Maker.make("1.0") do |maker|
-        xss = maker.xml_stylesheets.new_xml_stylesheet
-        xss.href = href
-        xss.type = type
-        xss.title = title
-        xss.media = media
-        xss.charset = charset
-        xss.alternate = alternate
-        
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+          xss.type = type
+          xss.title = title
+          xss.media = media
+          xss.charset = charset
+          xss.alternate = alternate
+        end
+
         setup_dummy_channel(maker)
+        setup_dummy_item(maker)
       end
 
       xss = rss.xml_stylesheets.first
@@ -37,10 +39,12 @@ module RSS
       href = 'http://example.com/index.xsl'
       type = 'text/xsl'
       rss = RSS::Maker.make("1.0") do |maker|
-        xss = maker.xml_stylesheets.new_xml_stylesheet
-        xss.href = href
-        
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+        end
+
         setup_dummy_channel(maker)
+        setup_dummy_item(maker)
       end
 
       xss = rss.xml_stylesheets.first
@@ -53,20 +57,24 @@ module RSS
       type = "text/xsl"
       
       rss = RSS::Maker.make("1.0") do |maker|
-        xss = maker.xml_stylesheets.new_xml_stylesheet
-        # xss.href = href
-        xss.type = type
-        
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          # xss.href = href
+          xss.type = type
+        end
+
         setup_dummy_channel(maker)
+        setup_dummy_item(maker)
       end
       assert(rss.xml_stylesheets.empty?)
 
       rss = RSS::Maker.make("1.0") do |maker|
-        xss = maker.xml_stylesheets.new_xml_stylesheet
-        xss.href = href
-        # xss.type = type
-        
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+          # xss.type = type
+        end
+
         setup_dummy_channel(maker)
+        setup_dummy_item(maker)
       end
       assert(rss.xml_stylesheets.empty?)
     end
diff --git a/test/rss/test_parser.rb b/test/rss/test_parser.rb
index f410b1b4f0..49b441bf96 100644
--- a/test/rss/test_parser.rb
+++ b/test/rss/test_parser.rb
@@ -13,12 +13,10 @@ end
 require "rss-testcase"
 
 require "rss/1.0"
-require "rss/2.0"
 require "rss/dublincore"
 
 module RSS
   class TestParser < TestCase
-    
     def setup
       @_default_parser = Parser.default_parser
       @rss10 = make_RDF(<<-EOR)
@@ -35,588 +33,6 @@ EOR
       Parser.default_parser = @_default_parser
       FileUtils.rm_f(@rss_file)
     end
-    
-    def test_RDF
-      assert_ns("", RDF::URI) do
-        Parser.parse(<<-EOR)
-#{make_xmldecl}
-<RDF/>
-EOR
-      end 
-
-      assert_ns("", RDF::URI) do
-        Parser.parse(<<-EOR)
-#{make_xmldecl}
-<RDF xmlns="hoge"/>
-EOR
-      end 
-
-      assert_ns("rdf", RDF::URI) do
-        Parser.parse(<<-EOR)
-#{make_xmldecl}
-<rdf:RDF xmlns:rdf="hoge"/>
-EOR
-      end
-
-      assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
-#{make_xmldecl}
-<rdf:RDF xmlns:rdf="#{RSS::RDF::URI}"/>
-EOR
-
-      assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
-#{make_xmldecl}
-<RDF xmlns="#{RSS::RDF::URI}"/>
-EOR
-
-      assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
-#{make_xmldecl}
-<RDF xmlns="#{RSS::RDF::URI}"/>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
-#{make_channel}
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
-#{make_channel}
-#{make_image}
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
-#{make_channel}
-#{make_textinput}
-EOR
-
-      assert_too_much_tag("image", "RDF") do
-        Parser.parse(make_RDF(<<-EOR))
-#{make_channel}
-#{make_image}
-#{make_image}
-#{make_item}
-#{make_textinput}
-EOR
-      end
-
-      assert_parse(make_RDF(<<-EOR), :nothing_raised)
-#{make_channel}
-#{make_item}
-#{make_image}
-#{make_textinput}
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :nothing_raised)
-#{make_channel}
-#{make_item}
-#{make_textinput}
-#{make_image}
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :nothing_raised)
-#{make_channel}
-#{make_image}
-#{make_item}
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :nothing_raised)
-#{make_channel}
-#{make_image}
-#{make_item}
-#{make_textinput}
-EOR
-
-      1.step(15, 3) do |i|
-        rss = make_RDF() do
-          res = make_channel
-          i.times { res << make_item }
-          res
-        end
-        assert_parse(rss, :nothing_raised)
-      end
-    end
-
-    def test_undefined_entity
-      return unless RSS::Parser.default_parser.raise_for_undefined_entity?
-      assert_parse(make_RDF(<<-EOR), :raises, RSS::NotWellFormedError)
-#{make_channel}
-#{make_image}
-<item rdf:about="#{RDF_ABOUT}">
-  <title>#{TITLE_VALUE} &UNKNOWN_ENTITY;</title>
-  <link>#{LINK_VALUE}</link>
-  <description>#{DESCRIPTION_VALUE}</description>
-</item>
-#{make_textinput}
-EOR
-    end
-
-    def test_channel
-
-      assert_parse(make_RDF(<<-EOR), :missing_attribute, "channel", "rdf:about")
-<channel />
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "channel")
-<channel rdf:about="http://example.com/"/>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "channel")
-<channel rdf:about="http://example.com/">
-  <title>hoge</title>
-</channel>
-EOR
-
-      assert_parse(make_RDF(<<EOR), :missing_tag, "description", "channel")
-<channel rdf:about="http://example.com/">
-  <title>hoge</title>
-  <link>http://example.com/</link>
-</channel>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel")
-<channel rdf:about="http://example.com/">
-  <title>hoge</title>
-  <link>http://example.com/</link>
-  <description>hogehoge</description>
-</channel>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "rdf:resource")
-<channel rdf:about="http://example.com/">
-  <title>hoge</title>
-  <link>http://example.com/</link>
-  <description>hogehoge</description>
-  <image/>
-</channel>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel")
-<channel rdf:about="http://example.com/">
-  <title>hoge</title>
-  <link>http://example.com/</link>
-  <description>hogehoge</description>
-  <image rdf:resource="http://example.com/hoge.png" />
-</channel>
-EOR
-
-      rss = make_RDF(<<-EOR)
-<channel rdf:about="http://example.com/">
-  <title>hoge</title>
-  <link>http://example.com/</link>
-  <description>hogehoge</description>
-  <image rdf:resource="http://example.com/hoge.png" />
-  <items/>
-</channel>
-EOR
-
-      assert_missing_tag("Seq", "items") do
-        Parser.parse(rss)
-      end
-
-      assert_missing_tag("item", "RDF") do
-        Parser.parse(rss, false).validate
-      end
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
-<channel rdf:about="http://example.com/">
-  <title>hoge</title>
-  <link>http://example.com/</link>
-  <description>hogehoge</description>
-  <image rdf:resource="http://example.com/hoge.png" />
-  <items>
-    <rdf:Seq>
-    </rdf:Seq>
-  </items>
-</channel>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "rdf:resource")
-<channel rdf:about="http://example.com/">
-  <title>hoge</title>
-  <link>http://example.com/</link>
-  <description>hogehoge</description>
-  <image rdf:resource="http://example.com/hoge.png" />
-  <items>
-    <rdf:Seq>
-    </rdf:Seq>
-  </items>
-  <textinput/>
-</channel>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
-<channel rdf:about="http://example.com/">
-  <title>hoge</title>
-  <link>http://example.com/</link>
-  <description>hogehoge</description>
-  <image rdf:resource="http://example.com/hoge.png" />
-  <items>
-    <rdf:Seq>
-    </rdf:Seq>
-  </items>
-  <textinput rdf:resource="http://example.com/search" />
-</channel>
-EOR
-
-    end
-
-    def test_rdf_li
-
-      rss = make_RDF(<<-EOR)
-<channel rdf:about="http://example.com/">
-  <title>hoge</title>
-  <link>http://example.com/</link>
-  <description>hogehoge</description>
-  <image rdf:resource="http://example.com/hoge.png" />
-  <items>
-    <rdf:Seq>
-      <rdf:li \#{rdf_li_attr}/>
-    </rdf:Seq>
-  </items>
-  <textinput rdf:resource="http://example.com/search" />
-</channel>
-#{make_item}
-EOR
-
-      source = Proc.new do |rdf_li_attr|
-        eval(%Q[%Q[#{rss}]], binding)
-      end
-
-      attr = %q[resource="http://example.com/hoge"]
-      assert_parse(source.call(attr), :nothing_raised)
-
-      attr = %q[rdf:resource="http://example.com/hoge"]
-      assert_parse(source.call(attr), :nothing_raised)
-
-      assert_parse(source.call(""), :missing_attribute, "li", "resource")
-    end
-
-    def test_image
-
-      assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "rdf:about")
-#{make_channel}
-<image>
-</image>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "image")
-#{make_channel}
-<image rdf:about="http://example.com/hoge.png">
-</image>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "url", "image")
-#{make_channel}
-<image rdf:about="http://example.com/hoge.png">
-  <title>hoge</title>
-</image>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "image")
-#{make_channel}
-<image rdf:about="http://example.com/hoge.png">
-  <title>hoge</title>
-  <url>http://example.com/hoge.png</url>
-</image>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
-#{make_channel}
-<image rdf:about="http://example.com/hoge.png">
-  <title>hoge</title>
-  <url>http://example.com/hoge.png</url>
-  <link>http://example.com/</link>
-</image>
-EOR
-
-      rss = make_RDF(<<-EOR)
-#{make_channel}
-<image rdf:about="http://example.com/hoge.png">
-  <link>http://example.com/</link>
-  <url>http://example.com/hoge.png</url>
-  <title>hoge</title>
-</image>
-EOR
-
-      assert_missing_tag("item", "RDF") do
-        Parser.parse(rss)
-      end
-
-      assert_missing_tag("item", "RDF") do
-        Parser.parse(rss, false).validate
-      end
-
-    end
-
-    def test_item
-
-      assert_parse(make_RDF(<<-EOR), :missing_attribute, "item", "rdf:about")
-#{make_channel}
-#{make_image}
-<item>
-</item>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "item")
-#{make_channel}
-#{make_image}
-<item rdf:about="http://example.com/hoge.html">
-</item>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "item")
-#{make_channel}
-#{make_image}
-<item rdf:about="http://example.com/hoge.html">
-  <title>hoge</title>
-</item>
-EOR
-
-      assert_too_much_tag("title", "item") do
-        Parser.parse(make_RDF(<<-EOR))
-#{make_channel}
-#{make_image}
-<item rdf:about="http://example.com/hoge.html">
-  <title>hoge</title>
-  <title>hoge</title>
-  <link>http://example.com/hoge.html</link>
-</item>
-EOR
-      end
-
-      assert_parse(make_RDF(<<-EOR), :nothing_raised)
-#{make_channel}
-#{make_image}
-<item rdf:about="http://example.com/hoge.html">
-  <title>hoge</title>
-  <link>http://example.com/hoge.html</link>
-</item>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :nothing_raised)
-#{make_channel}
-#{make_image}
-<item rdf:about="http://example.com/hoge.html">
-  <title>hoge</title>
-  <link>http://example.com/hoge.html</link>
-  <description>hogehoge</description>
-</item>
-EOR
-
-    end
-
-    def test_textinput
-
-      assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "rdf:about")
-#{make_channel}
-#{make_image}
-#{make_item}
-<textinput>
-</textinput>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "textinput")
-#{make_channel}
-#{make_image}
-#{make_item}
-<textinput rdf:about="http://example.com/search.html">
-</textinput>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "description", "textinput")
-#{make_channel}
-#{make_image}
-#{make_item}
-<textinput rdf:about="http://example.com/search.html">
-  <title>hoge</title>
-</textinput>
-EOR
-
-      assert_too_much_tag("title", "textinput") do
-        Parser.parse(make_RDF(<<-EOR))
-#{make_channel}
-#{make_image}
-#{make_item}
-<textinput rdf:about="http://example.com/search.html">
-  <title>hoge</title>
-  <title>hoge</title>
-  <description>hogehoge</description>
-</textinput>
-EOR
-      end
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "name", "textinput")
-#{make_channel}
-#{make_image}
-#{make_item}
-<textinput rdf:about="http://example.com/search.html">
-  <title>hoge</title>
-  <description>hogehoge</description>
-</textinput>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "textinput")
-#{make_channel}
-#{make_image}
-#{make_item}
-<textinput rdf:about="http://example.com/search.html">
-  <title>hoge</title>
-  <description>hogehoge</description>
-  <name>key</name>
-</textinput>
-EOR
-
-      assert_parse(make_RDF(<<-EOR), :nothing_raised)
-#{make_channel}
-#{make_image}
-#{make_item}
-<textinput rdf:about="http://example.com/search.html">
-  <title>hoge</title>
-  <description>hogehoge</description>
-  <name>key</name>
-  <link>http://example.com/search.html</link>
-</textinput>
-EOR
-
-    end
-
-    def test_rss20
-      
-      assert_parse(make_rss20(<<-EOR), :missing_tag, "channel", "rss")
-EOR
-
-      assert_parse(make_rss20(<<-EOR), :nothing_raised)
-#{make_channel20("")}
-EOR
-
-    end
-
-    def test_cloud20
-
-      attrs = [
-        ["domain", CLOUD_DOMAIN],
-        ["port", CLOUD_PORT],
-        ["path", CLOUD_PATH],
-        ["registerProcedure", CLOUD_REGISTER_PROCEDURE],
-        ["protocol", CLOUD_PROTOCOL],
-      ]
-      
-      (attrs.size + 1).times do |i|
-        missing_attr = attrs[i]
-        if missing_attr
-          meth = :missing_attribute
-          args = ["cloud", missing_attr[0]]
-        else
-          meth = :nothing_raised
-          args = []
-        end
-
-        cloud_attrs = []
-        attrs.each_with_index do |attr, j|
-          unless i == j
-            cloud_attrs << %Q[#{attr[0]}="#{attr[1]}"]
-          end
-        end
-
-        assert_parse(make_rss20(<<-EOR), meth, *args)
-#{make_channel20(%Q[<cloud #{cloud_attrs.join("\n")}/>])}
-EOR
-
-      end
-
-    end
-
-    def test_source20
-
-        assert_parse(make_rss20(<<-EOR), :missing_attribute, "source", "url")
-#{make_channel20(make_item20(%Q[<source>Example</source>]))}
-EOR
-
-        assert_parse(make_rss20(<<-EOR), :nothing_raised)
-#{make_channel20(make_item20(%Q[<source url="http://example.com/" />]))}
-EOR
-
-        assert_parse(make_rss20(<<-EOR), :nothing_raised)
-#{make_channel20(make_item20(%Q[<source url="http://example.com/">Example</source>]))}
-EOR
-    end
-
-    def test_enclosure20
-
-      attrs = [
-        ["url", ENCLOSURE_URL],
-        ["length", ENCLOSURE_LENGTH],
-        ["type", ENCLOSURE_TYPE],
-      ]
-      
-      (attrs.size + 1).times do |i|
-        missing_attr = attrs[i]
-        if missing_attr
-          meth = :missing_attribute
-          args = ["enclosure", missing_attr[0]]
-        else
-          meth = :nothing_raised
-          args = []
-        end
-
-        enclosure_attrs = []
-        attrs.each_with_index do |attr, j|
-          unless i == j
-            enclosure_attrs << %Q[#{attr[0]}="#{attr[1]}"]
-          end
-        end
-
-        assert_parse(make_rss20(<<-EOR), meth, *args)
-#{make_channel20(%Q[
-#{make_item20(%Q[
-<enclosure
-  #{enclosure_attrs.join("\n")} />
-    ])}
-  ])}
-EOR
-
-      end
-
-    end
-
-    def test_category20
-      values = [nil, CATEGORY_DOMAIN]
-      
-      values.each do |value|
-        domain = ""
-        domain << %Q[domain="#{value}"] if value
-
-        ["", "Example Text"].each do |text|
-          rss_src = make_rss20(<<-EOR)
-#{make_channel20(%Q[
-#{make_item20(%Q[
-<category #{domain}>#{text}</category>
-    ])}
-  ])}
-EOR
-          assert_parse(rss_src, :nothing_raised)
-
-          rss = RSS::Parser.parse(rss_src)
-          category = rss.items.last.categories.first
-          assert_equal(value, category.domain)
-          assert_equal(text, category.content)
-        end
-      end
-    end
-
-    def test_ignore
-
-      rss = make_RDF(<<-EOR)
-#{make_channel}
-#{make_item}
-<a/>
-EOR
-
-      assert_parse(rss, :nothing_raised)
-
-      assert_not_excepted_tag("a", "RDF") do
-        Parser.parse(rss, true, false)
-      end
-
-    end
 
     def test_default_parser
       assert_nothing_raised do
@@ -640,7 +56,5 @@ EOR
         assert_nil(RSS::Parser.parse(garbage_rss_file))
       end
     end
-    
   end
 end
-
diff --git a/test/rss/test_parser_1.0.rb b/test/rss/test_parser_1.0.rb
new file mode 100644
index 0000000000..472602b04a
--- /dev/null
+++ b/test/rss/test_parser_1.0.rb
@@ -0,0 +1,503 @@
+require "rss-testcase"
+
+require "rss/1.0"
+require "rss/dublincore"
+
+module RSS
+  class TestParser10 < TestCase
+    def test_RDF
+      assert_ns("", RDF::URI) do
+        Parser.parse(<<-EOR)
+#{make_xmldecl}
+<RDF/>
+EOR
+      end
+
+      assert_ns("", RDF::URI) do
+        Parser.parse(<<-EOR)
+#{make_xmldecl}
+<RDF xmlns="hoge"/>
+EOR
+      end
+
+      assert_ns("rdf", RDF::URI) do
+        Parser.parse(<<-EOR)
+#{make_xmldecl}
+<rdf:RDF xmlns:rdf="hoge"/>
+EOR
+      end
+
+      assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
+#{make_xmldecl}
+<rdf:RDF xmlns:rdf="#{RSS::RDF::URI}"/>
+EOR
+
+      assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
+#{make_xmldecl}
+<RDF xmlns="#{RSS::RDF::URI}"/>
+EOR
+
+      assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
+#{make_xmldecl}
+<RDF xmlns="#{RSS::RDF::URI}"/>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
+#{make_channel}
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
+#{make_channel}
+#{make_image}
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
+#{make_channel}
+#{make_textinput}
+EOR
+
+      assert_too_much_tag("image", "RDF") do
+        Parser.parse(make_RDF(<<-EOR))
+#{make_channel}
+#{make_image}
+#{make_image}
+#{make_item}
+#{make_textinput}
+EOR
+      end
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_item}
+#{make_image}
+#{make_textinput}
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_item}
+#{make_textinput}
+#{make_image}
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_image}
+#{make_item}
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_image}
+#{make_item}
+#{make_textinput}
+EOR
+
+      1.step(15, 3) do |i|
+        rss = make_RDF() do
+          res = make_channel
+          i.times { res << make_item }
+          res
+        end
+        assert_parse(rss, :nothing_raised)
+      end
+    end
+
+    def test_undefined_entity
+      return unless RSS::Parser.default_parser.raise_for_undefined_entity?
+      assert_parse(make_RDF(<<-EOR), :raises, RSS::NotWellFormedError)
+#{make_channel}
+#{make_image}
+<item rdf:about="#{RDF_ABOUT}">
+  <title>#{TITLE_VALUE} &UNKNOWN_ENTITY;</title>
+  <link>#{LINK_VALUE}</link>
+  <description>#{DESCRIPTION_VALUE}</description>
+</item>
+#{make_textinput}
+EOR
+    end
+
+    def test_channel
+      assert_parse(make_RDF(<<-EOR), :missing_attribute, "channel", "rdf:about")
+<channel />
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "channel")
+<channel rdf:about="http://example.com/"/>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "channel")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+</channel>
+EOR
+
+      assert_parse(make_RDF(<<EOR), :missing_tag, "description", "channel")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+</channel>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+</channel>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "rdf:resource")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image/>
+</channel>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image rdf:resource="http://example.com/hoge.png" />
+</channel>
+EOR
+
+      rss = make_RDF(<<-EOR)
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image rdf:resource="http://example.com/hoge.png" />
+  <items/>
+</channel>
+EOR
+
+      assert_missing_tag("Seq", "items") do
+        Parser.parse(rss)
+      end
+
+      assert_missing_tag("item", "RDF") do
+        Parser.parse(rss, false).validate
+      end
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image rdf:resource="http://example.com/hoge.png" />
+  <items>
+    <rdf:Seq>
+    </rdf:Seq>
+  </items>
+</channel>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "rdf:resource")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image rdf:resource="http://example.com/hoge.png" />
+  <items>
+    <rdf:Seq>
+    </rdf:Seq>
+  </items>
+  <textinput/>
+</channel>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image rdf:resource="http://example.com/hoge.png" />
+  <items>
+    <rdf:Seq>
+    </rdf:Seq>
+  </items>
+  <textinput rdf:resource="http://example.com/search" />
+</channel>
+EOR
+    end
+
+    def test_rdf_li
+      rss = make_RDF(<<-EOR)
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image rdf:resource="http://example.com/hoge.png" />
+  <items>
+    <rdf:Seq>
+      <rdf:li \#{rdf_li_attr}/>
+    </rdf:Seq>
+  </items>
+  <textinput rdf:resource="http://example.com/search" />
+</channel>
+#{make_item}
+EOR
+
+      source = Proc.new do |rdf_li_attr|
+        eval(%Q[%Q[#{rss}]], binding)
+      end
+
+      attr = %q[resource="http://example.com/hoge"]
+      assert_parse(source.call(attr), :nothing_raised)
+
+      attr = %q[rdf:resource="http://example.com/hoge"]
+      assert_parse(source.call(attr), :nothing_raised)
+
+      assert_parse(source.call(""), :missing_attribute, "li", "resource")
+    end
+
+    def test_image
+      assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "rdf:about")
+#{make_channel}
+<image>
+</image>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "image")
+#{make_channel}
+<image rdf:about="http://example.com/hoge.png">
+</image>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "url", "image")
+#{make_channel}
+<image rdf:about="http://example.com/hoge.png">
+  <title>hoge</title>
+</image>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "image")
+#{make_channel}
+<image rdf:about="http://example.com/hoge.png">
+  <title>hoge</title>
+  <url>http://example.com/hoge.png</url>
+</image>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
+#{make_channel}
+<image rdf:about="http://example.com/hoge.png">
+  <title>hoge</title>
+  <url>http://example.com/hoge.png</url>
+  <link>http://example.com/</link>
+</image>
+EOR
+
+      rss = make_RDF(<<-EOR)
+#{make_channel}
+<image rdf:about="http://example.com/hoge.png">
+  <link>http://example.com/</link>
+  <url>http://example.com/hoge.png</url>
+  <title>hoge</title>
+</image>
+EOR
+
+      assert_missing_tag("item", "RDF") do
+        Parser.parse(rss)
+      end
+
+      assert_missing_tag("item", "RDF") do
+        Parser.parse(rss, false).validate
+      end
+    end
+
+    def test_item
+      assert_parse(make_RDF(<<-EOR), :missing_attribute, "item", "rdf:about")
+#{make_channel}
+#{make_image}
+<item>
+</item>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "item")
+#{make_channel}
+#{make_image}
+<item rdf:about="http://example.com/hoge.html">
+</item>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "item")
+#{make_channel}
+#{make_image}
+<item rdf:about="http://example.com/hoge.html">
+  <title>hoge</title>
+</item>
+EOR
+
+      assert_too_much_tag("title", "item") do
+        Parser.parse(make_RDF(<<-EOR))
+#{make_channel}
+#{make_image}
+<item rdf:about="http://example.com/hoge.html">
+  <title>hoge</title>
+  <title>hoge</title>
+  <link>http://example.com/hoge.html</link>
+</item>
+EOR
+      end
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_image}
+<item rdf:about="http://example.com/hoge.html">
+  <title>hoge</title>
+  <link>http://example.com/hoge.html</link>
+</item>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_image}
+<item rdf:about="http://example.com/hoge.html">
+  <title>hoge</title>
+  <link>http://example.com/hoge.html</link>
+  <description>hogehoge</description>
+</item>
+EOR
+    end
+
+    def test_textinput
+      assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "rdf:about")
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput>
+</textinput>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "textinput")
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput rdf:about="http://example.com/search.html">
+</textinput>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "description", "textinput")
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput rdf:about="http://example.com/search.html">
+  <title>hoge</title>
+</textinput>
+EOR
+
+      assert_too_much_tag("title", "textinput") do
+        Parser.parse(make_RDF(<<-EOR))
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput rdf:about="http://example.com/search.html">
+  <title>hoge</title>
+  <title>hoge</title>
+  <description>hogehoge</description>
+</textinput>
+EOR
+      end
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "name", "textinput")
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput rdf:about="http://example.com/search.html">
+  <title>hoge</title>
+  <description>hogehoge</description>
+</textinput>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "textinput")
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput rdf:about="http://example.com/search.html">
+  <title>hoge</title>
+  <description>hogehoge</description>
+  <name>key</name>
+</textinput>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput rdf:about="http://example.com/search.html">
+  <title>hoge</title>
+  <description>hogehoge</description>
+  <name>key</name>
+  <link>http://example.com/search.html</link>
+</textinput>
+EOR
+    end
+
+    def test_ignore
+      name = "a"
+      rss = make_RDF(<<-EOR)
+#{make_channel}
+#{make_item}
+<#{name}/>
+EOR
+      assert_not_expected_tag(name, ::RSS::URI, "RDF") do
+        Parser.parse(rss, true, false)
+      end
+
+      uri = ""
+      name = "a"
+      rss = make_RDF(<<-EOR)
+#{make_channel}
+#{make_item}
+<#{name} xmlns=""/>
+EOR
+      assert_parse(rss, :nothing_raised)
+      assert_not_expected_tag(name, uri, "RDF") do
+        Parser.parse(rss, true, false)
+      end
+
+      uri = "http://example.com/"
+      name = "a"
+      rss = make_RDF(<<-EOR)
+#{make_channel}
+#{make_item}
+<x:#{name} xmlns:x="#{uri}"/>
+EOR
+      assert_parse(rss, :nothing_raised)
+      assert_not_expected_tag(name, uri, "RDF") do
+        Parser.parse(rss, true, false)
+      end
+
+      uri = ::RSS::URI
+      name = "a"
+      rss = make_RDF(<<-EOR)
+#{make_channel}
+#{make_item}
+#{make_image("<#{name}/>")}
+EOR
+      assert_parse(rss, :nothing_raised)
+      assert_not_expected_tag(name, uri, "image") do
+        Parser.parse(rss, true, false)
+      end
+      
+      uri = CONTENT_URI
+      name = "encoded"
+      elem = "<#{name} xmlns='#{uri}'/>"
+      rss = make_RDF(<<-EOR)
+#{make_channel}
+#{make_item}
+#{make_image(elem)}
+EOR
+      assert_parse(rss, :nothing_raised)
+      assert_not_expected_tag(name, uri, "image") do
+        Parser.parse(rss, true, false)
+      end
+    end
+  end
+end
+
diff --git a/test/rss/test_parser_2.0.rb b/test/rss/test_parser_2.0.rb
new file mode 100644
index 0000000000..249347d3dc
--- /dev/null
+++ b/test/rss/test_parser_2.0.rb
@@ -0,0 +1,122 @@
+require "rss-testcase"
+
+require "rss/2.0"
+
+module RSS
+  class TestParser20 < TestCase
+    def test_rss20
+      assert_parse(make_rss20(<<-EOR), :missing_tag, "channel", "rss")
+EOR
+
+      assert_parse(make_rss20(<<-EOR), :nothing_raised)
+#{make_channel20("")}
+EOR
+    end
+
+    def test_cloud20
+      attrs = [
+        ["domain", CLOUD_DOMAIN],
+        ["port", CLOUD_PORT],
+        ["path", CLOUD_PATH],
+        ["registerProcedure", CLOUD_REGISTER_PROCEDURE],
+        ["protocol", CLOUD_PROTOCOL],
+      ]
+
+      (attrs.size + 1).times do |i|
+        missing_attr = attrs[i]
+        if missing_attr
+          meth = :missing_attribute
+          args = ["cloud", missing_attr[0]]
+        else
+          meth = :nothing_raised
+          args = []
+        end
+
+        cloud_attrs = []
+        attrs.each_with_index do |attr, j|
+          unless i == j
+            cloud_attrs << %Q[#{attr[0]}="#{attr[1]}"]
+          end
+        end
+
+        assert_parse(make_rss20(<<-EOR), meth, *args)
+#{make_channel20(%Q[<cloud #{cloud_attrs.join("\n")}/>])}
+EOR
+      end
+    end
+
+    def test_source20
+        assert_parse(make_rss20(<<-EOR), :missing_attribute, "source", "url")
+#{make_channel20(make_item20(%Q[<source>Example</source>]))}
+EOR
+
+        assert_parse(make_rss20(<<-EOR), :nothing_raised)
+#{make_channel20(make_item20(%Q[<source url="http://example.com/" />]))}
+EOR
+
+        assert_parse(make_rss20(<<-EOR), :nothing_raised)
+#{make_channel20(make_item20(%Q[<source url="http://example.com/">Example</source>]))}
+EOR
+    end
+
+    def test_enclosure20
+      attrs = [
+        ["url", ENCLOSURE_URL],
+        ["length", ENCLOSURE_LENGTH],
+        ["type", ENCLOSURE_TYPE],
+      ]
+
+      (attrs.size + 1).times do |i|
+        missing_attr = attrs[i]
+        if missing_attr
+          meth = :missing_attribute
+          args = ["enclosure", missing_attr[0]]
+        else
+          meth = :nothing_raised
+          args = []
+        end
+
+        enclosure_attrs = []
+        attrs.each_with_index do |attr, j|
+          unless i == j
+            enclosure_attrs << %Q[#{attr[0]}="#{attr[1]}"]
+          end
+        end
+
+        assert_parse(make_rss20(<<-EOR), meth, *args)
+#{make_channel20(%Q[
+#{make_item20(%Q[
+<enclosure
+  #{enclosure_attrs.join("\n")} />
+    ])}
+  ])}
+EOR
+      end
+    end
+
+    def test_category20
+      values = [nil, CATEGORY_DOMAIN]
+      values.each do |value|
+        domain = ""
+        domain << %Q[domain="#{value}"] if value
+
+        ["", "Example Text"].each do |text|
+          rss_src = make_rss20(<<-EOR)
+#{make_channel20(%Q[
+#{make_item20(%Q[
+<category #{domain}>#{text}</category>
+    ])}
+  ])}
+EOR
+          assert_parse(rss_src, :nothing_raised)
+
+          rss = RSS::Parser.parse(rss_src)
+          category = rss.items.last.categories.first
+          assert_equal(value, category.domain)
+          assert_equal(text, category.content)
+        end
+      end
+    end
+  end
+end
+
diff --git a/test/rss/test_parser_atom_entry.rb b/test/rss/test_parser_atom_entry.rb
new file mode 100644
index 0000000000..c2572d7a3b
--- /dev/null
+++ b/test/rss/test_parser_atom_entry.rb
@@ -0,0 +1,163 @@
+require "rss-testcase"
+
+require "rss/atom"
+
+module RSS
+  class TestParserAtom < TestCase
+    def test_entry_validation
+      assert_ns("", Atom::URI) do
+        Parser.parse(<<-EOA)
+<entry/>
+EOA
+      end
+
+      assert_ns("", Atom::URI) do
+        Parser.parse(<<-EOA)
+<entry xmlns="hoge"/>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "id", "entry") do
+<entry xmlns="#{Atom::URI}"/>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "title", "entry") do
+<entry xmlns="#{Atom::URI}">
+  <id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id>
+</entry>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "updated", "entry") do
+<entry xmlns="#{Atom::URI}">
+  <id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id>
+  <title>Example Entry</title>
+</entry>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "author", "entry") do
+<entry xmlns="#{Atom::URI}">
+  <id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id>
+  <title>Example Entry</title>
+  <updated>2003-10-10T18:30:02Z</updated>
+</entry>
+EOA
+      end
+
+      assert_parse(<<-EOA, :nothing_raised) do
+<entry xmlns="#{Atom::URI}">
+  <id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id>
+  <title>Example Entry</title>
+  <updated>2003-10-10T18:30:02Z</updated>
+  <author>
+    <name>A person</name>
+  </author>
+</entry>
+EOA
+      end
+    end
+
+    def test_entry
+      entry = RSS::Parser.parse(<<-EOA)
+<?xml version="1.0" encoding="utf-8"?>
+<entry xmlns="http://www.w3.org/2005/Atom">
+  <author>
+    <name>A person</name>
+  </author>
+  <title>Atom-Powered Robots Run Amok</title>
+  <link href="http://example.org/2003/12/13/atom03"/>
+  <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
+  <updated>2003-12-13T18:30:02Z</updated>
+  <summary>Some text.</summary>
+</entry>
+EOA
+      assert_not_nil(entry)
+      assert_equal("Atom-Powered Robots Run Amok", entry.title.content)
+      assert_equal("http://example.org/2003/12/13/atom03", entry.link.href)
+      assert_equal("urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a",
+                   entry.id.content)
+      assert_equal(Time.parse("2003-12-13T18:30:02Z"), entry.updated.content)
+      assert_equal("Some text.", entry.summary.content)
+    end
+
+    def test_entry_author
+      assert_atom_person("author", method(:make_entry_document)) do |entry|
+        assert_equal(2, entry.authors.size)
+        entry.authors.last
+      end
+    end
+
+    def test_entry_category
+      assert_atom_category(method(:make_entry_document)) do |entry|
+        assert_equal(1, entry.categories.size)
+        entry.category
+      end
+    end
+
+    def test_entry_content_text
+      assert_atom_content(method(:make_entry_document)) do |entry|
+        entry.content
+      end
+    end
+
+    def test_entry_contributor
+      assert_atom_person("contributor", method(:make_entry_document)) do |entry|
+        assert_equal(1, entry.contributors.size)
+        entry.contributor
+      end
+    end
+
+    def test_entry_id
+      entry = RSS::Parser.parse(make_entry_document)
+      assert_equal(ENTRY_ID, entry.id.content)
+    end
+
+    def test_entry_link
+      assert_atom_link(method(:make_entry_document)) do |entry|
+        assert_equal(1, entry.links.size)
+        entry.link
+      end
+    end
+
+    def test_published
+      generator = method(:make_entry_document)
+      assert_atom_date_construct("published", generator) do |entry|
+        entry.published
+      end
+    end
+
+    def test_entry_rights
+      generator = method(:make_entry_document)
+      assert_atom_text_construct("rights", generator) do |entry|
+        entry.rights
+      end
+    end
+
+    def test_entry_source
+      generator = method(:make_entry_document_with_open_source)
+      assert_atom_source(generator) do |entry|
+        assert_not_nil(entry.source)
+        entry.source
+      end
+    end
+
+    def test_entry_summary
+      generator = method(:make_entry_document)
+      assert_atom_text_construct("summary", generator) do |entry|
+        entry.summary
+      end
+    end
+
+    def test_entry_title
+      entry = RSS::Parser.parse(make_entry_document)
+      assert_equal(ENTRY_TITLE, entry.title.content)
+    end
+
+    def test_entry_updated
+      entry = RSS::Parser.parse(make_entry_document)
+      assert_equal(Time.parse(ENTRY_UPDATED), entry.updated.content)
+    end
+  end
+end
diff --git a/test/rss/test_parser_atom_feed.rb b/test/rss/test_parser_atom_feed.rb
new file mode 100644
index 0000000000..4358cc8898
--- /dev/null
+++ b/test/rss/test_parser_atom_feed.rb
@@ -0,0 +1,276 @@
+require "rss-testcase"
+
+require "rss/atom"
+
+module RSS
+  class TestParserAtomFeed < TestCase
+    def test_feed_validation
+      assert_ns("", Atom::URI) do
+        Parser.parse(<<-EOA)
+<feed/>
+EOA
+      end
+
+      assert_ns("", Atom::URI) do
+        Parser.parse(<<-EOA)
+<feed xmlns="hoge"/>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "id", "feed") do
+<feed xmlns="#{Atom::URI}"/>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "title", "feed") do
+<feed xmlns="#{Atom::URI}">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+</feed>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "updated", "feed") do
+<feed xmlns="#{Atom::URI}">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+  <title>Example Feed</title>
+</feed>
+EOA
+      end
+
+      assert_parse(<<-EOA, :missing_tag, "author", "feed") do
+<feed xmlns="#{Atom::URI}">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+  <title>Example Feed</title>
+  <updated>2003-12-13T18:30:02Z</updated>
+</feed>
+EOA
+      end
+
+      assert_parse(<<-EOA, :nothing_raised) do
+<feed xmlns="#{Atom::URI}">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+  <title>Example Feed</title>
+  <updated>2003-12-13T18:30:02Z</updated>
+  <author>
+    <name>A person</name>
+  </author>
+</feed>
+EOA
+      end
+    end
+
+    def test_lang
+      feed = RSS::Parser.parse(<<-EOA)
+<feed xmlns="#{Atom::URI}" xml:lang="ja">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+  <title xml:lang="en">Example Feed</title>
+  <updated>2003-12-13T18:30:02Z</updated>
+  <author xml:lang="en">
+    <name>A person</name>
+  </author>
+</feed>
+EOA
+
+      assert_equal("ja", feed.lang)
+      assert_equal("ja", feed.id.lang)
+      assert_equal("en", feed.title.lang)
+      assert_equal("ja", feed.updated.lang)
+      assert_equal("en", feed.author.lang)
+      assert_equal("en", feed.author.name.lang)
+    end
+
+    def test_base
+      feed = RSS::Parser.parse(<<-EOA)
+<feed xmlns="#{Atom::URI}" xml:base="http://example.com/">
+  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
+  <title xml:lang="en">Example Feed</title>
+  <updated>2003-12-13T18:30:02Z</updated>
+  <generator uri="generator">Generator</generator>
+  <link hreflang="ja" href="http://example.org/link1"/>
+  <link hreflang="en" href="link2"/>
+  <link hreflang="fr" xml:base="http://example.net/" href="link3"/>
+  <author>
+    <name>A person</name>
+    <uri>person</uri>
+  </author>
+</feed>
+EOA
+
+      assert_equal("http://example.com/", feed.base)
+      assert_equal("http://example.com/", feed.id.base)
+      assert_equal("http://example.com/", feed.title.base)
+      assert_equal("http://example.com/", feed.updated.base)
+      assert_equal("http://example.com/", feed.generator.base)
+      assert_equal("http://example.com/generator", feed.generator.uri)
+
+      assert_equal("http://example.com/", feed.links[0].base)
+      assert_equal("http://example.org/link1", feed.links[0].href)
+      assert_equal("http://example.com/", feed.links[1].base)
+      assert_equal("http://example.com/link2", feed.links[1].href)
+      assert_equal("http://example.net/", feed.links[2].base)
+      assert_equal("http://example.net/link3", feed.links[2].href)
+      assert_equal("http://example.com/person", feed.author.uri.content)
+    end
+
+    def test_feed_author
+      assert_atom_person("author", method(:make_feed)) do |feed|
+        assert_equal(2, feed.authors.size)
+        feed.authors[1]
+      end
+    end
+
+    def test_entry_author
+      generator = method(:make_feed_with_open_entry)
+      assert_atom_person("author", generator) do |feed|
+        assert_equal(1, feed.entries.size)
+        assert_equal(1, feed.entry.authors.size)
+        feed.entry.author
+      end
+    end
+
+    def test_feed_category
+      assert_atom_category(method(:make_feed)) do |feed|
+        assert_equal(1, feed.categories.size)
+        feed.category
+      end
+    end
+
+    def test_entry_category
+      assert_atom_category(method(:make_feed_with_open_entry)) do |feed|
+        assert_equal(1, feed.entries.size)
+        assert_equal(1, feed.entry.categories.size)
+        feed.entry.category
+      end
+    end
+
+    def test_entry_content
+      assert_atom_content(method(:make_feed_with_open_entry)) do |feed|
+        assert_equal(1, feed.entries.size)
+        feed.entry.content
+      end
+    end
+
+    def test_feed_contributor
+      assert_atom_person("contributor", method(:make_feed)) do |feed|
+        assert_equal(1, feed.contributors.size)
+        feed.contributor
+      end
+    end
+
+    def test_entry_contributor
+      generator = method(:make_feed_with_open_entry)
+      assert_atom_person("contributor", generator) do |feed|
+        assert_equal(1, feed.entries.size)
+        assert_equal(1, feed.entry.contributors.size)
+        feed.entry.contributor
+      end
+    end
+
+    def test_feed_generator
+      assert_atom_generator(method(:make_feed)) do |feed|
+        feed.generator
+      end
+    end
+
+    def test_feed_icon
+      assert_atom_icon(method(:make_feed)) do |feed|
+        feed.icon
+      end
+    end
+
+    def test_feed_id
+      feed = RSS::Parser.parse(make_feed(''))
+      assert_equal(FEED_ID, feed.id.content)
+    end
+
+    def test_entry_id
+      feed = RSS::Parser.parse(make_feed(''))
+      assert_equal(ENTRY_ID, feed.entry.id.content)
+    end
+
+    def test_feed_link
+      assert_atom_link(method(:make_feed)) do |feed|
+        assert_equal(1, feed.links.size)
+        feed.link
+      end
+    end
+
+    def test_entry_link
+      assert_atom_link(method(:make_feed_with_open_entry)) do |feed|
+        assert_equal(1, feed.entries.size)
+        assert_equal(1, feed.entry.links.size)
+        feed.entry.link
+      end
+    end
+
+    def test_feed_logo
+      assert_atom_logo(method(:make_feed)) do |feed|
+        feed.logo
+      end
+    end
+
+    def test_feed_rights
+      assert_atom_text_construct("rights", method(:make_feed)) do |feed|
+        feed.rights
+      end
+    end
+
+    def test_entry_rights
+      generator = method(:make_feed_with_open_entry)
+      assert_atom_text_construct("rights", generator) do |feed|
+        assert_equal(1, feed.entries.size)
+        feed.entry.rights
+      end
+    end
+
+    def test_entry_source
+      assert_atom_source(method(:make_feed_with_open_entry_source)) do |feed|
+        assert_equal(1, feed.entries.size)
+        assert_not_nil(feed.entry.source)
+        feed.entry.source
+      end
+    end
+
+    def test_feed_subtitle
+      assert_atom_text_construct("subtitle", method(:make_feed)) do |feed|
+        feed.subtitle
+      end
+    end
+
+    def test_feed_title
+      feed = RSS::Parser.parse(make_feed(''))
+      assert_equal(FEED_TITLE, feed.title.content)
+    end
+
+    def test_entry_title
+      feed = RSS::Parser.parse(make_feed(''))
+      assert_equal(ENTRY_TITLE, feed.entry.title.content)
+    end
+
+    def test_feed_updated
+      feed = RSS::Parser.parse(make_feed(''))
+      assert_equal(Time.parse(FEED_UPDATED), feed.updated.content)
+    end
+
+    def test_entry_updated
+      feed = RSS::Parser.parse(make_feed(''))
+      assert_equal(Time.parse(ENTRY_UPDATED), feed.entry.updated.content)
+    end
+
+    def test_entry_published
+      generator = method(:make_feed_with_open_entry)
+      assert_atom_date_construct("published", generator) do |feed|
+        assert_equal(1, feed.entries.size)
+        feed.entry.published
+      end
+    end
+
+    def test_entry_summary
+      generator = method(:make_feed_with_open_entry)
+      assert_atom_text_construct("summary", generator) do |feed|
+        assert_equal(1, feed.entries.size)
+        feed.entry.summary
+      end
+    end
+  end
+end
diff --git a/test/rss/test_setup_maker_0.9.rb b/test/rss/test_setup_maker_0.9.rb
index 086065c2bc..c20186cc8a 100644
--- a/test/rss/test_setup_maker_0.9.rb
+++ b/test/rss/test_setup_maker_0.9.rb
@@ -40,17 +40,28 @@ module RSS
         maker.channel.lastBuildDate = lastBuildDate
 
         skipDays.each do |day|
-          new_day = maker.channel.skipDays.new_day
-          new_day.content = day
+          maker.channel.skipDays.new_day do |new_day|
+            new_day.content = day
+          end
         end
         skipHours.each do |hour|
-          new_hour = maker.channel.skipHours.new_hour
-          new_hour.content = hour
+          maker.channel.skipHours.new_hour do |new_hour|
+            new_hour.content = hour
+          end
+        end
+
+        setup_dummy_image(maker)
+      end
+
+      assert_not_set_error("maker.image", %w(title url)) do
+        RSS::Maker.make("0.91") do |maker|
+          rss.channel.setup_maker(maker)
         end
       end
 
       new_rss = RSS::Maker.make("0.91") do |maker|
         rss.channel.setup_maker(maker)
+        setup_dummy_image(maker)
       end
       channel = new_rss.channel
       
@@ -72,9 +83,8 @@ module RSS
       skipHours.each_with_index do |hour, i|
         assert_equal(hour.to_i, channel.skipHours.hours[i].content)
       end
-      
+
       assert(channel.items.empty?)
-      assert_nil(channel.image)
       assert_nil(channel.textInput)
     end
 
@@ -119,6 +129,7 @@ module RSS
 
       rss = RSS::Maker.make("0.91") do |maker|
         setup_dummy_channel(maker)
+        setup_dummy_image(maker)
 
         maker.textinput.title = title
         maker.textinput.description = description
@@ -128,6 +139,7 @@ module RSS
 
       new_rss = RSS::Maker.make("0.91") do |maker|
         rss.channel.setup_maker(maker)
+        rss.image.setup_maker(maker)
         rss.textinput.setup_maker(maker)
       end
       
@@ -149,11 +161,14 @@ module RSS
         setup_dummy_channel(maker)
         
         item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{title}#{i}"
-          item.link = "#{link}#{i}"
-          item.description = "#{description}#{i}"
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+          end
         end
+
+        setup_dummy_image(maker)
       end
       
       new_rss = RSS::Maker.make("0.91") do |maker|
@@ -166,15 +181,16 @@ module RSS
             item.setup_maker(maker.items)
           end
         end
+
+        rss.image.setup_maker(maker)
       end
-      
+
       assert_equal(item_size, new_rss.items.size)
       new_rss.items.each_with_index do |item, i|
         assert_equal("#{title}#{i}", item.title)
         assert_equal("#{link}#{i}", item.link)
         assert_equal("#{description}#{i}", item.description)
       end
-
     end
 
     def test_setup_maker_items_backward_compatibility
@@ -196,17 +212,19 @@ module RSS
         maker.encoding = encoding
         maker.standalone = standalone
 
-        xss = maker.xml_stylesheets.new_xml_stylesheet
-        xss.href = href
-        xss.type = type
-        xss.title = title
-        xss.media = media
-        xss.charset = charset
-        xss.alternate = alternate
-        
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+          xss.type = type
+          xss.title = title
+          xss.media = media
+          xss.charset = charset
+          xss.alternate = alternate
+        end
+
         setup_dummy_channel(maker)
+        setup_dummy_image(maker)
       end
-      
+
       new_rss = RSS::Maker.make("0.91") do |maker|
         rss.setup_maker(maker)
       end
@@ -224,6 +242,5 @@ module RSS
       assert_equal(charset, xss.charset)
       assert_equal(alternate, xss.alternate)
     end
-    
   end
 end
diff --git a/test/rss/test_setup_maker_1.0.rb b/test/rss/test_setup_maker_1.0.rb
index 95d8b310ba..539749bf20 100644
--- a/test/rss/test_setup_maker_1.0.rb
+++ b/test/rss/test_setup_maker_1.0.rb
@@ -87,10 +87,15 @@ module RSS
         @sy_elems.each do |var, value|
           maker.channel.__send__("sy_#{var}=", value)
         end
+
+        setup_dummy_item(maker)
       end
 
       new_rss = RSS::Maker.make("1.0") do |maker|
         rss.channel.setup_maker(maker)
+        rss.items.each do |item|
+          item.setup_maker(maker)
+        end
       end
       channel = new_rss.channel
       
@@ -98,7 +103,7 @@ module RSS
       assert_equal(title, channel.title)
       assert_equal(link, channel.link)
       assert_equal(description, channel.description)
-      assert_equal(true, channel.items.Seq.lis.empty?)
+      assert_equal(1, channel.items.Seq.lis.size)
       assert_nil(channel.image)
       assert_nil(channel.textinput)
 
@@ -128,11 +133,16 @@ module RSS
         @dc_elems.each do |var, value|
           maker.image.__send__("dc_#{var}=", value)
         end
+
+        setup_dummy_item(maker)
       end
       
       new_rss = RSS::Maker.make("1.0") do |maker|
         rss.channel.setup_maker(maker)
         rss.image.setup_maker(maker)
+        rss.items.each do |item|
+          item.setup_maker(maker)
+        end
       end
       
       image = new_rss.image
@@ -164,11 +174,16 @@ module RSS
         @dc_elems.each do |var, value|
           maker.textinput.__send__("dc_#{var}=", value)
         end
+
+        setup_dummy_item(maker)
       end
       
       new_rss = RSS::Maker.make("1.0") do |maker|
         rss.channel.setup_maker(maker)
         rss.textinput.setup_maker(maker)
+        rss.items.each do |item|
+          item.setup_maker(maker)
+        end
       end
       
       textinput = new_rss.textinput
@@ -195,23 +210,25 @@ module RSS
         setup_dummy_channel(maker)
         
         item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{title}#{i}"
-          item.link = "#{link}#{i}"
-          item.description = "#{description}#{i}"
-
-          @dc_elems.each do |var, value|
-            item.__send__("dc_#{var}=", value)
-          end
-          
-          @content_elems.each do |var, value|
-            item.__send__("content_#{var}=", value)
-          end
-
-          item.trackback_ping = @trackback_elems[:ping]
-          @trackback_elems[:about].each do |value|
-            new_about = item.trackback_abouts.new_about
-            new_about.value = value
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+
+            @dc_elems.each do |var, value|
+              item.__send__("dc_#{var}=", value)
+            end
+
+            @content_elems.each do |var, value|
+              item.__send__("content_#{var}=", value)
+            end
+
+            item.trackback_ping = @trackback_elems[:ping]
+            @trackback_elems[:about].each do |value|
+              item.trackback_abouts.new_about do |new_about|
+                new_about.value = value
+              end
+            end
           end
         end
       end
@@ -321,15 +338,17 @@ module RSS
         maker.encoding = encoding
         maker.standalone = standalone
 
-        xss = maker.xml_stylesheets.new_xml_stylesheet
-        xss.href = href
-        xss.type = type
-        xss.title = title
-        xss.media = media
-        xss.charset = charset
-        xss.alternate = alternate
-        
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+          xss.type = type
+          xss.title = title
+          xss.media = media
+          xss.charset = charset
+          xss.alternate = alternate
+        end
+
         setup_dummy_channel(maker)
+        setup_dummy_item(maker)
       end
       
       new_rss = RSS::Maker.make("1.0") do |maker|
@@ -384,14 +403,15 @@ module RSS
         maker.encoding = encoding
         maker.standalone = standalone
 
-        xss = maker.xml_stylesheets.new_xml_stylesheet
-        xss.href = href
-        xss.type = type
-        xss.title = title
-        xss.media = media
-        xss.charset = charset
-        xss.alternate = alternate
-        
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+          xss.type = type
+          xss.title = title
+          xss.media = media
+          xss.charset = charset
+          xss.alternate = alternate
+        end
+
         maker.channel.about = channel_about
         maker.channel.title = channel_title
         maker.channel.link = channel_link
@@ -418,23 +438,25 @@ module RSS
         end
         
         item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{item_title}#{i}"
-          item.link = "#{item_link}#{i}"
-          item.description = "#{item_description}#{i}"
-
-          @dc_elems.each do |var, value|
-            item.__send__("dc_#{var}=", value)
-          end
-          
-          @content_elems.each do |var, value|
-            item.__send__("content_#{var}=", value)
-          end
-
-          item.trackback_ping = @trackback_elems[:ping]
-          @trackback_elems[:about].each do |value|
-            new_about = item.trackback_abouts.new_about
-            new_about.value = value
+          maker.items.new_item do |item|
+            item.title = "#{item_title}#{i}"
+            item.link = "#{item_link}#{i}"
+            item.description = "#{item_description}#{i}"
+
+            @dc_elems.each do |var, value|
+              item.__send__("dc_#{var}=", value)
+            end
+
+            @content_elems.each do |var, value|
+              item.__send__("content_#{var}=", value)
+            end
+
+            item.trackback_ping = @trackback_elems[:ping]
+            @trackback_elems[:about].each do |value|
+              item.trackback_abouts.new_about do |new_about|
+                new_about.value = value
+              end
+            end
           end
         end
 
diff --git a/test/rss/test_setup_maker_2.0.rb b/test/rss/test_setup_maker_2.0.rb
index a35096cf16..8fb727de8d 100644
--- a/test/rss/test_setup_maker_2.0.rb
+++ b/test/rss/test_setup_maker_2.0.rb
@@ -46,18 +46,21 @@ module RSS
         maker.channel.lastBuildDate = lastBuildDate
 
         skipDays.each do |day|
-          new_day = maker.channel.skipDays.new_day
-          new_day.content = day
+          maker.channel.skipDays.new_day do |new_day|
+            new_day.content = day
+          end
         end
         skipHours.each do |hour|
-          new_hour = maker.channel.skipHours.new_hour
-          new_hour.content = hour
+          maker.channel.skipHours.new_hour do |new_hour|
+            new_hour.content = hour
+          end
         end
 
 
         categories.each do |category|
-          new_category = maker.channel.categories.new_category
-          new_category.content = category
+          maker.channel.categories.new_category do |new_category|
+            new_category.content = category
+          end
         end
         
         maker.channel.generator = generator
@@ -189,27 +192,28 @@ module RSS
         setup_dummy_channel(maker)
         
         item_size.times do |i|
-          item = maker.items.new_item
-          item.title = "#{title}#{i}"
-          item.link = "#{link}#{i}"
-          item.description = "#{description}#{i}"
-          item.author = "#{author}#{i}"
-          item.comments = "#{comments}#{i}"
-          item.date = pubDate
-
-          item.guid.isPermaLink = guid_isPermaLink
-          item.guid.content = guid_content
-
-          item.enclosure.url = enclosure_url
-          item.enclosure.length = enclosure_length
-          item.enclosure.type = enclosure_type
-
-          item.source.url = source_url
-          item.source.content = source_content
-
-          category = item.categories.new_category
-          category.domain = category_domain
-          category.content = category_content
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+            item.author = "#{author}#{i}"
+            item.comments = "#{comments}#{i}"
+            item.date = pubDate
+
+            item.guid.isPermaLink = guid_isPermaLink
+            item.guid.content = guid_content
+
+            item.enclosure.url = enclosure_url
+            item.enclosure.length = enclosure_length
+            item.enclosure.type = enclosure_type
+
+            item.source.url = source_url
+            item.source.content = source_content
+
+            category = item.categories.new_category
+            category.domain = category_domain
+            category.content = category_content
+          end
         end
       end
       
@@ -270,14 +274,15 @@ module RSS
         maker.encoding = encoding
         maker.standalone = standalone
 
-        xss = maker.xml_stylesheets.new_xml_stylesheet
-        xss.href = href
-        xss.type = type
-        xss.title = title
-        xss.media = media
-        xss.charset = charset
-        xss.alternate = alternate
-        
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+          xss.type = type
+          xss.title = title
+          xss.media = media
+          xss.charset = charset
+          xss.alternate = alternate
+        end
+
         setup_dummy_channel(maker)
       end
       
diff --git a/test/rss/test_setup_maker_atom_entry.rb b/test/rss/test_setup_maker_atom_entry.rb
new file mode 100644
index 0000000000..6f3df65f3f
--- /dev/null
+++ b/test/rss/test_setup_maker_atom_entry.rb
@@ -0,0 +1,409 @@
+require "rss-testcase"
+
+require "rss/maker"
+
+module RSS
+  class TestSetupMakerAtomEntry < TestCase
+    def setup
+      t = Time.iso8601("2000-01-01T12:00:05+00:00")
+      class << t
+        alias_method(:to_s, :iso8601)
+      end
+
+      @dc_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,
+      }
+    end
+
+    def test_setup_maker_entry(with_dc=true)
+      authors = [
+                 {
+                   :name => "Bob",
+                   :uri => "http://example.com/~bob/",
+                   :email => "bob@example.com",
+                 },
+                 {
+                   :name => "Alice",
+                   :uri => "http://example.com/~alice/",
+                   :email => "alice@example.com",
+                 },
+                ]
+      categories = [
+                    {
+                      :term => "music",
+                      :label => "Music",
+                    },
+                    {
+                      :term => "book",
+                      :scheme => "http://example.com/category/book/",
+                      :label => "Book",
+                    },
+                   ]
+      contributors = [
+                      {
+                        :name => "Chris",
+                        :email => "chris@example.com",
+                      },
+                      {
+                        :name => "Eva",
+                        :uri => "http://example.com/~eva/",
+                      },
+                     ]
+      id = "urn:uuid:8b105336-7e20-45fc-bb78-37fb3e1db25a"
+      link = "http://hoge.com"
+      published = Time.now - 60 * 3600
+      rights = "Copyrights (c) 2007 Alice and Bob"
+      description = "fugafugafugafuga"
+      title = "fugafuga"
+      updated = Time.now
+
+      feed = RSS::Maker.make("atom:entry") do |maker|
+        maker.items.new_item do |item|
+          authors.each do |author_info|
+            item.authors.new_author do |author|
+              author_info.each do |key, value|
+                author.__send__("#{key}=", value)
+              end
+            end
+          end
+
+          categories.each do |category_info|
+            item.categories.new_category do |category|
+              category_info.each do |key, value|
+                category.__send__("#{key}=", value)
+              end
+            end
+          end
+
+          contributors.each do |contributor_info|
+            item.contributors.new_contributor do |contributor|
+              contributor_info.each do |key, value|
+                contributor.__send__("#{key}=", value)
+              end
+            end
+          end
+
+          item.id = id
+          item.link = link
+          item.published = published
+          item.rights = rights
+          item.description = description
+          item.title = title
+          item.updated = updated
+
+          if with_dc
+            @dc_elems.each do |var, value|
+              if var == :date
+                item.new_dc_date(value)
+              else
+                item.__send__("dc_#{var}=", value)
+              end
+            end
+          end
+        end
+      end
+      assert_not_nil(feed)
+
+      new_feed = RSS::Maker.make("atom:entry") do |maker|
+        feed.setup_maker(maker)
+      end
+      assert_not_nil(new_feed)
+
+      new_authors = new_feed.authors.collect do |author|
+        {
+          :name => author.name.content,
+          :uri => author.uri.content,
+          :email => author.email.content,
+        }
+      end
+      assert_equal(authors, new_authors)
+
+      new_categories = new_feed.categories.collect do |category|
+        {
+          :term => category.term,
+          :scheme => category.scheme,
+          :label => category.label,
+        }.reject {|key, value| value.nil?}
+      end
+      assert_equal(categories, new_categories)
+
+      new_contributors = new_feed.contributors.collect do |contributor|
+        info = {}
+        info[:name] = contributor.name.content
+        info[:uri] = contributor.uri.content if contributor.uri
+        info[:email] = contributor.email.content if contributor.email
+        info
+      end
+      assert_equal(contributors, new_contributors)
+
+      assert_equal(id, new_feed.id.content)
+      assert_equal(link, new_feed.link.href)
+      assert_equal(published, new_feed.published.content)
+      assert_equal(rights, new_feed.rights.content)
+      assert_equal(description, new_feed.summary.content)
+      assert_equal(title, new_feed.title.content)
+      assert_equal(updated, new_feed.updated.content)
+
+      if with_dc
+        @dc_elems.each do |var, value|
+          if var == :date
+            assert_equal([updated, value],
+                         new_feed.dc_dates.collect {|date| date.value})
+          else
+            assert_equal(value, new_feed.__send__("dc_#{var}"))
+          end
+        end
+      end
+
+      assert_equal(1, new_feed.items.size)
+    end
+
+    def test_setup_maker_entry_without_dc
+      test_setup_maker_entry(false)
+    end
+
+    def test_setup_maker_items(for_backward_compatibility=false)
+      title = "TITLE"
+      link = "http://hoge.com/"
+      description = "text hoge fuga"
+      updated = Time.now
+
+      item_size = 5
+      feed = RSS::Maker.make("atom:entry") do |maker|
+        setup_dummy_channel_atom(maker)
+
+        item_size.times do |i|
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+            item.updated = updated + i * 60
+          end
+        end
+      end
+
+      new_feed = RSS::Maker.make("atom:entry") do |maker|
+        feed.items.each do |item|
+          if for_backward_compatibility
+            item.setup_maker(maker)
+          else
+            item.setup_maker(maker.items)
+          end
+        end
+
+        feed.items.clear
+        feed.setup_maker(maker)
+      end
+
+      assert_equal(1, new_feed.items.size)
+      new_feed.items[0..1].each_with_index do |item, i|
+        assert_equal("#{title}#{i}", item.title.content)
+        assert_equal("#{link}#{i}", item.link.href)
+        assert_equal("#{description}#{i}", item.summary.content)
+        assert_equal(updated + i * 60, item.updated.content)
+      end
+    end
+
+    def test_setup_maker_items_sort
+      title = "TITLE"
+      link = "http://hoge.com/"
+      summary = "text hoge fuga"
+      updated = Time.now
+
+      feed_size = 5
+      feed = RSS::Maker.make("atom:entry") do |maker|
+        setup_dummy_channel_atom(maker)
+
+        feed_size.times do |i|
+          entry_class = RSS::Atom::Entry
+          entry = entry_class.new
+          entry.title = entry_class::Title.new(:content => "#{title}#{i}")
+          entry.links << entry_class::Link.new(:href => "#{link}#{i}")
+          entry.summary = entry_class::Summary.new(:content => "#{summary}#{i}")
+          entry.updated = entry_class::Updated.new(:content => updated + i * 60)
+          entry.setup_maker(maker.items)
+        end
+        maker.items.do_sort = false
+      end
+      assert_equal(1, feed.items.size)
+
+      assert_equal("#{title}0", feed.title.content)
+      assert_equal("#{link}0", feed.link.href)
+      assert_equal("#{summary}0", feed.summary.content)
+
+
+      feed = RSS::Maker.make("atom:entry") do |maker|
+        setup_dummy_channel_atom(maker)
+
+        feed_size.times do |i|
+          entry_class = RSS::Atom::Entry
+          entry = entry_class.new
+          entry.title = entry_class::Title.new(:content => "#{title}#{i}")
+          entry.links << entry_class::Link.new(:href => "#{link}#{i}")
+          entry.summary = entry_class::Summary.new(:content => "#{summary}#{i}")
+          entry.updated = entry_class::Updated.new(:content => updated + i * 60)
+          entry.setup_maker(maker.items)
+        end
+        maker.items.do_sort = true
+      end
+      assert_equal(1, feed.items.size)
+
+      assert_equal("#{title}#{feed_size - 1}", feed.title.content)
+      assert_equal("#{link}#{feed_size - 1}", feed.link.href)
+      assert_equal("#{summary}#{feed_size - 1}", feed.summary.content)
+    end
+
+    def test_setup_maker_items_backward_compatibility
+      test_setup_maker_items(true)
+    end
+
+    def test_setup_maker
+      encoding = "EUC-JP"
+      standalone = true
+
+      href = 'a.xsl'
+      type = 'text/xsl'
+      title = 'sample'
+      media = 'printer'
+      charset = 'UTF-8'
+      alternate = 'yes'
+
+      feed = RSS::Maker.make("atom:entry") do |maker|
+        maker.encoding = encoding
+        maker.standalone = standalone
+
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+          xss.type = type
+          xss.title = title
+          xss.media = media
+          xss.charset = charset
+          xss.alternate = alternate
+        end
+
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+      assert_not_nil(feed)
+
+      new_feed = RSS::Maker.make("atom:entry") do |maker|
+        feed.setup_maker(maker)
+      end
+
+      assert_equal(["atom", "1.0", "entry"], new_feed.feed_info)
+      assert_equal(encoding, new_feed.encoding)
+      assert_equal(standalone, new_feed.standalone)
+
+      xss = new_feed.xml_stylesheets.first
+      assert_equal(1, new_feed.xml_stylesheets.size)
+      assert_equal(href, xss.href)
+      assert_equal(type, xss.type)
+      assert_equal(title, xss.title)
+      assert_equal(media, xss.media)
+      assert_equal(charset, xss.charset)
+      assert_equal(alternate, xss.alternate)
+    end
+
+    def test_setup_maker_full
+      encoding = "EUC-JP"
+      standalone = true
+
+      href = 'a.xsl'
+      type = 'text/xsl'
+      title = 'sample'
+      media = 'printer'
+      charset = 'UTF-8'
+      alternate = 'yes'
+
+      channel_about = "http://hoge.com"
+      channel_title = "fugafuga"
+      channel_link = "http://hoge.com"
+      channel_description = "fugafugafugafuga"
+      channel_author = "Bob"
+
+      image_url = "http://hoge.com/hoge.png"
+
+      item_title = "TITLE"
+      item_link = "http://hoge.com/"
+      item_description = "text hoge fuga"
+
+      entry_size = 5
+      feed = RSS::Maker.make("atom:entry") do |maker|
+        maker.encoding = encoding
+        maker.standalone = standalone
+
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+          xss.type = type
+          xss.title = title
+          xss.media = media
+          xss.charset = charset
+          xss.alternate = alternate
+        end
+
+        maker.channel.about = channel_about
+        maker.channel.title = channel_title
+        maker.channel.link = channel_link
+        maker.channel.description = channel_description
+        maker.channel.author = channel_author
+        @dc_elems.each do |var, value|
+          maker.channel.__send__("dc_#{var}=", value)
+        end
+
+        maker.image.url = image_url
+
+        entry_size.times do |i|
+          maker.items.new_item do |item|
+            item.title = "#{item_title}#{i}"
+            item.link = "#{item_link}#{i}"
+            item.description = "#{item_description}#{i}"
+
+            @dc_elems.each do |var, value|
+              item.__send__("dc_#{var}=", value)
+            end
+          end
+        end
+      end
+
+      new_feed = RSS::Maker.make("atom:entry") do |maker|
+        feed.setup_maker(maker)
+      end
+
+      assert_equal(["atom", "1.0", "entry"], new_feed.feed_info)
+      assert_equal(encoding, new_feed.encoding)
+      assert_equal(standalone, new_feed.standalone)
+
+      xss = new_feed.xml_stylesheets.first
+      assert_equal(1, new_feed.xml_stylesheets.size)
+      assert_equal(href, xss.href)
+      assert_equal(type, xss.type)
+      assert_equal(title, xss.title)
+      assert_equal(media, xss.media)
+      assert_equal(charset, xss.charset)
+      assert_equal(alternate, xss.alternate)
+
+      assert_equal("#{item_title}0", new_feed.title.content)
+      assert_equal("#{item_link}0", new_feed.link.href)
+      assert_equal("#{item_description}0", new_feed.summary.content)
+      @dc_elems.each do |var, value|
+        assert_equal(value, new_feed.__send__("dc_#{var}"))
+      end
+      assert_equal(1, new_feed.items.size)
+    end
+  end
+end
diff --git a/test/rss/test_setup_maker_atom_feed.rb b/test/rss/test_setup_maker_atom_feed.rb
new file mode 100644
index 0000000000..0caed6cec8
--- /dev/null
+++ b/test/rss/test_setup_maker_atom_feed.rb
@@ -0,0 +1,443 @@
+require "rss-testcase"
+
+require "rss/maker"
+
+module RSS
+  class TestSetupMakerAtomFeed < TestCase
+    def setup
+      t = Time.iso8601("2000-01-01T12:00:05+00:00")
+      class << t
+        alias_method(:to_s, :iso8601)
+      end
+
+      @dc_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,
+      }
+    end
+
+    def test_setup_maker_feed(with_dc=true)
+      authors = [
+                 {
+                   :name => "Bob",
+                   :uri => "http://example.com/~bob/",
+                   :email => "bob@example.com",
+                 },
+                 {
+                   :name => "Alice",
+                   :uri => "http://example.com/~alice/",
+                   :email => "alice@example.com",
+                 },
+                ]
+      categories = [
+                    {
+                      :term => "music",
+                      :label => "Music",
+                    },
+                    {
+                      :term => "book",
+                      :scheme => "http://example.com/category/book/",
+                      :label => "Book",
+                    },
+                   ]
+      contributors = [
+                      {
+                        :name => "Chris",
+                        :email => "chris@example.com",
+                      },
+                      {
+                        :name => "Eva",
+                        :uri => "http://example.com/~eva/",
+                      },
+                     ]
+      generator = {
+        :uri => "http://example.com/generator/",
+        :version => "0.0.1",
+        :content => "Feed Generator",
+      }
+      icon = "http://example.com/icon.png"
+      about = "http://hoge.com"
+      title = "fugafuga"
+      link = "http://hoge.com"
+      logo = "http://example.com/logo.png"
+      rights = "Copyrights (c) 2007 Alice and Bob"
+      description = "fugafugafugafuga"
+      updated = Time.now
+
+      feed = RSS::Maker.make("atom") do |maker|
+        authors.each do |author_info|
+          maker.channel.authors.new_author do |author|
+            author_info.each do |key, value|
+              author.__send__("#{key}=", value)
+            end
+          end
+        end
+
+        categories.each do |category_info|
+          maker.channel.categories.new_category do |category|
+            category_info.each do |key, value|
+              category.__send__("#{key}=", value)
+            end
+          end
+        end
+
+        contributors.each do |contributor_info|
+          maker.channel.contributors.new_contributor do |contributor|
+            contributor_info.each do |key, value|
+              contributor.__send__("#{key}=", value)
+            end
+          end
+        end
+
+        generator.each do |key, value|
+          maker.channel.generator.__send__("#{key}=", value)
+        end
+
+        maker.channel.icon = icon
+
+        maker.channel.about = about
+        maker.channel.link = link
+        maker.channel.logo = logo
+        maker.channel.rights = rights
+        maker.channel.title = title
+        maker.channel.description = description
+        maker.channel.updated = updated
+
+        if with_dc
+          @dc_elems.each do |var, value|
+            if var == :date
+              maker.channel.new_dc_date(value)
+            else
+              maker.channel.__send__("dc_#{var}=", value)
+            end
+          end
+        end
+
+        setup_dummy_item_atom(maker)
+      end
+      assert_not_nil(feed)
+
+      new_feed = RSS::Maker.make("atom") do |maker|
+        feed.setup_maker(maker)
+      end
+      assert_not_nil(new_feed)
+
+      new_authors = new_feed.authors.collect do |author|
+        {
+          :name => author.name.content,
+          :uri => author.uri.content,
+          :email => author.email.content,
+        }
+      end
+      assert_equal(authors, new_authors)
+
+      new_categories = new_feed.categories.collect do |category|
+        {
+          :term => category.term,
+          :scheme => category.scheme,
+          :label => category.label,
+        }.reject {|key, value| value.nil?}
+      end
+      assert_equal(categories, new_categories)
+
+      new_contributors = new_feed.contributors.collect do |contributor|
+        info = {}
+        info[:name] = contributor.name.content
+        info[:uri] = contributor.uri.content if contributor.uri
+        info[:email] = contributor.email.content if contributor.email
+        info
+      end
+      assert_equal(contributors, new_contributors)
+
+      new_generator = {
+        :uri => new_feed.generator.uri,
+        :version => new_feed.generator.version,
+        :content => new_feed.generator.content,
+      }
+      assert_equal(generator, new_generator)
+
+      assert_equal(icon, new_feed.icon.content)
+      assert_equal(about, new_feed.id.content)
+      assert_equal(link, new_feed.link.href)
+      assert_equal(logo, new_feed.logo.content)
+      assert_equal(rights, new_feed.rights.content)
+      assert_equal(description, new_feed.subtitle.content)
+      assert_equal(title, new_feed.title.content)
+      assert_equal(updated, new_feed.updated.content)
+
+      if with_dc
+        @dc_elems.each do |var, value|
+          if var == :date
+            assert_equal([updated, value],
+                         new_feed.dc_dates.collect {|date| date.value})
+          else
+            assert_equal(value, new_feed.__send__("dc_#{var}"))
+          end
+        end
+      end
+
+      assert_equal(1, new_feed.items.size)
+    end
+
+    def test_setup_maker_feed_without_dc
+      test_setup_maker_feed(false)
+    end
+
+    def test_setup_maker_items(for_backward_compatibility=false)
+      title = "TITLE"
+      link = "http://hoge.com/"
+      description = "text hoge fuga"
+      updated = Time.now
+
+      item_size = 5
+      feed = RSS::Maker.make("atom") do |maker|
+        setup_dummy_channel_atom(maker)
+
+        item_size.times do |i|
+          maker.items.new_item do |item|
+            item.title = "#{title}#{i}"
+            item.link = "#{link}#{i}"
+            item.description = "#{description}#{i}"
+            item.updated = updated + i * 60
+          end
+        end
+      end
+
+      new_feed = RSS::Maker.make("atom") do |maker|
+        feed.items.each do |item|
+          if for_backward_compatibility
+            item.setup_maker(maker)
+          else
+            item.setup_maker(maker.items)
+          end
+        end
+
+        feed.items.clear
+        feed.setup_maker(maker)
+      end
+
+      assert_equal(item_size, new_feed.items.size)
+      new_feed.items.each_with_index do |item, i|
+        assert_equal("#{title}#{i}", item.title.content)
+        assert_equal("#{link}#{i}", item.link.href)
+        assert_equal("#{description}#{i}", item.summary.content)
+        assert_equal(updated + i * 60, item.updated.content)
+      end
+    end
+
+    def test_setup_maker_items_sort
+      title = "TITLE"
+      link = "http://hoge.com/"
+      summary = "text hoge fuga"
+      updated = Time.now
+
+      feed_size = 5
+      feed = RSS::Maker.make("atom") do |maker|
+        setup_dummy_channel_atom(maker)
+
+        feed_size.times do |i|
+          entry_class = RSS::Atom::Feed::Entry
+          entry = entry_class.new
+          entry.title = entry_class::Title.new(:content => "#{title}#{i}")
+          entry.links << entry_class::Link.new(:href => "#{link}#{i}")
+          entry.summary = entry_class::Summary.new(:content => "#{summary}#{i}")
+          entry.updated = entry_class::Updated.new(:content => updated + i * 60)
+          entry.setup_maker(maker.items)
+        end
+        maker.items.do_sort = false
+      end
+      assert_equal(feed_size, feed.entries.size)
+      feed.entries.each_with_index do |entry, i|
+        assert_equal("#{title}#{i}", entry.title.content)
+        assert_equal("#{link}#{i}", entry.link.href)
+        assert_equal("#{summary}#{i}", entry.summary.content)
+      end
+
+
+      feed = RSS::Maker.make("atom") do |maker|
+        setup_dummy_channel_atom(maker)
+
+        feed_size.times do |i|
+          entry_class = RSS::Atom::Feed::Entry
+          entry = entry_class.new
+          entry.title = entry_class::Title.new(:content => "#{title}#{i}")
+          entry.links << entry_class::Link.new(:href => "#{link}#{i}")
+          entry.summary = entry_class::Summary.new(:content => "#{summary}#{i}")
+          entry.updated = entry_class::Updated.new(:content => updated + i * 60)
+          entry.setup_maker(maker.items)
+        end
+        maker.items.do_sort = true
+       end
+      assert_equal(feed_size, feed.entries.size)
+      feed.entries.reverse.each_with_index do |entry, i|
+        assert_equal("#{title}#{i}", entry.title.content)
+        assert_equal("#{link}#{i}", entry.link.href)
+        assert_equal("#{summary}#{i}", entry.summary.content)
+      end
+    end
+
+    def test_setup_maker_items_backward_compatibility
+      test_setup_maker_items(true)
+    end
+
+    def test_setup_maker
+      encoding = "EUC-JP"
+      standalone = true
+      
+      href = 'a.xsl'
+      type = 'text/xsl'
+      title = 'sample'
+      media = 'printer'
+      charset = 'UTF-8'
+      alternate = 'yes'
+
+      feed = RSS::Maker.make("atom") do |maker|
+        maker.encoding = encoding
+        maker.standalone = standalone
+
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+          xss.type = type
+          xss.title = title
+          xss.media = media
+          xss.charset = charset
+          xss.alternate = alternate
+        end
+
+        setup_dummy_channel_atom(maker)
+        setup_dummy_item_atom(maker)
+      end
+      assert_not_nil(feed)
+
+      new_feed = RSS::Maker.make("atom") do |maker|
+        feed.setup_maker(maker)
+      end
+
+      assert_equal(["atom", "1.0", "feed"], new_feed.feed_info)
+      assert_equal(encoding, new_feed.encoding)
+      assert_equal(standalone, new_feed.standalone)
+
+      xss = new_feed.xml_stylesheets.first
+      assert_equal(1, new_feed.xml_stylesheets.size)
+      assert_equal(href, xss.href)
+      assert_equal(type, xss.type)
+      assert_equal(title, xss.title)
+      assert_equal(media, xss.media)
+      assert_equal(charset, xss.charset)
+      assert_equal(alternate, xss.alternate)
+    end
+
+    def test_setup_maker_full
+      encoding = "EUC-JP"
+      standalone = true
+
+      href = 'a.xsl'
+      type = 'text/xsl'
+      title = 'sample'
+      media = 'printer'
+      charset = 'UTF-8'
+      alternate = 'yes'
+
+      channel_about = "http://hoge.com"
+      channel_title = "fugafuga"
+      channel_link = "http://hoge.com"
+      channel_description = "fugafugafugafuga"
+      channel_author = "Bob"
+
+      image_url = "http://hoge.com/hoge.png"
+
+      item_title = "TITLE"
+      item_link = "http://hoge.com/"
+      item_description = "text hoge fuga"
+
+      entry_size = 5
+      feed = RSS::Maker.make("atom") do |maker|
+        maker.encoding = encoding
+        maker.standalone = standalone
+
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+          xss.type = type
+          xss.title = title
+          xss.media = media
+          xss.charset = charset
+          xss.alternate = alternate
+        end
+
+        maker.channel.about = channel_about
+        maker.channel.title = channel_title
+        maker.channel.link = channel_link
+        maker.channel.description = channel_description
+        maker.channel.author = channel_author
+        @dc_elems.each do |var, value|
+          maker.channel.__send__("dc_#{var}=", value)
+        end
+
+        maker.image.url = image_url
+
+        entry_size.times do |i|
+          maker.items.new_item do |item|
+            item.title = "#{item_title}#{i}"
+            item.link = "#{item_link}#{i}"
+            item.description = "#{item_description}#{i}"
+
+            @dc_elems.each do |var, value|
+              item.__send__("dc_#{var}=", value)
+            end
+          end
+        end
+      end
+
+      new_feed = RSS::Maker.make("atom") do |maker|
+        feed.setup_maker(maker)
+      end
+
+      assert_equal(["atom", "1.0", "feed"], new_feed.feed_info)
+      assert_equal(encoding, new_feed.encoding)
+      assert_equal(standalone, new_feed.standalone)
+
+      xss = new_feed.xml_stylesheets.first
+      assert_equal(1, new_feed.xml_stylesheets.size)
+      assert_equal(href, xss.href)
+      assert_equal(type, xss.type)
+      assert_equal(title, xss.title)
+      assert_equal(media, xss.media)
+      assert_equal(charset, xss.charset)
+      assert_equal(alternate, xss.alternate)
+
+      assert_equal(channel_title, new_feed.title.content)
+      assert_equal(channel_link, new_feed.link.href)
+      assert_equal(channel_description, new_feed.subtitle.content)
+      assert_equal(channel_author, new_feed.author.name.content)
+      assert_equal(image_url, new_feed.logo.content)
+      @dc_elems.each do |var, value|
+        assert_equal(value, new_feed.__send__("dc_#{var}"))
+      end
+
+      assert_equal(entry_size, new_feed.entries.size)
+      new_feed.entries.each_with_index do |entry, i|
+        assert_equal("#{item_title}#{i}", entry.title.content)
+        assert_equal("#{item_link}#{i}", entry.link.href)
+        assert_equal("#{item_description}#{i}", entry.summary.content)
+
+        @dc_elems.each do |var, value|
+          assert_equal(value, entry.__send__("dc_#{var}"))
+        end
+      end
+    end
+  end
+end
diff --git a/test/rss/test_syndication.rb b/test/rss/test_syndication.rb
index 894a7855ac..6aaaa43382 100644
--- a/test/rss/test_syndication.rb
+++ b/test/rss/test_syndication.rb
@@ -93,7 +93,7 @@ EOR
       
       %w(-2 0.3 -0.4).each do |x|
         @parents.each do |parent|
-          assert_not_available_value("updateBase", x) do
+          assert_not_available_value("sy:updateBase", x) do
             @rss.__send__(parent).sy_updateBase = x
           end
         end
@@ -107,7 +107,7 @@ EOR
         excepted = "<#{@prefix}:#{name}>#{value}</#{@prefix}:#{name}>"
         @parents.each do |parent|
           assert_equal(excepted,
-                       @rss.__send__(parent).funcall("sy_#{name}_element"))
+                       @rss.__send__(parent).__send!("sy_#{name}_element"))
         end
       end
       
@@ -120,8 +120,6 @@ EOR
           end
         end
       end
-      
     end
-  
   end
 end
diff --git a/test/rss/test_taxonomy.rb b/test/rss/test_taxonomy.rb
index b4950c0004..42746af490 100644
--- a/test/rss/test_taxonomy.rb
+++ b/test/rss/test_taxonomy.rb
@@ -140,7 +140,7 @@ EOR
     def test_to_s
       @topics_parents.each do |parent|
         meth = "taxo_topics_element"
-        assert_equal(@topics_node, @rss.__send__(parent).funcall(meth))
+        assert_equal(@topics_node, @rss.__send__(parent).__send!(meth))
       end
 
       @topic_nodes.each_with_index do |node, i|
diff --git a/test/rss/test_trackback.rb b/test/rss/test_trackback.rb
index 5209a8c06b..db4f291317 100644
--- a/test/rss/test_trackback.rb
+++ b/test/rss/test_trackback.rb
@@ -114,7 +114,7 @@ EOR
         @parents.each do |parent|
           meth = "#{RSS::TRACKBACK_PREFIX}_#{name}_element"
           meth << "s" if name == :about
-          assert_equal(excepted, @rss.__send__(parent).funcall(meth))
+          assert_equal(excepted, @rss.__send__(parent).__send!(meth))
         end
       end
       
diff --git a/test/rss/test_version.rb b/test/rss/test_version.rb
index 237f364b20..2c7d2e0f7a 100644
--- a/test/rss/test_version.rb
+++ b/test/rss/test_version.rb
@@ -3,7 +3,7 @@ require "rss-testcase"
 module RSS
   class TestVersion < TestCase
     def test_version
-      assert_equal("0.1.6", ::RSS::VERSION)
+      assert_equal("0.1.7", ::RSS::VERSION)
     end
   end
 end
diff --git a/test/rss/test_xml-stylesheet.rb b/test/rss/test_xml-stylesheet.rb
index c88a858f56..b946af1294 100644
--- a/test/rss/test_xml-stylesheet.rb
+++ b/test/rss/test_xml-stylesheet.rb
@@ -14,7 +14,7 @@ module RSS
         {:media => "print", :title => "FOO"},
         {:charset => "UTF-8", :alternate => "yes"},
       ].each do |attrs|
-        assert_xml_stylesheet_attrs(attrs, XMLStyleSheet.new(*attrs))
+        assert_xml_stylesheet_attrs(attrs, XMLStyleSheet.new(attrs))
       end
     end
     
@@ -35,8 +35,8 @@ module RSS
          :media => "printer", :charset => "UTF-8",
          :alternate => "yes"},
       ].each do |attrs|
-        target, contents = parse_pi(XMLStyleSheet.new(*attrs).to_s)
-        assert_xml_stylesheet(target, attrs, XMLStyleSheet.new(*contents))
+        target, contents = parse_pi(XMLStyleSheet.new(attrs).to_s)
+        assert_xml_stylesheet(target, attrs, XMLStyleSheet.new(contents))
       end
     end