rss 0.2.8 → 0.2.9

data/test/test_maker_slash.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: false
+require_relative "rss-testcase"
+
+require "rss/maker"
+
+module RSS
+  class TestMakerSlash < TestCase
+    def setup
+      @elements = {
+        "section" => "articles",
+        "department" => "not-an-ocean-unless-there-are-lobsters",
+        "comments" => 177,
+        "hit_parades" => [177, 155, 105, 33, 6, 3, 0],
+      }
+    end
+
+    def test_rss10
+      rss = RSS::Maker.make("1.0") do |maker|
+        setup_dummy_channel(maker)
+
+        setup_dummy_item(maker)
+        item = maker.items.last
+        @elements.each do |name, value|
+          item.send("slash_#{name}=", value)
+        end
+      end
+
+      item = rss.items.last
+      assert_not_nil(item)
+      assert_slash_elements(item)
+    end
+
+    private
+    def assert_slash_elements(target)
+      super(@elements, target)
+    end
+  end
+end

data/test/test_maker_sy.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: false
+require_relative "rss-testcase"
+
+require "rss/maker"
+
+module RSS
+  class TestMakerSyndication < TestCase
+
+    def setup
+      @uri = "http://purl.org/rss/1.0/modules/syndication/"
+
+      t = Time.iso8601("2000-01-01T12:00:05+00:00")
+      class << t
+        alias_method(:to_s, :iso8601)
+      end
+
+      @elements = {
+        :updatePeriod => "hourly",
+        :updateFrequency => "2",
+        :updateBase => t,
+      }
+    end
+
+    def test_rss10
+      rss = RSS::Maker.make("1.0") do |maker|
+        setup_dummy_channel(maker)
+        set_elements(maker.channel)
+        setup_dummy_item(maker)
+      end
+      assert_syndication(@elements, rss.channel)
+    end
+
+    private
+    def accessor_name(name)
+      "sy_#{name}"
+    end
+
+    def set_elements(target)
+      @elements.each do |name, value|
+        target.__send__("#{accessor_name(name)}=", value)
+      end
+    end
+
+  end
+end

data/test/test_maker_taxo.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: false
+require_relative "rss-testcase"
+
+require "rss/maker"
+
+module RSS
+  class TestMakerTaxonomy < TestCase
+
+    def setup
+      @uri = "http://purl.org/rss/1.0/modules/taxonomy/"
+
+      @resources = [
+        "http://meerkat.oreillynet.com/?c=cat23",
+        "http://meerkat.oreillynet.com/?c=47",
+        "http://dmoz.org/Computers/Data_Formats/Markup_Languages/XML/",
+      ]
+
+      @topics = [
+        {
+          :link => "http://meerkat.oreillynet.com/?c=cat23",
+          :title => "Data: XML",
+          :description => "A Meerkat channel",
+         },
+        {
+          :link => "http://dmoz.org/Computers/Data_Formats/Markup_Languages/XML/",
+          :title => "XML",
+          :subject => "XML",
+          :description => "DMOZ category",
+          :topics => [
+            "http://meerkat.oreillynet.com/?c=cat23",
+            "http://dmoz.org/Computers/Data_Formats/Markup_Languages/SGML/",
+            "http://dmoz.org/Computers/Programming/Internet/",
+          ]
+         },
+       ]
+    end
+
+    def test_rss10
+      rss = RSS::Maker.make("1.0") do |maker|
+        setup_dummy_channel(maker)
+        set_topics(maker.channel)
+
+        setup_dummy_item(maker)
+        set_topics(maker.items.last)
+
+        setup_taxo_topic(maker, @topics)
+      end
+      assert_equal(@resources, rss.channel.taxo_topics.resources)
+      assert_equal(@resources, rss.items.last.taxo_topics.resources)
+      assert_taxo_topic(@topics, rss)
+    end
+
+    def _test_date
+      t1 = Time.iso8601("2000-01-01T12:00:05+00:00")
+      t2 = Time.iso8601("2005-01-01T12:00:05+00:00")
+
+      rss = RSS::Maker.make("1.0") do |maker|
+        setup_dummy_channel(maker)
+        maker.channel.date = t1
+        maker.channel.dc_dates.new_date do |date|
+          date.value = t2
+        end
+
+        setup_dummy_item(maker)
+        item = maker.items.last
+        item.date = t2
+        item.dc_dates.new_date do |date|
+          date.value = t1
+        end
+      end
+      assert_equal([t1, t2], rss.channel.dc_dates.collect{|x| x.value})
+      assert_equal([t2, t1], rss.items.last.dc_dates.collect{|x| x.value})
+    end
+
+    private
+    def set_topics(target, resources=@resources)
+      resources.each do |value|
+        target.taxo_topics << value
+      end
+    end
+  end
+end

data/test/test_maker_trackback.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: false
+require_relative "rss-testcase"
+
+require "rss/maker"
+
+module RSS
+  class TestMakerTrackBack < TestCase
+
+    def setup
+      @uri = "http://madskills.com/public/xml/rss/module/trackback/"
+
+      @elements = {
+        :ping => "http://bar.com/tb.cgi?tb_id=rssplustrackback",
+        :abouts => [
+          "http://foo.com/trackback/tb.cgi?tb_id=20020923",
+          "http://bar.com/trackback/tb.cgi?tb_id=20041114",
+        ],
+      }
+    end
+
+    def test_rss10
+      rss = RSS::Maker.make("1.0") do |maker|
+        setup_dummy_channel(maker)
+
+        setup_dummy_item(maker)
+        item = maker.items.last
+        item.trackback_ping = @elements[:ping]
+        @elements[:abouts].each do |about|
+          item.trackback_abouts.new_about do |new_about|
+            new_about.value = about
+          end
+        end
+      end
+      assert_trackback(@elements, rss.items.last)
+    end
+
+    private
+    def accessor_name(name)
+      "trackback_#{name}"
+    end
+  end
+end

data/test/test_maker_xml-stylesheet.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: false
+require_relative "rss-testcase"
+
+require "rss/maker"
+
+module RSS
+  class TestMakerXMLStyleSheet < TestCase
+
+    def test_xml_stylesheet
+      href = 'a.xsl'
+      type = 'text/xsl'
+      title = 'sample'
+      media = 'printer'
+      charset = 'UTF-8'
+      alternate = 'yes'
+
+      rss = RSS::Maker.make("1.0") do |maker|
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+          xss.type = type
+          xss.title = title
+          xss.media = media
+          xss.charset = charset
+          xss.alternate = alternate
+        end
+
+        setup_dummy_channel(maker)
+        setup_dummy_item(maker)
+      end
+
+      xss = rss.xml_stylesheets.first
+      assert_equal(href, xss.href)
+      assert_equal(type, xss.type)
+      assert_equal(title, xss.title)
+      assert_equal(media, xss.media)
+      assert_equal(charset, xss.charset)
+      assert_equal(alternate, xss.alternate)
+
+
+      href = 'http://example.com/index.xsl'
+      type = 'text/xsl'
+      rss = RSS::Maker.make("1.0") do |maker|
+        maker.xml_stylesheets.new_xml_stylesheet do |_xss|
+          _xss.href = href
+        end
+
+        setup_dummy_channel(maker)
+        setup_dummy_item(maker)
+      end
+
+      xss = rss.xml_stylesheets.first
+      assert_equal(href, xss.href)
+      assert_equal(type, xss.type)
+    end
+
+    def test_not_valid_xml_stylesheet
+      href = 'xss.XXX'
+      type = "text/xsl"
+
+      rss = RSS::Maker.make("1.0") do |maker|
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          # xss.href = href
+          xss.type = type
+        end
+
+        setup_dummy_channel(maker)
+        setup_dummy_item(maker)
+      end
+      assert(rss.xml_stylesheets.empty?)
+
+      rss = RSS::Maker.make("1.0") do |maker|
+        maker.xml_stylesheets.new_xml_stylesheet do |xss|
+          xss.href = href
+          # xss.type = type
+        end
+
+        setup_dummy_channel(maker)
+        setup_dummy_item(maker)
+      end
+      assert(rss.xml_stylesheets.empty?)
+    end
+
+  end
+end

data/test/test_parser.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: false
+require "tempfile"
+
+require_relative "rss-testcase"
+
+require "rss/1.0"
+require "rss/dublincore"
+
+module RSS
+  class TestParser < TestCase
+    def setup
+      @_default_parser = Parser.default_parser
+      @rss10 = make_RDF(<<-EOR)
+#{make_channel}
+#{make_item}
+#{make_textinput}
+#{make_image}
+EOR
+      @rss_tmp = Tempfile.new(%w"rss10- .rdf")
+      @rss_tmp.print(@rss10)
+      @rss_tmp.close
+      @rss_file = @rss_tmp.path
+      @rss_file.untaint if RUBY_VERSION < '2.7'
+    end
+
+    def teardown
+      Parser.default_parser = @_default_parser
+      @rss_tmp.close(true)
+    end
+
+    def test_default_parser
+      assert_nothing_raised do
+        Parser.default_parser = RSS::AVAILABLE_PARSERS.first
+      end
+
+      assert_raise(RSS::NotValidXMLParser) do
+        Parser.default_parser = RSS::Parser
+      end
+    end
+
+    def test_parse
+      assert_not_nil(RSS::Parser.parse(@rss_file))
+
+      garbage_rss_file = @rss_file + "-garbage"
+      if RSS::Parser.default_parser.name == "RSS::XMLParserParser"
+        assert_raise(RSS::NotWellFormedError) do
+          RSS::Parser.parse(garbage_rss_file)
+        end
+      else
+        assert_nil(RSS::Parser.parse(garbage_rss_file))
+      end
+    end
+
+    def test_parse_tag_includes_hyphen
+      assert_nothing_raised do
+        RSS::Parser.parse(make_RDF(<<-EOR))
+<xCal:x-calconnect-venue xmlns:xCal="urn:ietf:params:xml:ns:xcal" />
+#{make_channel}
+#{make_item}
+#{make_textinput}
+#{make_image}
+EOR
+      end
+    end
+
+    def test_parse_option_validate_nil
+      assert_raise(RSS::MissingTagError) do
+        RSS::Parser.parse(make_RDF(<<-RDF), :validate => nil)
+        RDF
+      end
+    end
+
+    def test_parse_option_validate_true
+      assert_raise(RSS::MissingTagError) do
+        RSS::Parser.parse(make_RDF(<<-RDF), :validate => true)
+        RDF
+      end
+    end
+
+    def test_parse_option_validate_false
+      rdf = RSS::Parser.parse(make_RDF(<<-RDF), :validate => false)
+      RDF
+      assert_nil(rdf.channel)
+    end
+
+    def test_parse_option_ignore_unknown_element_nil
+      assert_nothing_raised do
+        RSS::Parser.parse(make_RDF(<<-RDF), :ignore_unknown_element => nil)
+<unknown/>
+#{make_channel}
+#{make_item}
+#{make_textinput}
+#{make_image}
+        RDF
+      end
+    end
+
+    def test_parse_option_ignore_unknown_element_true
+      assert_nothing_raised do
+        RSS::Parser.parse(make_RDF(<<-RDF), :ignore_unknown_element => true)
+<unknown/>
+#{make_channel}
+#{make_item}
+#{make_textinput}
+#{make_image}
+        RDF
+      end
+    end
+
+    def test_parse_option_ignore_unknown_element_false
+      assert_raise(RSS::NotExpectedTagError) do
+        RSS::Parser.parse(make_RDF(<<-RDF), :ignore_unknown_element => false)
+<unknown/>
+#{make_channel}
+#{make_item}
+#{make_textinput}
+#{make_image}
+        RDF
+      end
+    end
+  end
+end

data/test/test_parser_1.0.rb

@@ -0,0 +1,529 @@
+# frozen_string_literal: false
+require_relative "rss-testcase"
+
+require "rss/1.0"
+require "rss/dublincore"
+
+module RSS
+  class TestParser10 < TestCase
+    def test_RDF
+      assert_ns("", RDF::URI) do
+        Parser.parse(<<-EOR)
+#{make_xmldecl}
+<RDF/>
+EOR
+      end
+
+      assert_ns("", RDF::URI) do
+        Parser.parse(<<-EOR)
+#{make_xmldecl}
+<RDF xmlns="hoge"/>
+EOR
+      end
+
+      assert_ns("rdf", RDF::URI) do
+        Parser.parse(<<-EOR)
+#{make_xmldecl}
+<rdf:RDF xmlns:rdf="hoge"/>
+EOR
+      end
+
+      assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
+#{make_xmldecl}
+<rdf:RDF xmlns:rdf="#{RSS::RDF::URI}"/>
+EOR
+
+      assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
+#{make_xmldecl}
+<RDF xmlns="#{RSS::RDF::URI}"/>
+EOR
+
+      assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
+#{make_xmldecl}
+<RDF xmlns="#{RSS::RDF::URI}"/>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
+#{make_channel}
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
+#{make_channel}
+#{make_image}
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
+#{make_channel}
+#{make_textinput}
+EOR
+
+      assert_too_much_tag("image", "RDF") do
+        Parser.parse(make_RDF(<<-EOR))
+#{make_channel}
+#{make_image}
+#{make_image}
+#{make_item}
+#{make_textinput}
+EOR
+      end
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_item}
+#{make_image}
+#{make_textinput}
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_item}
+#{make_textinput}
+#{make_image}
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_image}
+#{make_item}
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_image}
+#{make_item}
+#{make_textinput}
+EOR
+
+      1.step(15, 3) do |i|
+        rss = make_RDF() do
+          res = make_channel
+          i.times { res << make_item }
+          res
+        end
+        assert_parse(rss, :nothing_raised)
+      end
+    end
+
+    def test_undefined_entity
+      return unless RSS::Parser.default_parser.raise_for_undefined_entity?
+      assert_parse(make_RDF(<<-EOR), :raises, RSS::NotWellFormedError)
+#{make_channel}
+#{make_image}
+<item rdf:about="#{RDF_ABOUT}">
+  <title>#{TITLE_VALUE} &UNKNOWN_ENTITY;</title>
+  <link>#{LINK_VALUE}</link>
+  <description>#{DESCRIPTION_VALUE}</description>
+</item>
+#{make_textinput}
+EOR
+    end
+
+    def test_channel
+      assert_parse(make_RDF(<<-EOR), :missing_attribute, "channel", "rdf:about")
+<channel />
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "channel")
+<channel rdf:about="http://example.com/"/>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "channel")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+</channel>
+EOR
+
+      assert_parse(make_RDF(<<EOR), :missing_tag, "description", "channel")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+</channel>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+</channel>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "rdf:resource")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image/>
+</channel>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image rdf:resource="http://example.com/hoge.png" />
+</channel>
+EOR
+
+      rss = make_RDF(<<-EOR)
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image rdf:resource="http://example.com/hoge.png" />
+  <items/>
+</channel>
+EOR
+
+      assert_missing_tag("Seq", "items") do
+        Parser.parse(rss)
+      end
+
+      assert_missing_tag("item", "RDF") do
+        Parser.parse(rss, false).validate
+      end
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image rdf:resource="http://example.com/hoge.png" />
+  <items>
+    <rdf:Seq>
+    </rdf:Seq>
+  </items>
+</channel>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "rdf:resource")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image rdf:resource="http://example.com/hoge.png" />
+  <items>
+    <rdf:Seq>
+    </rdf:Seq>
+  </items>
+  <textinput/>
+</channel>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image rdf:resource="http://example.com/hoge.png" />
+  <items>
+    <rdf:Seq>
+    </rdf:Seq>
+  </items>
+  <textinput rdf:resource="http://example.com/search" />
+</channel>
+EOR
+    end
+
+    def test_rdf_li
+      rss = make_RDF(<<-EOR)
+<channel rdf:about="http://example.com/">
+  <title>hoge</title>
+  <link>http://example.com/</link>
+  <description>hogehoge</description>
+  <image rdf:resource="http://example.com/hoge.png" />
+  <items>
+    <rdf:Seq>
+      <rdf:li \#{rdf_li_attr}/>
+    </rdf:Seq>
+  </items>
+  <textinput rdf:resource="http://example.com/search" />
+</channel>
+#{make_item}
+EOR
+
+      source = Proc.new do |rdf_li_attr|
+        eval(%Q[%Q[#{rss}]], binding)
+      end
+
+      attr = %q[resource="http://example.com/hoge"]
+      assert_parse(source.call(attr), :nothing_raised)
+
+      attr = %q[rdf:resource="http://example.com/hoge"]
+      assert_parse(source.call(attr), :nothing_raised)
+
+      assert_parse(source.call(""), :missing_attribute, "li", "resource")
+    end
+
+    def test_image
+      assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "rdf:about")
+#{make_channel}
+<image>
+</image>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "image")
+#{make_channel}
+<image rdf:about="http://example.com/hoge.png">
+</image>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "url", "image")
+#{make_channel}
+<image rdf:about="http://example.com/hoge.png">
+  <title>hoge</title>
+</image>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "image")
+#{make_channel}
+<image rdf:about="http://example.com/hoge.png">
+  <title>hoge</title>
+  <url>http://example.com/hoge.png</url>
+</image>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
+#{make_channel}
+<image rdf:about="http://example.com/hoge.png">
+  <title>hoge</title>
+  <url>http://example.com/hoge.png</url>
+  <link>http://example.com/</link>
+</image>
+EOR
+
+      rss = make_RDF(<<-EOR)
+#{make_channel}
+<image rdf:about="http://example.com/hoge.png">
+  <link>http://example.com/</link>
+  <url>http://example.com/hoge.png</url>
+  <title>hoge</title>
+</image>
+EOR
+
+      assert_missing_tag("item", "RDF") do
+        Parser.parse(rss)
+      end
+
+      assert_missing_tag("item", "RDF") do
+        Parser.parse(rss, false).validate
+      end
+    end
+
+    def test_item
+      assert_parse(make_RDF(<<-EOR), :missing_attribute, "item", "rdf:about")
+#{make_channel}
+#{make_image}
+<item>
+</item>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "item")
+#{make_channel}
+#{make_image}
+<item rdf:about="http://example.com/hoge.html">
+</item>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "item")
+#{make_channel}
+#{make_image}
+<item rdf:about="http://example.com/hoge.html">
+  <title>hoge</title>
+</item>
+EOR
+
+      assert_too_much_tag("title", "item") do
+        Parser.parse(make_RDF(<<-EOR))
+#{make_channel}
+#{make_image}
+<item rdf:about="http://example.com/hoge.html">
+  <title>hoge</title>
+  <title>hoge</title>
+  <link>http://example.com/hoge.html</link>
+</item>
+EOR
+      end
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_image}
+<item rdf:about="http://example.com/hoge.html">
+  <title>hoge</title>
+  <link>http://example.com/hoge.html</link>
+</item>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_image}
+<item rdf:about="http://example.com/hoge.html">
+  <title>hoge</title>
+  <link>http://example.com/hoge.html</link>
+  <description>hogehoge</description>
+</item>
+EOR
+    end
+
+    def test_textinput
+      assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "rdf:about")
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput>
+</textinput>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "textinput")
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput rdf:about="http://example.com/search.html">
+</textinput>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "description", "textinput")
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput rdf:about="http://example.com/search.html">
+  <title>hoge</title>
+</textinput>
+EOR
+
+      assert_too_much_tag("title", "textinput") do
+        Parser.parse(make_RDF(<<-EOR))
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput rdf:about="http://example.com/search.html">
+  <title>hoge</title>
+  <title>hoge</title>
+  <description>hogehoge</description>
+</textinput>
+EOR
+      end
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "name", "textinput")
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput rdf:about="http://example.com/search.html">
+  <title>hoge</title>
+  <description>hogehoge</description>
+</textinput>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "textinput")
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput rdf:about="http://example.com/search.html">
+  <title>hoge</title>
+  <description>hogehoge</description>
+  <name>key</name>
+</textinput>
+EOR
+
+      assert_parse(make_RDF(<<-EOR), :nothing_raised)
+#{make_channel}
+#{make_image}
+#{make_item}
+<textinput rdf:about="http://example.com/search.html">
+  <title>hoge</title>
+  <description>hogehoge</description>
+  <name>key</name>
+  <link>http://example.com/search.html</link>
+</textinput>
+EOR
+    end
+
+    def test_ignore
+      name = "a"
+      rss = make_RDF(<<-EOR)
+#{make_channel}
+#{make_item}
+<#{name}/>
+EOR
+      assert_not_expected_tag(name, ::RSS::URI, "RDF") do
+        Parser.parse(rss, true, false)
+      end
+
+      uri = ""
+      name = "a"
+      rss = make_RDF(<<-EOR)
+#{make_channel}
+#{make_item}
+<#{name} xmlns=""/>
+EOR
+      assert_parse(rss, :nothing_raised)
+      assert_not_expected_tag(name, uri, "RDF") do
+        Parser.parse(rss, true, false)
+      end
+
+      uri = "http://example.com/"
+      name = "a"
+      rss = make_RDF(<<-EOR)
+#{make_channel}
+#{make_item}
+<x:#{name} xmlns:x="#{uri}"/>
+EOR
+      assert_parse(rss, :nothing_raised)
+      assert_not_expected_tag(name, uri, "RDF") do
+        Parser.parse(rss, true, false)
+      end
+
+      uri = ::RSS::URI
+      name = "a"
+      rss = make_RDF(<<-EOR)
+#{make_channel}
+#{make_item}
+#{make_image("<#{name}/>")}
+EOR
+      assert_parse(rss, :nothing_raised)
+      assert_not_expected_tag(name, uri, "image") do
+        Parser.parse(rss, true, false)
+      end
+
+      uri = CONTENT_URI
+      name = "encoded"
+      elem = "<#{name} xmlns='#{uri}'/>"
+      rss = make_RDF(<<-EOR)
+#{make_channel}
+#{make_item}
+#{make_image(elem)}
+EOR
+      assert_parse(rss, :nothing_raised)
+      assert_not_expected_tag(name, uri, "image") do
+        Parser.parse(rss, true, false)
+      end
+    end
+
+    def test_unknown_duplicated_element
+      xmlns = {"test" => "http://localhost/test"}
+      assert_parse(make_RDF(<<-EOR, xmlns), :nothing_raised)
+        #{make_channel("<test:string/>")}
+        #{make_item}
+        #{make_image}
+      EOR
+    end
+
+    def test_unknown_case_insensitive_duplicated_element
+      xmlns = {
+        "foaf" => "http://xmlns.com/foaf/0.1/",
+        "dc" => "http://purl.org/dc/elements/1.1/",
+      }
+      assert_parse(make_RDF(<<-EOR, xmlns), :nothing_raised)
+        #{make_channel}
+        #{make_item}
+        #{make_image}
+        <foaf:Image rdf:about="http://example.com/myself.png">
+          <dc:title>Myself</dc:title>
+          <dc:link>http://example.com/</dc:link>
+        </foaf:Image>
+      EOR
+    end
+  end
+end
+