require 'erb'

module RSS
  module Assertions
    def assert_parse(rss, assert_method, *args)
      __send__("assert_#{assert_method}", *args) do
        ::RSS::Parser.parse(rss)
      end
      __send__("assert_#{assert_method}", *args) do
        ::RSS::Parser.parse(rss, false).validate
      end
    end
    
    def assert_ns(prefix, uri)
      _wrap_assertion do
        begin
          yield
          flunk("Not raise NSError")
        rescue ::RSS::NSError => e
          assert_equal(prefix, e.prefix)
          assert_equal(uri, e.uri)
        end
      end
    end
    
    def assert_missing_tag(tag, parent)
      _wrap_assertion do
        begin
          yield
          flunk("Not raise MissingTagError")
        rescue ::RSS::MissingTagError => e
          assert_equal(tag, e.tag)
          assert_equal(parent, e.parent)
        end
      end
    end
    
    def assert_too_much_tag(tag, parent)
      _wrap_assertion do
        begin
          yield
          flunk("Not raise TooMuchTagError")
        rescue ::RSS::TooMuchTagError => e
          assert_equal(tag, e.tag)
          assert_equal(parent, e.parent)
        end
      end
    end
    
    def assert_missing_attribute(tag, attrname)
      _wrap_assertion do
        begin
          yield
          flunk("Not raise MissingAttributeError")
        rescue ::RSS::MissingAttributeError => e
          assert_equal(tag, e.tag)
          assert_equal(attrname, e.attribute)
        end
      end
    end
    
    def assert_not_expected_tag(tag, uri, parent)
      _wrap_assertion do
        begin
          yield
          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
    end
    
    def assert_not_available_value(tag, value, attribute=nil)
      _wrap_assertion do
        begin
          yield
          flunk("Not raise NotAvailableValueError")
        rescue ::RSS::NotAvailableValueError => e
          assert_equal(tag, e.tag)
          assert_equal(value, e.value)
          assert_equal(attribute, e.attribute)
        end
      end
    end

    def assert_not_set_error(name, variables)
      _wrap_assertion do
        begin
          yield
          flunk("Not raise NotSetError")
        rescue ::RSS::NotSetError => e
          assert_equal(name, e.name)
          assert_kind_of(Array, variables)
          assert_equal(variables.sort, e.variables.sort)
        end
      end
    end
    
    def assert_xml_declaration(version, encoding, standalone, rss)
      _wrap_assertion do
        assert_equal(version, rss.version)
        assert_equal(encoding, rss.encoding)
        assert_equal(standalone, rss.standalone)
      end
    end
    
    def assert_xml_stylesheet_attrs(attrs, xsl)
      _wrap_assertion do
        n_attrs = normalized_attrs(attrs)
        ::RSS::XMLStyleSheet::ATTRIBUTES.each do |name|
          assert_equal(n_attrs[name], xsl.__send__(name))
        end
      end
    end
    
    def assert_xml_stylesheet(target, attrs, xsl)
      _wrap_assertion do
        if attrs.has_key?(:href)
          if !attrs.has_key?(:type) and attrs.has_key?(:guess_type)
            attrs[:type] = attrs[:guess_type]
          end
          assert_equal("xml-stylesheet", target)
          assert_xml_stylesheet_attrs(attrs, xsl)
        else
          assert_nil(target)
          assert_equal("", xsl.to_s)
        end
      end
    end
    
    def assert_xml_stylesheet_pis(attrs_ary, rss=nil)
      _wrap_assertion do
        if rss.nil?
          rss = ::RSS::RDF.new
          setup_rss10(rss)
        end
        xss_strs = []
        attrs_ary.each do |attrs|
          xss = ::RSS::XMLStyleSheet.new(attrs)
          xss_strs.push(xss.to_s)
          rss.xml_stylesheets.push(xss)
        end
        pi_str = rss.to_s.gsub(/<\?xml .*\n/, "").gsub(/\s*<[^\?].*\z/m, "")
        assert_equal(xss_strs.join("\n"), pi_str)
      end
    end

    def assert_xml_stylesheets(attrs, xss)
      _wrap_assertion do
        xss.each_with_index do |xs, i|
          assert_xml_stylesheet_attrs(attrs[i], xs)
        end
      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
        type = "image/png"
        assert_parse(generator.call(<<-EOA), :nothing_raised)
  <content type="#{type}"/>
EOA

        png_file = File.join(File.dirname(__FILE__), "dot.png")
        png = File.open(png_file, "rb") {|file| file.read}
        base64_content = [png].pack("m")

        [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(png, 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
        elems.each do |name, value|
          assert_equal(value, target.__send__("dc_#{name}"))
        end
      end
    end
    
    def assert_multiple_dublin_core(elems, target)
      _wrap_assertion do
        elems.each do |name, values, plural|
          plural ||= "#{name}s"
          actual = target.__send__("dc_#{plural}").collect{|x| x.value}
          assert_equal(values, actual)
        end
      end
    end
    
    def assert_syndication(elems, target)
      _wrap_assertion do
        elems.each do |name, value|
          meth = "sy_#{name}"
          value = value.to_i if meth == "sy_updateFrequency"
          assert_equal(value, target.__send__(meth ))
        end
      end
    end
    
    def assert_content(elems, target)
      _wrap_assertion do
        elems.each do |name, value|
          assert_equal(value, target.__send__("content_#{name}"))
        end
      end
    end
    
    def assert_trackback(attrs, target)
      _wrap_assertion do
        n_attrs = normalized_attrs(attrs)
        if n_attrs["ping"]
          assert_equal(n_attrs["ping"], target.trackback_ping)
        end
        if n_attrs["abouts"]
          n_attrs["abouts"].each_with_index do |about, i|
            assert_equal(about, target.trackback_abouts[i].value)
          end
        end
      end
    end

    def assert_taxo_topic(topics, target)
      _wrap_assertion do
        topics.each_with_index do |topic, i|
          taxo_topic = target.taxo_topics[i]
          topic.each do |name, value|
            case name
            when :link
              assert_equal(value, taxo_topic.about)
              assert_equal(value, taxo_topic.taxo_link)
            when :topics
              assert_equal(value, taxo_topic.taxo_topics.resources)
            else
              assert_equal(value, taxo_topic.__send__("dc_#{name}"))
            end
          end
        end
      end
    end


    def assert_attributes(attrs, names, target)
      _wrap_assertion do
        n_attrs = normalized_attrs(attrs)
        names.each do |info|
          if info.is_a?(String)
            name = info
            type = nil
          else
            name, type = info
          end
          value = n_attrs[name]
          if value.is_a?(Time)
            actual = target.__send__(name)
            assert_instance_of(Time, actual)
            assert_equal(value.to_i, actual.to_i)
          elsif value
            case type
            when :integer
              value = value.to_i
            when :boolean
              value = value == "true" if value.is_a?(String)
            end
            assert_equal(value, target.__send__(name))
          end
        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_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
        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) {|x| x}
            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) {|x| x}
            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) {|x| x}
            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) {|x| x}
            target.type = "xhtml"
            target.content = "Content"
          end
        end

        _assert_maker_atom_text_construct(*args) do |maker|
          yield maker
          target = chain_reader(maker, maker_readers) {|x| x}
          target.type = "text"
          target.content = "Content"
        end

        _assert_maker_atom_text_construct(*args) do |maker|
          yield maker
          target = chain_reader(maker, maker_readers) {|x| x}
          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) {|x| x}
          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) {|x| x}
          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) {|x| x}
          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) {|x| x}
                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) {|x| x}
              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.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?,
        }
        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 assert_slash_elements(expected, target)
      assert_equal(expected,
                   {
                     "section" => target.slash_section,
                     "department" => target.slash_department,
                     "comments" => target.slash_comments,
                     "hit_parades" => target.slash_hit_parades,
                   })
      assert_equal(expected["hit_parades"].join(","),
                   target.slash_hit_parade)
    end

    def chain_reader(target, readers, &block)
      readers.inject(target) do |result, reader|
        return nil if result.nil?
        result.__send__(reader, &block)
      end
    end

    def normalized_attrs(attrs)
      n_attrs = {}
      attrs.each do |name, value|
        n_attrs[name.to_s] = value
      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

    def tag(name, content=nil, attributes={})
      attributes = attributes.collect do |key, value|
        "#{ERB::Util.h(key)}=\"#{ERB::Util.h(value)}\""
      end.join(" ")
      begin_tag = "<#{name}"
      begin_tag << " #{attributes}" unless attributes.empty?
      if content
        "#{begin_tag}>#{content}</#{name}>\n"
      else
        "#{begin_tag}/>\n"
      end
    end
  end
end
