rss 0.2.8 → 0.2.9

data/test/test_accessor.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: false
+require_relative "rss-testcase"
+
+require "rss/1.0"
+require "rss/2.0"
+require "rss/syndication"
+require "rss/image"
+
+module RSS
+  class TestAccessor < TestCase
+    def test_date
+      channel = Rss::Channel.new
+      channel.pubDate = nil
+      assert_nil(channel.pubDate)
+
+      time = Time.now
+      channel.pubDate = time
+      assert_equal(time, channel.pubDate)
+
+      time = Time.parse(Time.now.rfc822)
+      channel.pubDate = time.rfc822
+      assert_equal(time, channel.pubDate)
+
+      time = Time.parse(Time.now.iso8601)
+      value = time.iso8601
+      assert_not_available_value("pubDate", value) do
+        channel.pubDate = value
+      end
+
+      channel.do_validate = false
+      time = Time.parse(Time.now.iso8601)
+      value = time.iso8601
+      channel.pubDate = value
+      assert_equal(time, channel.pubDate)
+
+      channel.pubDate = nil
+      assert_nil(channel.pubDate)
+    end
+
+    def test_integer
+      image_item = RDF::Item::ImageItem.new
+
+      image_item.width = nil
+      assert_nil(image_item.width)
+
+      width = 10
+      image_item.width = width
+      assert_equal(width, image_item.width)
+
+      width = 10.0
+      image_item.width = width
+      assert_equal(width, image_item.width)
+
+      width = "10"
+      image_item.width = width
+      assert_equal(width.to_i, image_item.width)
+
+      width = "10.0"
+      assert_not_available_value("image:width", width) do
+        image_item.width = width
+      end
+
+      image_item.do_validate = false
+      width = "10.0"
+      image_item.width = width
+      assert_equal(width.to_i, image_item.width)
+
+      image_item.width = nil
+      assert_nil(image_item.width)
+    end
+
+    def test_positive_integer
+      channel = RDF::Channel.new
+
+      channel.sy_updateFrequency = nil
+      assert_nil(channel.sy_updateFrequency)
+
+      freq = 10
+      channel.sy_updateFrequency = freq
+      assert_equal(freq, channel.sy_updateFrequency)
+
+      freq = 10.0
+      channel.sy_updateFrequency = freq
+      assert_equal(freq, channel.sy_updateFrequency)
+
+      freq = "10"
+      channel.sy_updateFrequency = freq
+      assert_equal(freq.to_i, channel.sy_updateFrequency)
+
+      freq = "10.0"
+      assert_not_available_value("sy:updateFrequency", freq) do
+        channel.sy_updateFrequency = freq
+      end
+
+      channel.do_validate = false
+      freq = "10.0"
+      channel.sy_updateFrequency = freq
+      assert_equal(freq.to_i, channel.sy_updateFrequency)
+
+      channel.sy_updateFrequency = nil
+      assert_nil(channel.sy_updateFrequency)
+    end
+  end
+end

data/test/test_atom.rb

@@ -0,0 +1,684 @@
+# frozen_string_literal: false
+require "rexml/document"
+
+require_relative "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
+
+      assert_equal(version, xmldecl.version)
+      assert_equal(encoding, xmldecl.encoding.to_s)
+      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
+
+      assert_equal(version, xmldecl.version)
+      assert_equal(encoding, xmldecl.encoding.to_s)
+      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(with_convenience_way=true)
+      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/"
+        if with_convenience_way
+          maker.channel.description = atom.title.content
+        else
+          maker.channel.description {|d| d.content = atom.title.content}
+        end
+
+        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/"
+        if with_convenience_way
+          maker.channel.description = atom.title.content
+        else
+          maker.channel.description {|d| d.content = atom.title.content}
+        end
+      end
+      rss20 = RSS::Parser.parse(rss20_xml)
+      assert_equal("2.0", rss20.rss_version)
+      assert_equal(["rss", "2.0", nil], rss20.feed_info)
+    end
+
+    def test_to_xml_with_new_api_since_018
+      test_to_xml(false)
+    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
+
+
+    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"
+        optvs = {
+          '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}=", optvs[name])
+          assert_equal("", link.to_s)
+
+          rest.each do |n|
+            link.__send__("#{n}=", optvs[n])
+            assert_equal("", link.to_s)
+          end
+
+          link = target_class.new
+          link.href = href
+          link.__send__("#{name}=", optvs[name])
+          attrs = [["href", href], [name, optvs[name]]]
+          xml = REXML::Document.new(link.to_s).root
+          assert_rexml_element([], attrs, nil, xml)
+
+          rest.each do |n|
+            link.__send__("#{n}=", optvs[n])
+            attrs << [n, optvs[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
+        type = "image/png"
+        png_file = File.join(File.dirname(__FILE__), "dot.png")
+        original_content = File.open(png_file, "rb") do |file|
+          file.read.force_encoding("binary")
+        end
+
+        content = target_class.new
+        content.type = type
+        content.content = original_content
+        xml = REXML::Document.new(content.to_s).root
+        assert_rexml_element([], {"type" => type},
+                             [original_content].pack("m").delete("\n"),
+                             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
+  end
+end